fix(spec): let defineSeed type a multi-value lookup as an array of keys

CI caught the other half of #3911: the RUNTIME resolved a natural-key array
fine, but `defineSeed`'s record typing still declared every lookup as
`string | null`, so authoring the array the loader now wants was a compile
error (`Type 'string[]' is not assignable to type 'string'`) — the showcase
seed added in the previous commit is exactly that case.

`SeedFieldValue` widens a `multiple: true` lookup to `string | string[] | null`.
A lone string stays legal there (the loader accepts it as one-element shorthand
for the array shape the field stores); `master_detail` is inherently single and
is not widened; an array on a single-value lookup and a wrapper object inside a
multi array both remain compile errors — the guard that comment promises is
intact, verified in both directions.

Reaching that required `Field.lookup` to stop widening its config: with
`config: FieldInput` the literal `multiple: true` collapses to `boolean` before
it ever reaches the seed type. It is now generic over a `const` type parameter,
with the return type intersected with `FieldInput` so the optional surface is
unchanged — narrowing to just the passed keys broke consumers that read
`.options` off a field union (app-todo). Type-level only; the returned object is
identical at runtime.

Repo-wide `pnpm -r typecheck` is clean.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Gusro3gdGv4wgbBnaFy9ah

Author: claude

.changeset/seed-loader-multi-value-lookup.md

@@ -29,3 +29,13 @@ rejected, now with advice an author can act on: declare the field
 `ReferenceResolution` (`@objectstack/spec/data`) gains an optional `multiple`
 flag carrying the field's array-ness into resolution; it is additive and
 defaulted-absent, so existing dependency graphs are unaffected.
+
+**Authoring types.** `defineSeed`'s per-field value type now widens a
+`multiple: true` lookup to `string | string[] | null` (a lone string stays legal
+— the loader accepts it as one-element shorthand). `master_detail` is inherently
+single and is not widened, and an array on a single-value lookup is still a
+compile error. To make that reachable, `Field.lookup` became generic over its
+config (`<const C extends FieldInput>`) so `multiple: true` survives as a
+literal instead of widening to `boolean`; the return type is intersected with
+`FieldInput` so its optional surface is unchanged. Type-level only — the
+returned object is byte-identical at runtime.

packages/spec/src/data/field.zod.ts

@@ -717,11 +717,25 @@ export const Field = {
   },
 
 
-  lookup: (reference: string, config: FieldInput = {}) => ({ 
-    type: 'lookup', 
-    reference, 
-    ...config 
-  } as const),
+  /**
+   * Lookup — a reference to another object's record.
+   *
+   * Generic over `config` (with a `const` type parameter) so literal values
+   * SURVIVE into the returned field definition. A plain `config: FieldInput`
+   * widens `multiple: true` to `boolean`, which erases exactly the fact
+   * `defineSeed` needs to know: a `multiple: true` lookup is seeded from an
+   * ARRAY of natural keys, a single-value one from a lone string
+   * (framework#3911). Widening is purely a type-level change — the returned
+   * object is identical at runtime.
+   */
+  lookup: <const C extends FieldInput>(
+    reference: string,
+    config: C = {} as C,
+  ): FieldInput & C & { readonly type: 'lookup'; readonly reference: string } => ({
+    type: 'lookup',
+    reference,
+    ...config,
+  } as FieldInput & C & { readonly type: 'lookup'; readonly reference: string }),
 
   masterDetail: (reference: string, config: FieldInput = {}) => ({
     type: 'master_detail',

packages/spec/src/data/seed.zod.ts

@@ -95,9 +95,19 @@ export type SeedImportMode = z.infer<typeof SeedMode>;
  * strings, bigints, buffers, and null" (silently masked on an always-empty
  * `:memory:` DB, fatal-looking on a persistent one). Constrain those fields to
  * `string | null` at compile time; every other field stays `unknown`.
+ *
+ * A `multiple: true` lookup is the one exception: it stores an ARRAY of ids, so
+ * it is seeded from an ARRAY of natural keys — one per element (framework#3911).
+ * A lone string stays legal there because the loader accepts it as one-element
+ * shorthand for the array shape the field stores. `master_detail` is inherently
+ * single-valued and so is never widened.
  */
 type SeedFieldValue<TFieldDef> =
-  TFieldDef extends { type: 'lookup' | 'master_detail' } ? string | null : unknown;
+  TFieldDef extends { type: 'lookup' | 'master_detail' }
+    ? TFieldDef extends { multiple: true }
+      ? string | string[] | null
+      : string | null
+    : unknown;
 
 /** Shape of a single seed record, derived from the object's field definitions. */
 type SeedRecord<TFields> = {