@@ -0,0 +1,18 @@
+---
+'@object-ui/core': patch
+'@object-ui/plugin-form': patch
+---
+
+fix(plugin-form): a create form offers a `state_machine`-governed select only the machine's `initialStates`, so no option on it ends in `invalid_initial_state`
+
+Clause-②: no
+Metadata-protocol: none
+
+An object's `state_machine` validation can declare `initialStates`, the values a new record may be created in; the server refuses an insert with any other value (`invalid_initial_state`). Create forms used to offer every option of that select anyway, so a user picking, say, `active` on the showcase "New Project + Tasks" form learned only from the refusal after submit that `planned` was the one value allowed.
+
+Now every create form layout (the in-page form, the master-detail header, the drawer, the dialog, the tabbed and wizard forms) offers such a select only its `initialStates`, through the same field gate that already narrows an edit form to the moves from the stored value. Two rules hold:
+
+- A machine that declares no `initialStates`, or that is `warning`/`info`, inactive or update-only, leaves the create form's options unconstrained, exactly where the server does not police the insert.
+- The value the form opens with (a seeded `default: true` option or the caller's pre-fill) stays offered even outside `initialStates`, so the form never silently drops what it was handed; the server's refusal still names it.
+
+`@object-ui/core` gains `stateMachineInitialValues(objectSchema, fieldName)`, the insert-side sibling of `stateMachineNextValues`.
@@ -97,6 +97,10 @@ renderer were removed (ADR-0050): use `tabbed`, or an
 
 Which fields an edit save sends, and which fields and line-item actions a caller is offered, is the same in the SDK and the Console. It is documented under [What an edit save writes](/docs/ui/forms#what-an-edit-save-writes).
 
+## What a state-machine select offers
+
+A select governed by the object's blocking `state_machine` validation offers only the values the server accepts. On an edit form that is the stored value plus its declared next states; on a create form it is the machine's `initialStates`, plus the value the form opens with (a `default: true` option or a caller's pre-fill), which is never dropped. A machine that declares no `initialStates`, or a `warning`, inactive or update-only one, leaves a create form's options as they are. Every form layout, the master-detail header included, applies the same rule.
+
 ## Field Types
 
 The plugin supports these field types:
 
@@ -59,6 +59,16 @@ test.beforeEach(async ({ page }) => {
   await expect(page.getByRole('heading', { name: 'New Project + Tasks' })).toBeVisible();
 });
 
+test('the status select offers only the state the server admits on create', async ({ page }) => {
+  // `project_status_flow` declares `initialStates: ['planned']`; every other
+  // option would be refused 400 `invalid_initial_state` (#27763).
+  await page.getByTestId('select-trigger-status').first().click();
+  await expect(page.getByTestId('select-option-planned').first()).toBeVisible();
+  for (const refused of ['active', 'on_hold', 'completed', 'cancelled']) {
+    await expect(page.getByTestId(`select-option-${refused}`)).toHaveCount(0);
+  }
+});
+
 test('Create stores the populated parent through one atomic batch', async ({ page, request }) => {
   const name = `E2E Project ${Date.now()}`;
   await page.locator('input[name="name"]').fill(name);
@@ -87,8 +97,8 @@ test('Create with a task line stores the child referencing the parent', async ({
   const name = `E2E MD ${Date.now()}`;
   await page.locator('input[name="name"]').fill(name);
   await fillLookup(page, 'account', 'North');
-  // `planned` is the only status `project_status_flow` admits on create; any
-  // other pick is refused 400 `invalid_initial_state`.
+  // `planned` is the only status `project_status_flow` admits on create, and
+  // the only one the select offers.
   await selectOption(page, 'status', 'planned');
   await expect(page.getByText('Northwind', { exact: false })).toBeVisible();
 
 
@@ -7,8 +7,11 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { stateMachineNextValues } from '../validators/state-machine-next-values';
-import { stateMachineNextValues as fromPackageRoot } from '../../index';
+import { stateMachineInitialValues, stateMachineNextValues } from '../validators/state-machine-next-values';
+import {
+  stateMachineInitialValues as fromPackageRootInitial,
+  stateMachineNextValues as fromPackageRoot,
+} from '../../index';
 
 // The showcase task's machine (examples/app-showcase task.object.ts).
 const transitions = {
@@ -117,3 +120,57 @@ describe('stateMachineNextValues', () => {
     expect(stateMachineNextValues(schema, 'status', 'backlog')).toBeNull();
   });
 });
+
+// The showcase project's machine (examples/app-showcase project.object.ts):
+// `initialStates` is the insert entry point (#27763).
+const withInitial = (rule: Record<string, unknown>) => ({
+  validations: [
+    {
+      type: 'state_machine',
+      field: 'status',
+      events: ['insert', 'update'],
+      initialStates: ['planned'],
+      transitions: { planned: ['active', 'cancelled'] },
+      ...rule,
+    },
+  ],
+});
+
+describe('stateMachineInitialValues', () => {
+  it('is published from the package root', () => {
+    expect(fromPackageRootInitial).toBe(stateMachineInitialValues);
+  });
+
+  it('offers the declared initialStates', () => {
+    expect(sorted(stateMachineInitialValues(withInitial({}), 'status'))).toEqual(['planned']);
+  });
+
+  it('reads absent events as the spec default, which covers insert', () => {
+    expect(sorted(stateMachineInitialValues(withInitial({ events: undefined }), 'status'))).toEqual(['planned']);
+  });
+
+  it('does not narrow when the rule declares no initialStates — the server does not police that insert', () => {
+    expect(stateMachineInitialValues(withInitial({ initialStates: undefined }), 'status')).toBeNull();
+    expect(stateMachineInitialValues(withInitial({ initialStates: [] }), 'status')).toBeNull();
+  });
+
+  it('does not narrow on a warning, inactive or update-only machine', () => {
+    expect(stateMachineInitialValues(withInitial({ severity: 'warning' }), 'status')).toBeNull();
+    expect(stateMachineInitialValues(withInitial({ active: false }), 'status')).toBeNull();
+    expect(stateMachineInitialValues(withInitial({ events: ['update'] }), 'status')).toBeNull();
+  });
+
+  it('does not narrow another field', () => {
+    expect(stateMachineInitialValues(withInitial({}), 'health')).toBeNull();
+  });
+
+  it('intersects several blocking rules on the same field', () => {
+    const schema = {
+      validations: [
+        { type: 'state_machine', field: 'status', initialStates: ['planned', 'active'], transitions: {} },
+        { type: 'state_machine', field: 'status', initialStates: ['active', 'on_hold'], transitions: {} },
+      ],
+    };
+    expect(sorted(stateMachineInitialValues(schema, 'status'))).toEqual(['active']);
+  });
+});
@@ -31,6 +31,7 @@ export {
 } from './object-validation-engine.js';
 
 // Not part of the deprecated engine: a presentation read of a declared
-// `state_machine` transition map, so a choice control offers only the moves
-// the server would accept (#25933). It imports nothing from the engine.
-export { stateMachineNextValues } from './state-machine-next-values.js';
+// `state_machine` transition map and entry point, so a choice control offers
+// only the moves (#25933) and initial states (#27763) the server would accept.
+// It imports nothing from the engine.
+export { stateMachineNextValues, stateMachineInitialValues } from './state-machine-next-values.js';
@@ -13,6 +13,8 @@
  * value, read from the object's served `validations`. A choice control (the
  * grid's inline editor, the record form's select, the board's columns) offers
  * only these, so it does not stage a move the server is bound to refuse.
+ * `stateMachineInitialValues` is the insert half: the values a NEW record may
+ * be created in (`initialStates`), which a create form offers (#27763).
  *
  * This is a PRESENTATION read of the declared transition map, not a client-side
  * enforcement path: it never judges a write, and the server's rule validator
@@ -25,9 +27,11 @@
  *  - only `severity: 'error'` rules (the spec default) — a `warning` / `info`
  *    machine never blocks the write, so every option stays offered;
  *  - only rules that are `active` (default `true`) and whose `events` cover
- *    `update` (default `['insert', 'update']`) — a move is an update;
+ *    the write (default `['insert', 'update']`) — a move is an update, a
+ *    create is an insert;
  *  - a from-state the transition map does not declare is unconstrained, as
- *    the server is lenient there;
+ *    the server is lenient there; so is an insert under a rule that declares
+ *    no `initialStates` (the server's legacy no-op);
  *  - several applicable rules on one field all have to pass, so their allowed
  *    sets intersect.
  *
@@ -42,26 +46,47 @@
 /** The spec's `events` default for a validation rule. */
 const DEFAULT_EVENTS: readonly string[] = ['insert', 'update'];
 
-/** A `state_machine` rule that refuses an invalid move on update. */
-function isBlockingUpdateMachine(
-  rule: unknown,
-  fieldName: string,
-): rule is { transitions: Record<string, unknown> } {
+/** A `state_machine` rule on `fieldName` that refuses an invalid `event` write. */
+function isBlockingMachine(rule: unknown, fieldName: string, event: 'insert' | 'update'): boolean {
   if (!rule || typeof rule !== 'object') return false;
   const r = rule as {
     type?: unknown;
     field?: unknown;
-    transitions?: unknown;
     active?: unknown;
     events?: unknown;
     severity?: unknown;
   };
   if (r.type !== 'state_machine' || r.field !== fieldName) return false;
-  if (!r.transitions || typeof r.transitions !== 'object') return false;
   if (r.active === false) return false;
   if ((r.severity ?? 'error') !== 'error') return false;
   const events = Array.isArray(r.events) && r.events.length > 0 ? r.events : DEFAULT_EVENTS;
-  return events.includes('update');
+  return events.includes(event);
+}
+
+/** A `state_machine` rule that refuses an invalid move on update. */
+function isBlockingUpdateMachine(
+  rule: unknown,
+  fieldName: string,
+): rule is { transitions: Record<string, unknown> } {
+  if (!isBlockingMachine(rule, fieldName, 'update')) return false;
+  const transitions = (rule as { transitions?: unknown }).transitions;
+  return !!transitions && typeof transitions === 'object';
+}
+
+/** A `state_machine` rule that refuses a create outside its `initialStates`. */
+function isBlockingInsertMachine(
+  rule: unknown,
+  fieldName: string,
+): rule is { initialStates: unknown[] } {
+  if (!isBlockingMachine(rule, fieldName, 'insert')) return false;
+  const initial = (rule as { initialStates?: unknown }).initialStates;
+  return Array.isArray(initial) && initial.length > 0;
+}
+
+/** Several applicable rules on one field all have to pass. */
+function intersect(sets: Set<string>[]): Set<string> | null {
+  if (sets.length === 0) return null;
+  return sets.reduce((acc, next) => new Set([...acc].filter((v) => next.has(v))));
 }
 
 /**
@@ -97,6 +122,30 @@ export function stateMachineNextValues(
     if (!Array.isArray(allowed)) continue;
     perRule.push(new Set<string>([from, ...allowed.map((s) => String(s))]));
   }
-  if (perRule.length === 0) return null;
-  return perRule.reduce((acc, next) => new Set([...acc].filter((v) => next.has(v))));
+  return intersect(perRule);
+}
+
+/**
+ * For a field governed by a blocking `state_machine` validation that declares
+ * `initialStates`, the set of values a NEW record may be created in — the
+ * machine's entry point, which the server enforces on insert.
+ *
+ * Returns `null` (= "don't constrain the options") when the object has no
+ * applicable rule for the field: none at all, only warning / inactive /
+ * update-only ones, or ones that declare no `initialStates` (the server does
+ * not police an insert under such a rule).
+ */
+export function stateMachineInitialValues(
+  objectSchema: unknown,
+  fieldName: string,
+): Set<string> | null {
+  const rules = (objectSchema as { validations?: unknown } | null | undefined)?.validations;
+  if (!Array.isArray(rules)) return null;
+
+  const perRule: Set<string>[] = [];
+  for (const rule of rules) {
+    if (!isBlockingInsertMachine(rule, fieldName)) continue;
+    perRule.push(new Set<string>(rule.initialStates.map((s) => String(s))));
+  }
+  return intersect(perRule);
 }
@@ -434,6 +434,24 @@ evaluator that resolves it — `resolveFieldRuleState`, reading
 `isServerOwnedValue`. Display and validation share that single verdict, so a
 field can never lose its asterisk while still refusing the submit.
 
+### What a state-machine select offers
+
+A select governed by a blocking `state_machine` validation (`severity: 'error'`,
+active, its `events` covering the write) offers only the values the server
+accepts, through the one field gate every layout draws through
+(`gateFormFields`):
+
+| Form | Offers |
+|---|---|
+| edit, record loaded | the stored value plus its declared next states (`stateMachineNextValues`) |
+| create, machine declares `initialStates` | those states (`stateMachineInitialValues`), plus the value the form opens with |
+| create, no `initialStates` | every option, as the server does not police that insert |
+
+The value a create form opens with (a `default: true` option, a `defaultValue`,
+or the caller's `initialValues` / `initialData`) stays offered even outside
+`initialStates`, so the form never silently drops a value it was handed; the
+server's refusal names it on save.
+
 ### Resolving `sections[].group` outside this package
 
 A form section declares its members exactly one way: it enumerates `fields`, or
 
@@ -284,6 +284,8 @@ const DrawerFormBody: React.FC<DrawerFormProps> = ({
         objectSchema,
         // The persisted record a `state_machine` select narrows by (#25933).
         previousValues: schema.mode === 'edit' && schema.recordId ? formData : undefined,
+        // The values a create form opens with, which stay offered (#27763).
+        openingValues: formData,
       }) as FormField[],
     [perms, schema.objectName, schema.mode, schema.recordId, objectSchema, formData],
   );
 
@@ -374,6 +374,8 @@ const ModalFormBody: React.FC<ModalFormProps> = ({
         objectSchema,
         // The persisted record a `state_machine` select narrows by (#25933).
         previousValues: schema.mode === 'edit' && schema.recordId ? formData : undefined,
+        // The values a create form opens with, which stay offered (#27763).
+        openingValues: formData,
       }) as FormField[],
     [perms, schema.objectName, schema.mode, schema.recordId, objectSchema, formData],
   );
 
@@ -609,21 +609,6 @@ const SimpleObjectForm: React.FC<{ schema: LocalizedObjectFormSchema; dataSource
     schema.mode === 'edit' && schema.recordId && initialData && typeof initialData === 'object'
       ? (initialData as Record<string, any>)
       : undefined;
-  // The ONE field-gate step every layout draws through (objectui#10612):
-  // field-level security plus the ADR-0092 D4 managed-object lock, which this
-  // arm's field generator used to stamp on its own — see `gateFormFields`.
-  const gateFields = useCallback(
-    (fields: FormField[]): FormField[] =>
-      gateFormFields(fields, {
-        perms,
-        objectName: schema.objectName,
-        mode: schema.mode,
-        objectSchema,
-        deniedDescription,
-        previousValues,
-      }) as FormField[],
-    [perms, schema.objectName, schema.mode, objectSchema, deniedDescription, previousValues],
-  );
   // objectui#11000 — why `gateFields` locked every field, when the lock is the
   // form-wide one: the affordance for the mode is closed. Rendered above the
   // fields by `ClosedAffordanceNotice`.
@@ -1195,6 +1180,24 @@ const SimpleObjectForm: React.FC<{ schema: LocalizedObjectFormSchema; dataSource
   // (objectui#12359), so both readers spell it through `formOpeningValues`.
   const finalDefaultValues = formOpeningValues(schemaDefaults, initialData);
 
+  // The ONE field-gate step every layout draws through (objectui#10612):
+  // field-level security plus the ADR-0092 D4 managed-object lock, which this
+  // arm's field generator used to stamp on its own — see `gateFormFields`.
+  const gateFields = useCallback(
+    (fields: FormField[]): FormField[] =>
+      gateFormFields(fields, {
+        perms,
+        objectName: schema.objectName,
+        mode: schema.mode,
+        objectSchema,
+        deniedDescription,
+        previousValues,
+        // What the form opens with stays offered on a create (#27763).
+        openingValues: finalDefaultValues,
+      }) as FormField[],
+    [perms, schema.objectName, schema.mode, objectSchema, deniedDescription, previousValues, finalDefaultValues],
+  );
+
   // Handle form submission
   const handleSubmit = useCallback(async (formData: any, e?: any) => {
     // An upload is still in flight (objectui#10166). A `file`/`image` value is