From 2d209cc8a5884c92eb61a2f995dcd7967f06fe13 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 8 Oct 2026 08:45:00 +0000
Subject: [PATCH 1/4] fix(plugin-form): a create form preselects the option a
 field marks default: true

A field that declares no `defaultValue` but marks one option
`default: true` opened on the "Select an option" placeholder, while a
create that omitted the field stored the marked option: the server's
insert path falls back to it since objectstack#7246. `schemaDefaultValues`,
the one function every create-form container seeds through, now reads the
option list the same way the engine's `resolveOptionDefault` does: only
when `defaultValue` is absent (== null), first marked option on a
single-valued field, every marked option as an array on a multi-valued one
(`isMultiValueField`). Edit forms and caller seeds are unchanged.

Claude-Session: https://claude.ai/code/session_01MgfduSkFrfM3eorB3UGfAU
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../optionDefaultSeed-11914.test.tsx          | 327 ++++++++++++++++++
 packages/plugin-form/src/schemaDefaults.ts    | 123 ++++++-
 2 files changed, 433 insertions(+), 17 deletions(-)
 create mode 100644 packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx

diff --git a/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx b/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
new file mode 100644
index 0000000000..b9125f44b5
--- /dev/null
+++ b/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
@@ -0,0 +1,327 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#11914 — a CREATE form preselects the option a field's option list
+ * marks `default: true`.
+ *
+ * Measured before the fix through the console's create dialog (the global
+ * `ModalForm`) on the objectstack tutorial's verbatim ticket object: Priority
+ * and Status, both required `select`s that mark one option `default: true` and
+ * declare no field-level `defaultValue`, opened on the "Select an option"
+ * placeholder. The form could not be submitted until the user picked the very
+ * values the metadata had already chosen — while the server, given the same
+ * create without those keys, stores the marked options.
+ *
+ * The server's rule is `ObjectQL.applyFieldDefaults` falling back to its
+ * `resolveOptionDefault` (objectstack#7246) when the field declares no
+ * `defaultValue`. The pins below are that rule, read from the client side:
+ *
+ *   - one marked option is preselected, and submitted without a manual pick;
+ *   - CONTROL: a field whose options mark nothing stays empty;
+ *   - a field-level `defaultValue` wins over the option flag — including a
+ *     runtime one, which the server resolves at insert and the form leaves
+ *     empty, so the flag is never seeded in its place;
+ *   - a single-valued field takes the FIRST marked option; a multi-valued one
+ *     takes every marked option, as an array;
+ *   - an explicit choice wins: the caller's seed, and the user's own pick;
+ *   - an EDIT form never applies it — the stored record is what it shows.
+ */
+
+import React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, fireEvent, waitFor, cleanup } from '@testing-library/react';
+import { registerAllFields } from '@object-ui/fields';
+import { schemaDefaultValues, seedCreateValues } from '../schemaDefaults';
+import { ModalForm } from '../ModalForm';
+import { ObjectForm } from '../ObjectForm';
+
+registerAllFields();
+
+/**
+ * The objectstack tutorial's ticket object (`build-with-claude-code.mdx`,
+ * step 3), as the server serves it: `Field.select` returns its config
+ * unchanged, so neither field carries a `defaultValue`.
+ */
+const TICKET = {
+  name: 'support_desk_ticket',
+  fields: {
+    subject: { type: 'text', label: 'Subject', required: true },
+    priority: {
+      type: 'select',
+      label: 'Priority',
+      required: true,
+      options: [
+        { label: 'Low', value: 'low', default: true },
+        { label: 'Normal', value: 'normal' },
+        { label: 'High', value: 'high' },
+        { label: 'Urgent', value: 'urgent' },
+      ],
+    },
+    status: {
+      type: 'select',
+      label: 'Status',
+      required: true,
+      options: [
+        { label: 'Open', value: 'open', color: '#3B82F6', default: true },
+        { label: 'Pending', value: 'pending', color: '#F59E0B' },
+        { label: 'Resolved', value: 'resolved', color: '#10B981' },
+        { label: 'Closed', value: 'closed', color: '#6B7280' },
+      ],
+    },
+    // CONTROL: options that mark nothing.
+    channel: {
+      type: 'select',
+      label: 'Channel',
+      options: [
+        { label: 'Email', value: 'email' },
+        { label: 'Phone', value: 'phone' },
+      ],
+    },
+  },
+};
+
+const makeDS = (objectSchema: unknown = TICKET, record?: unknown) =>
+  ({
+    getObjectSchema: vi.fn().mockResolvedValue(objectSchema),
+    create: vi.fn().mockResolvedValue({ id: 't1' }),
+    update: vi.fn().mockResolvedValue({ id: 't1' }),
+    findOne: vi.fn().mockResolvedValue(record ?? { id: 't1' }),
+  }) as any;
+
+const triggerText = (field: string) =>
+  document.body.querySelector(`[data-testid="select-trigger-${field}"]`)?.textContent ?? '';
+
+/** Radix renders a hidden native `<select>` inside a form; a pick through it
+ *  drives the same `onValueChange` a pointer pick does. */
+const nativeSelect = (field: string) =>
+  document.body.querySelector(`select[name="${field}"]`) as HTMLSelectElement | null;
+
+const submit = () => {
+  fireEvent.submit(document.body.querySelector('form') as HTMLFormElement);
+};
+
+beforeEach(() => vi.clearAllMocks());
+afterEach(() => cleanup());
+
+describe('schemaDefaultValues — an option marked `default: true` (objectui#11914)', () => {
+  const opts = (...marked: boolean[]) =>
+    marked.map((m, i) => ({ label: `O${i}`, value: `o${i}`, ...(m ? { default: true } : {}) }));
+
+  it('seeds the marked option of a field that declares no `defaultValue`', () => {
+    expect(schemaDefaultValues(TICKET)).toEqual({ priority: 'low', status: 'open' });
+  });
+
+  it('CONTROL: seeds nothing when no option is marked', () => {
+    const seeded = schemaDefaultValues({
+      fields: { channel: { type: 'select', options: opts(false, false) } },
+    });
+    expect(seeded).toEqual({});
+    expect('channel' in seeded).toBe(false);
+  });
+
+  it('lets a static field-level `defaultValue` win over the option flag', () => {
+    expect(
+      schemaDefaultValues({
+        fields: { s: { type: 'select', defaultValue: 'o1', options: opts(true, false) } },
+      }),
+    ).toEqual({ s: 'o1' });
+  });
+
+  it('never seeds the option in place of a RUNTIME `defaultValue` — the server resolves that one', () => {
+    const seeded = schemaDefaultValues({
+      fields: {
+        a: { type: 'select', defaultValue: 'NOW()', options: opts(true) },
+        b: { type: 'select', defaultValue: { dialect: 'cel', source: "'o0'" }, options: opts(true) },
+      },
+    });
+    expect(seeded).toEqual({});
+  });
+
+  it('falls back to the option when `defaultValue` is null — the engine\'s own presence test', () => {
+    expect(
+      schemaDefaultValues({
+        fields: { s: { type: 'select', defaultValue: null, options: opts(false, true) } },
+      }),
+    ).toEqual({ s: 'o1' });
+  });
+
+  it('takes the FIRST marked option on a single-valued field', () => {
+    expect(
+      schemaDefaultValues({ fields: { s: { type: 'select', options: opts(false, true, true) } } }),
+    ).toEqual({ s: 'o1' });
+  });
+
+  it('takes EVERY marked option, as an array, on a multi-valued field', () => {
+    expect(
+      schemaDefaultValues({
+        fields: {
+          tags: { type: 'multiselect', options: opts(true, false, true) },
+          // `select` + `multiple` is multi-valued by the same spec predicate.
+          picks: { type: 'select', multiple: true, options: opts(false, true, true) },
+          // One marked option on a multi-valued field is still an array.
+          one: { type: 'multiselect', options: opts(false, true) },
+        },
+      }),
+    ).toEqual({ tags: ['o0', 'o2'], picks: ['o1', 'o2'], one: ['o1'] });
+  });
+
+  it('skips a marked option that carries no value', () => {
+    expect(
+      schemaDefaultValues({
+        fields: { s: { type: 'select', options: [{ label: 'X', value: null, default: true }] } },
+      }),
+    ).toEqual({});
+  });
+
+  it('lets the caller\'s seed outrank the option flag', () => {
+    expect(seedCreateValues(TICKET, { status: 'pending' })).toEqual({
+      priority: 'low',
+      status: 'pending',
+    });
+  });
+});
+
+const renderModalCreate = (ds: any, extra: Record<string, unknown> = {}) =>
+  render(
+    <ModalForm
+      schema={{
+        type: 'object-form',
+        formType: 'modal',
+        objectName: 'support_desk_ticket',
+        mode: 'create',
+        open: true,
+        sections: [
+          { name: 'basics', label: 'Basics', fields: ['subject', 'priority', 'status', 'channel'] },
+        ],
+        ...extra,
+      } as any}
+      dataSource={ds}
+    />,
+  );
+
+describe('ModalForm (the console create dialog) — option defaults (objectui#11914)', () => {
+  it('opens the tutorial ticket with Priority and Status preselected, and submits them unpicked', async () => {
+    const ds = makeDS();
+    renderModalCreate(ds);
+
+    await waitFor(() => expect(triggerText('priority')).toContain('Low'));
+    expect(triggerText('status')).toContain('Open');
+
+    const subject = document.body.querySelector<HTMLInputElement>('[data-field="subject"] input');
+    fireEvent.change(subject as HTMLInputElement, { target: { value: 'Printer on fire' } });
+    submit();
+
+    await waitFor(() => expect(ds.create).toHaveBeenCalled());
+    expect(ds.create.mock.calls[0][1]).toMatchObject({ priority: 'low', status: 'open' });
+  });
+
+  it('CONTROL: leaves a select whose options mark nothing on its placeholder', async () => {
+    renderModalCreate(makeDS());
+
+    await waitFor(() => expect(triggerText('priority')).toContain('Low'));
+    expect(triggerText('channel')).not.toContain('Email');
+    expect(triggerText('channel')).not.toContain('Phone');
+  });
+
+  it('lets the user\'s own pick win over the preselected option', async () => {
+    const ds = makeDS();
+    renderModalCreate(ds, { initialData: { subject: 'Printer on fire' } });
+
+    await waitFor(() => expect(triggerText('status')).toContain('Open'));
+    await waitFor(() => expect(nativeSelect('status')).not.toBeNull());
+    fireEvent.change(nativeSelect('status') as HTMLSelectElement, { target: { value: 'pending' } });
+    await waitFor(() => expect(triggerText('status')).toContain('Pending'));
+
+    submit();
+    await waitFor(() => expect(ds.create).toHaveBeenCalled());
+    expect(ds.create.mock.calls[0][1]).toMatchObject({ priority: 'low', status: 'pending' });
+  });
+
+  it('lets a caller-supplied seed win over the preselected option', async () => {
+    renderModalCreate(makeDS(), { initialData: { status: 'resolved' } });
+
+    await waitFor(() => expect(triggerText('status')).toContain('Resolved'));
+    expect(triggerText('priority')).toContain('Low');
+  });
+
+  it('preselects every marked option of a multi-valued field', async () => {
+    const ds = makeDS({
+      name: 'support_desk_ticket',
+      fields: {
+        tags: {
+          type: 'multiselect',
+          label: 'Tags',
+          options: [
+            { label: 'Billing', value: 'billing', default: true },
+            { label: 'Bug', value: 'bug' },
+            { label: 'Urgent', value: 'urgent', default: true },
+          ],
+        },
+      },
+    });
+    renderModalCreate(ds, {
+      sections: [{ name: 'basics', label: 'Basics', fields: ['tags'] }],
+    });
+
+    const pressed = (value: string) =>
+      document.body
+        .querySelector(`[data-testid="multiselect-option-${value}"]`)
+        ?.getAttribute('aria-pressed');
+    await waitFor(() => expect(pressed('billing')).toBe('true'));
+    expect(pressed('urgent')).toBe('true');
+    expect(pressed('bug')).toBe('false');
+  });
+
+  it('does not apply the option flag to an EDIT form over the stored record', async () => {
+    // The stored row leaves `status` ABSENT — the case a leaking default
+    // would show up on (an explicit null would overwrite it either way).
+    const ds = makeDS(TICKET, { id: 't1', subject: 'Printer on fire' });
+    renderModalCreate(ds, { mode: 'edit', recordId: 't1' });
+
+    await waitFor(() => expect(ds.findOne).toHaveBeenCalled());
+    await waitFor(() => {
+      const el = document.body.querySelector<HTMLInputElement>('[data-field="subject"] input');
+      if (el?.value !== 'Printer on fire') throw new Error('record not loaded yet');
+    });
+    expect(triggerText('status')).not.toContain('Open');
+    expect(triggerText('priority')).not.toContain('Low');
+  });
+});
+
+describe('ObjectForm (the page-mode create form) — option defaults (objectui#11914)', () => {
+  it('opens the tutorial ticket with Priority and Status preselected', async () => {
+    render(
+      <ObjectForm
+        schema={{ type: 'object-form', objectName: 'support_desk_ticket', mode: 'create' } as any}
+        dataSource={makeDS()}
+      />,
+    );
+
+    await waitFor(() => expect(triggerText('priority')).toContain('Low'));
+    expect(triggerText('status')).toContain('Open');
+    expect(triggerText('channel')).not.toContain('Email');
+  });
+
+  it('does not apply the option flag to an EDIT form over the stored record', async () => {
+    const ds = makeDS(TICKET, { id: 't1', subject: 'Printer on fire' });
+    render(
+      <ObjectForm
+        schema={{ type: 'object-form', objectName: 'support_desk_ticket', mode: 'edit', recordId: 't1' } as any}
+        dataSource={ds}
+      />,
+    );
+
+    await waitFor(() => expect(ds.findOne).toHaveBeenCalled());
+    await waitFor(() => {
+      const el = document.body.querySelector<HTMLInputElement>('[data-field="subject"] input');
+      if (el?.value !== 'Printer on fire') throw new Error('record not loaded yet');
+    });
+    expect(triggerText('status')).not.toContain('Open');
+  });
+});
diff --git a/packages/plugin-form/src/schemaDefaults.ts b/packages/plugin-form/src/schemaDefaults.ts
index f502840f7e..a8807e5e63 100644
--- a/packages/plugin-form/src/schemaDefaults.ts
+++ b/packages/plugin-form/src/schemaDefaults.ts
@@ -30,18 +30,26 @@
  * empty, with a required marker, forcing the user to pick a value the system
  * already knew (and putting every neighbouring option one click away).
  *
- * ## Which spelling is honoured, and why only that one
- *
- * `field.defaultValue` — and deliberately NOT a select option's `default: true`,
- * even though `@objectstack/spec`'s `SelectOptionSchema` declares that key.
- * The reason is the producer, not taste: the server's insert path
- * (`ObjectQL.applyFieldDefaults`) resolves `field.defaultValue` and nothing
- * else, which is exactly why omitting the field from a create request stores
- * the declared default (measured on the reporting stack). A console that
- * additionally seeded from option-level `default` would preselect values the
- * server would never have applied — a second, UI-only default contract, which
- * is the renderer-side dialect AGENTS.md #0.1 forbids. If option-level
- * `default` is to mean "the initial value", that belongs at the producer.
+ * ## Which spellings are honoured: the producer's, in the producer's order
+ *
+ * Two declarations name a field's initial value, and this module reads both
+ * exactly as the server's insert path (`ObjectQL.applyFieldDefaults`) does —
+ * the form previews the value omitting the field would store, never a value
+ * of its own:
+ *
+ *   1. `field.defaultValue`, whenever it is present (`!= null`).
+ *   2. Otherwise, the option a field's option list marks `default: true`
+ *      (`@objectstack/spec`'s `SelectOptionSchema.default`). The engine falls
+ *      back to it since objectstack#7246 (`resolveOptionDefault`); see
+ *      {@link optionListDefault} for the rule, which mirrors that method.
+ *
+ * Until objectui#11914 this module read (1) only, on the then-true ground
+ * that the server read nothing else — so the tutorial's required `priority`
+ * and `status` selects, which mark an option and declare no `defaultValue`,
+ * opened on the placeholder while a create that omitted them stored the
+ * marked options. The producer moved; the reading follows it. A flag the
+ * server does NOT apply (an option marked beside a present `defaultValue`)
+ * is not seeded either, so there is still exactly one default contract.
  *
  * ## Which defaults are seeded, and why the rest are skipped
  *
@@ -76,7 +84,7 @@
  */
 
 import { isMissingForRequired, isRuntimeDefault } from '@object-ui/core';
-import { isCurrentUserDefaultToken } from '@objectstack/spec/data';
+import { isCurrentUserDefaultToken, isMultiValueField } from '@objectstack/spec/data';
 
 // Re-exported (not re-implemented) so this package's long-standing import site
 // keeps working while there is exactly ONE classifier in the workspace. It
@@ -87,7 +95,11 @@ export { isRuntimeDefault };
 
 /**
  * An object schema as the data source serves it (`{ fields: { [name]: def } }`),
- * narrowed to the four field members THIS module's rule reads.
+ * narrowed to `defaultValue` and the two members the `current_user` seed reads
+ * (`type`, `reference`). The keys the option-list fallback reads
+ * (objectui#11914) sit on the package-local `SeedFieldLike` below instead: no
+ * published function reads them, and every member added here is published
+ * surface somebody then has to keep.
  *
  * Exported and published (objectui#7324) because `omitServerResolvedDefaults`
  * is published and this is its second parameter: a host with its own form
@@ -115,6 +127,28 @@ export interface FieldDefaultsSchemaLike {
   >;
 }
 
+/**
+ * One field as the SEEDING half of this module reads it: the published
+ * {@link FieldDefaultsSchemaLike} member set plus the two keys the option-list
+ * fallback reads (objectui#11914) — `options`, and `multiple` for the arity.
+ *
+ * Package-local, and derived from the published type rather than restating
+ * it: seeding is not on the package entry (`schemaDefaultValues` and
+ * `seedCreateValues` are withheld, see `index.tsx`), so the keys only it reads
+ * stay off the published shape, whose members are pinned to what the
+ * published pair reads (`parameterTypesNameable-7324.test.ts`). Every value of
+ * the published type is still a value of this one.
+ */
+type SeedFieldLike = NonNullable<NonNullable<FieldDefaultsSchemaLike['fields']>[string]> & {
+  options?: unknown;
+  multiple?: unknown;
+};
+
+/** An object schema as the seeding half reads it — see {@link SeedFieldLike}. */
+interface SeedSchemaLike {
+  fields?: Record<string, SeedFieldLike | undefined>;
+}
+
 /**
  * The session facts create-form seeding may draw on (#5683). Callers thread it
  * from `usePermissions()`; every key is optional so existing call sites keep
@@ -213,13 +247,15 @@ export function isRequiredInForm(
 }
 
 /**
- * The static `defaultValue`s an object schema declares, as a form-values patch.
+ * The static defaults an object schema declares, as a form-values patch: each
+ * field's `defaultValue`, or — for a field that declares none — the option its
+ * option list marks `default: true` ({@link optionListDefault}).
  *
  * Returns a fresh object (never shared), and `{}` for a missing/!object schema
  * so callers can spread it unconditionally.
  */
 export function schemaDefaultValues(
-  objectSchema: FieldDefaultsSchemaLike | null | undefined,
+  objectSchema: SeedSchemaLike | null | undefined,
   ctx?: SeedContext,
 ): Record<string, unknown> {
   const fields = objectSchema?.fields;
@@ -243,11 +279,64 @@ export function schemaDefaultValues(
       // anonymous) the field seeds nothing and the pre-#5683 contract holds:
       // empty control, key omitted, server resolves.
       defaults[name] = ctx.currentUserId;
+    } else if (dv == null) {
+      // objectui#11914 — no `defaultValue`, so the option list speaks. The
+      // `== null` gate is the engine's own presence test (`applyFieldDefaults`
+      // reaches `resolveOptionDefault` only through `f.defaultValue == null`),
+      // which is what keeps a runtime `defaultValue` — skipped above, resolved
+      // by the server at insert — from being replaced here by a flag the
+      // server never applies to that field.
+      const fromOptions = optionListDefault(f);
+      if (fromOptions !== undefined) defaults[name] = fromOptions;
     }
   }
   return defaults;
 }
 
+/**
+ * The value a field's option list declares as its initial value — the option
+ * marked `default: true` — or `undefined` when it marks none (objectui#11914).
+ *
+ * The client reading of `ObjectQL.resolveOptionDefault` (objectstack#7246),
+ * rule for rule, so a create form preselects exactly what omitting the field
+ * would store:
+ *
+ *   - **Only `default === true`, on the canonical key.** The authoring aliases
+ *     (`isDefault`, `selected`) are normalized by `SelectOptionSchema` before
+ *     metadata is served, and the engine reads the canonical key alone.
+ *   - **A marked option with no value declares nothing** and is skipped.
+ *   - **Single-valued: the FIRST marked option wins** — the schema does not
+ *     dedupe the flag, so declaration order decides.
+ *   - **Multi-valued: every marked option, as an array** — even one, since the
+ *     field stores an array. Arity is `@objectstack/spec`'s `isMultiValueField`,
+ *     the one predicate the engine asks too (`declaredMultiValued`), ⛔ never a
+ *     raw `multiple` read: `multiselect` stores an array without the flag.
+ *
+ * Not gated on `type: 'select'`, as the engine's is not: `options` is a
+ * field-level key, and a field the server defaults must not open empty here.
+ */
+function optionListDefault(field: SeedFieldLike | undefined): unknown {
+  const options = field?.options;
+  if (!Array.isArray(options)) return undefined;
+  const marked: unknown[] = [];
+  for (const option of options as unknown[]) {
+    if (!isMarkedOption(option)) continue;
+    if (option.value === undefined || option.value === null) continue;
+    marked.push(option.value);
+  }
+  if (marked.length === 0) return undefined;
+  const multiValued = isMultiValueField({
+    type: typeof field?.type === 'string' ? field.type : '',
+    multiple: field?.multiple === true,
+  });
+  return multiValued ? marked : marked[0];
+}
+
+/** Is this option-list entry an object marked `default: true`? */
+function isMarkedOption(option: unknown): option is { value?: unknown; default: true } {
+  return typeof option === 'object' && option !== null && 'default' in option && option.default === true;
+}
+
 /**
  * Is this field one the `current_user` token may legally default — and does it
  * declare that token?
@@ -277,7 +366,7 @@ function isCurrentUserSeedField(
  * "leave this blank", not an absence.
  */
 export function seedCreateValues(
-  objectSchema: FieldDefaultsSchemaLike | null | undefined,
+  objectSchema: SeedSchemaLike | null | undefined,
   initial?: Record<string, unknown> | null,
   ctx?: SeedContext,
 ): Record<string, unknown> {

From a8ee7a562ad57dd4fabc048d1b022679f928d699 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 8 Oct 2026 08:45:26 +0000
Subject: [PATCH 2/4] docs(plugin-form): the create-defaults table reads an
 option's default: true

The README said an option's `default: true` leaves a create form empty
because the server reads `defaultValue` alone. The server falls back to the
marked option, and the form now does too, so the table row and the
paragraph under it state the rule the form applies. Adds the patch
changeset for the fix.

Claude-Session: https://claude.ai/code/session_01MgfduSkFrfM3eorB3UGfAU
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/11914-select-option-default.md | 17 +++++++++++++++++
 packages/plugin-form/README.md            | 21 ++++++++++++---------
 2 files changed, 29 insertions(+), 9 deletions(-)
 create mode 100644 .changeset/11914-select-option-default.md

diff --git a/.changeset/11914-select-option-default.md b/.changeset/11914-select-option-default.md
new file mode 100644
index 0000000000..0efb2fb34d
--- /dev/null
+++ b/.changeset/11914-select-option-default.md
@@ -0,0 +1,17 @@
+---
+'@object-ui/plugin-form': patch
+---
+
+A create form preselects the option a field's option list marks `default: true` (objectui#11914).
+
+A `select` field that declares no `defaultValue` but marks one option `default: true` opened on the "Select an option" placeholder in every object-form container, the console's create dialog included. The server stores the marked option when a create omits the field, so the objectstack tutorial's Create Ticket form showed Priority and Status empty and could not be submitted until the user picked the values the metadata had already chosen.
+
+The create form now reads the option list the way the server's insert path does:
+
+- only when the field declares no `defaultValue`. A field-level default, static or runtime, always wins, and the option flag is then not seeded;
+- a single-valued field takes the first marked option;
+- a multi-valued field (`multiselect`, or `select` with `multiple: true`) takes every marked option, as an array.
+
+A value the caller seeds or the user picks still wins. Edit forms are unchanged: they show the stored record.
+
+Nothing is added to the package entry: no export, prop or type member.
diff --git a/packages/plugin-form/README.md b/packages/plugin-form/README.md
index 417dfd05df..224ec430c7 100644
--- a/packages/plugin-form/README.md
+++ b/packages/plugin-form/README.md
@@ -273,7 +273,8 @@ the form looks validated while validating nothing.
 ### What a create form opens with
 
 A create form has no persisted record, so its opening values come from the
-object schema's declared field `defaultValue`s. Every object-form container
+object schema's declared defaults: a field's `defaultValue`, or the option its
+option list marks `default: true`. Every object-form container
 (`ObjectForm`, `ModalForm`, `DrawerForm`, `TabbedForm`, `SplitForm`,
 `WizardForm`) resolves them the same way, through `schemaDefaults`:
 
@@ -282,20 +283,22 @@ object schema's declared field `defaultValue`s. Every object-form container
 | `defaultValue: 'draft'` (any static literal) | `draft`, preselected and submittable | the value is known; making the user pick it is busywork, and on a status-like field every wrong option is one click away |
 | `defaultValue: 'NOW()'` / `'current_user'` (a runtime token) | empty | the token is an *instruction*, not a value. The server resolves it at insert — but only for fields that arrive empty, so seeding the literal text would suppress it |
 | `defaultValue: cel\`today()\`` (an Expression envelope) | empty | same reason: the server evaluates it per insert |
-| an option's `default: true` | empty | see below |
+| an option's `default: true`, and no `defaultValue` | that option, preselected and submittable | the server stores the marked option when the field is omitted; see below |
 | nothing | empty | no default is invented |
 
 `initialData` / `initialValues` passed by the caller always outrank a schema
 default — a lookup prefill or a "duplicate this record" seed is the more
 specific instruction.
 
-Only the **field-level** `defaultValue` is read, never a select option's
-`default: true`, even though `@objectstack/spec`'s `SelectOptionSchema` declares
-that key. The server's insert path resolves `defaultValue` and nothing else, so
-a form that also seeded from option-level `default` would preselect values the
-server would never have applied on its own — a renderer-side second default
-contract (AGENTS.md #0.1). If option-level `default` is meant to mean "the
-initial value", that belongs at the producer.
+An option's `default: true` is read the way the server's insert path reads it
+(`ObjectQL.applyFieldDefaults`, which falls back to the marked option), so the
+form preselects exactly what omitting the field would store:
+
+- only when the field declares no `defaultValue` — a field-level default,
+  static or runtime, always wins, and the flag is then not seeded at all;
+- a single-valued field takes the **first** marked option;
+- a multi-valued field (`@objectstack/spec`'s `isMultiValueField`: `multiselect`,
+  or `select` with `multiple: true`) takes **every** marked option, as an array.
 
 **Edit forms are never seeded.** An edit form shows the row as the server holds
 it; folding a default in over a column the record leaves unset would arm a

From 27be779f7915b36b3650108ca0045ba69318db57 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 8 Oct 2026 09:03:25 +0000
Subject: [PATCH 3/4] test(plugin-form): type the option-default pin's schemas
 and data-source double

Drops the `as any` casts from the new pin: the container schemas are
typed by `ModalFormSchema` and `ObjectFormSchema`, and the data-source
double is a named partial.

Claude-Session: https://claude.ai/code/session_01MgfduSkFrfM3eorB3UGfAU
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../optionDefaultSeed-11914.test.tsx          | 40 ++++++++++---------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx b/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
index b9125f44b5..e266a2e136 100644
--- a/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
+++ b/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
@@ -37,8 +37,9 @@ import React from 'react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render, fireEvent, waitFor, cleanup } from '@testing-library/react';
 import { registerAllFields } from '@object-ui/fields';
+import type { DataSource, ObjectFormSchema } from '@object-ui/types';
 import { schemaDefaultValues, seedCreateValues } from '../schemaDefaults';
-import { ModalForm } from '../ModalForm';
+import { ModalForm, type ModalFormSchema } from '../ModalForm';
 import { ObjectForm } from '../ObjectForm';
 
 registerAllFields();
@@ -86,13 +87,17 @@ const TICKET = {
   },
 };
 
-const makeDS = (objectSchema: unknown = TICKET, record?: unknown) =>
-  ({
+/** A partial data-source double: the four methods these forms call. */
+const makeDS = (objectSchema: unknown = TICKET, record?: unknown) => {
+  const mocks = {
     getObjectSchema: vi.fn().mockResolvedValue(objectSchema),
     create: vi.fn().mockResolvedValue({ id: 't1' }),
     update: vi.fn().mockResolvedValue({ id: 't1' }),
     findOne: vi.fn().mockResolvedValue(record ?? { id: 't1' }),
-  }) as any;
+  };
+  return { ...mocks, dataSource: mocks as unknown as DataSource };
+};
+type MockDS = ReturnType<typeof makeDS>;
 
 const triggerText = (field: string) =>
   document.body.querySelector(`[data-testid="select-trigger-${field}"]`)?.textContent ?? '';
@@ -187,7 +192,7 @@ describe('schemaDefaultValues — an option marked `default: true` (objectui#119
   });
 });
 
-const renderModalCreate = (ds: any, extra: Record<string, unknown> = {}) =>
+const renderModalCreate = (ds: MockDS, extra: Partial<ModalFormSchema> = {}) =>
   render(
     <ModalForm
       schema={{
@@ -200,8 +205,8 @@ const renderModalCreate = (ds: any, extra: Record<string, unknown> = {}) =>
           { name: 'basics', label: 'Basics', fields: ['subject', 'priority', 'status', 'channel'] },
         ],
         ...extra,
-      } as any}
-      dataSource={ds}
+      }}
+      dataSource={ds.dataSource}
     />,
   );
 
@@ -296,12 +301,8 @@ describe('ModalForm (the console create dialog) — option defaults (objectui#11
 
 describe('ObjectForm (the page-mode create form) — option defaults (objectui#11914)', () => {
   it('opens the tutorial ticket with Priority and Status preselected', async () => {
-    render(
-      <ObjectForm
-        schema={{ type: 'object-form', objectName: 'support_desk_ticket', mode: 'create' } as any}
-        dataSource={makeDS()}
-      />,
-    );
+    const schema: ObjectFormSchema = { type: 'object-form', objectName: 'support_desk_ticket', mode: 'create' };
+    render(<ObjectForm schema={schema} dataSource={makeDS().dataSource} />);
 
     await waitFor(() => expect(triggerText('priority')).toContain('Low'));
     expect(triggerText('status')).toContain('Open');
@@ -310,12 +311,13 @@ describe('ObjectForm (the page-mode create form) — option defaults (objectui#1
 
   it('does not apply the option flag to an EDIT form over the stored record', async () => {
     const ds = makeDS(TICKET, { id: 't1', subject: 'Printer on fire' });
-    render(
-      <ObjectForm
-        schema={{ type: 'object-form', objectName: 'support_desk_ticket', mode: 'edit', recordId: 't1' } as any}
-        dataSource={ds}
-      />,
-    );
+    const schema: ObjectFormSchema = {
+      type: 'object-form',
+      objectName: 'support_desk_ticket',
+      mode: 'edit',
+      recordId: 't1',
+    };
+    render(<ObjectForm schema={schema} dataSource={ds.dataSource} />);
 
     await waitFor(() => expect(ds.findOne).toHaveBeenCalled());
     await waitFor(() => {

From 6da0e6e0b048a886987369bb353ff0601b8d57af Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 8 Oct 2026 09:12:24 +0000
Subject: [PATCH 4/4] test(plugin-form): pin two more engine-parity cases of
 the option default

A `multiple` flag on a type outside the multi-valued sets keeps the
seeded default a scalar, and an option whose value is spelled
`current_user` seeds that literal, never the acting user's id: both
are what the engine stores for an omitted field.

Claude-Session: https://claude.ai/code/session_01MgfduSkFrfM3eorB3UGfAU
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../optionDefaultSeed-11914.test.tsx          | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx b/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
index e266a2e136..5fab502bc8 100644
--- a/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
+++ b/packages/plugin-form/src/__tests__/optionDefaultSeed-11914.test.tsx
@@ -176,6 +176,31 @@ describe('schemaDefaultValues — an option marked `default: true` (objectui#119
     ).toEqual({ tags: ['o0', 'o2'], picks: ['o1', 'o2'], one: ['o1'] });
   });
 
+  it('keeps the default a scalar when `multiple` sits on a type outside the multi-valued sets', () => {
+    // `isMultiValueField` calls `text` single-valued whatever the flag says,
+    // and the engine stores a scalar for it — so the form seeds one too.
+    expect(
+      schemaDefaultValues({
+        fields: { t: { type: 'text', multiple: true, options: opts(true, true) } },
+      }),
+    ).toEqual({ t: 'o0' });
+  });
+
+  it('seeds an option spelled `current_user` as that literal value, never the acting user', () => {
+    // An option value is a picklist literal, not a runtime token: the engine
+    // stores the twelve characters, so the form previews the same.
+    expect(
+      schemaDefaultValues(
+        {
+          fields: {
+            s: { type: 'select', options: [{ label: 'Me', value: 'current_user', default: true }] },
+          },
+        },
+        { currentUserId: 'u42' },
+      ),
+    ).toEqual({ s: 'current_user' });
+  });
+
   it('skips a marked option that carries no value', () => {
     expect(
       schemaDefaultValues({