@lunora/seed 1.0.0-alpha.3 → 1.0.0-alpha.30

package/LICENSE.md

@@ -103,3 +103,9 @@ Unless required by applicable law or agreed to in writing, software distributed
 under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
+
+<!-- DEPENDENCIES -->
+<!-- /DEPENDENCIES -->
+
+<!-- TYPE_DEPENDENCIES -->
+<!-- /TYPE_DEPENDENCIES -->

package/dist/index.d.mts

@@ -1,20 +1,20 @@
 import { Schema } from '@lunora/server';
-import { O as OverrideContext } from "./packem_shared/plan.d-BQ6LiWIk.mjs";
-export { type S as SeedCounts, type a as SeedOptions, type b as SeedOverrides, type T as TablePlan, s as seedPlan } from "./packem_shared/plan.d-BQ6LiWIk.mjs";
+import { O as OverrideContext } from "./packem_shared/plan.d-SaRxbrrI.mjs";
+export { type S as SeedCounts, type a as SeedOptions, type b as SeedOverrides, type T as TablePlan, s as seedPlan } from "./packem_shared/plan.d-SaRxbrrI.mjs";
 /**
-* A typed, schema-aware seed client — the ergonomic DX layer over {@link seedPlan}.
-*
-* Where `seedPlan` generates every table at once, the client lets you author one
-* table at a time, with autocomplete on each table's columns and live foreign-key
-* connection to whatever was seeded earlier this run. Pass your generated
-* `InsertModel` type as the type argument — or let `lunora/_generated/seed.ts`
-* do that for you — for full type inference on each table's columns.
-*
-* The client is deterministic (same `seed` ⇒ same rows and ids) and pure unless a
-* `persist` hook is supplied, in which case each generated batch is also written
-* through it (the test harness, an admin import, …). Because every row carries an
-* explicit `_id`, the returned ids are known whether or not anything is persisted.
-*/
+ * A typed, schema-aware seed client — the ergonomic DX layer over {@link seedPlan}.
+ *
+ * Where `seedPlan` generates every table at once, the client lets you author one
+ * table at a time, with autocomplete on each table's columns and live foreign-key
+ * connection to whatever was seeded earlier this run. Pass your generated
+ * `InsertModel` type as the type argument — or let `lunora/_generated/seed.ts`
+ * do that for you — for full type inference on each table's columns.
+ *
+ * The client is deterministic (same `seed` ⇒ same rows and ids) and pure unless a
+ * `persist` hook is supplied, in which case each generated batch is also written
+ * through it (the test harness, an admin import, …). Because every row carries an
+ * explicit `_id`, the returned ids are known whether or not anything is persisted.
+ */
 /** Picks a concrete count: a fixed number, or a deterministic value within `[min, max]`. */
 type CountHelper = (countOrRange: number | readonly [number, number]) => number;
 /** The per-call population spec: a count, an inclusive range, explicit partial rows, or a count callback. */
@@ -23,10 +23,10 @@ type SeedSpec<Row> = number | ReadonlyArray<Partial<Row>> | readonly [number, nu
 type FieldOverride<Value> = ((context: OverrideContext) => Value) | Value;
 /** Options for a single table call. `overrides` win over any explicit partial rows. */
 interface SeedCallOptions<Row> {
-  overrides?: { [K in keyof Row]?: FieldOverride<Row[K]> };
+  overrides?: { [K in keyof Row]?: FieldOverride<Row[K]>; };
 }
 /** The id columns the client emits, keyed by table — the result of a single table call. */
-type SeedCallResult<InsertModel, Table extends keyof InsertModel> = { [K in Table]: string[] };
+type SeedCallResult<InsertModel, Table extends keyof InsertModel> = { [K in Table]: string[]; };
 /** The seeder function exposed for one table. */
 type TableSeeder<InsertModel, Table extends keyof InsertModel> = (spec?: SeedSpec<InsertModel[Table]>, options?: SeedCallOptions<InsertModel[Table]>) => Promise<SeedCallResult<InsertModel, Table>>;
 /** The `$`-prefixed run state shared by every client. */
@@ -39,7 +39,7 @@ interface SeedClientState {
   readonly $store: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
 }
 /** The per-table seeder methods plus the `$`-prefixed run state. */
-type SeedClient<InsertModel> = SeedClientState & { [Table in keyof InsertModel]: TableSeeder<InsertModel, Table> };
+type SeedClient<InsertModel> = SeedClientState & { [Table in keyof InsertModel]: TableSeeder<InsertModel, Table>; };
 /** Options for {@link createSeedClient}. */
 interface SeedClientOptions {
   /** Default row count when a table call passes no spec (default `10`). */
@@ -50,15 +50,15 @@ interface SeedClientOptions {
   seed?: number;
 }
 /**
-* Create a typed seed client for `schema`. Each table is a method; call it with a
-* count, a range, or explicit partial rows, and its foreign keys connect to rows
-* seeded earlier this run. State accumulates on `$store`/`$ids` and clears with
-* `$reset()`.
-* @example
-* const seed = createSeedClient<InsertModel>(schema, { seed: 1 });
-* const { users } = await seed.users(5);
-* const { posts } = await seed.posts((x) => x([10, 20]));
-* // posts.authorId values are drawn from `users`.
-*/
+ * Create a typed seed client for `schema`. Each table is a method; call it with a
+ * count, a range, or explicit partial rows, and its foreign keys connect to rows
+ * seeded earlier this run. State accumulates on `$store`/`$ids` and clears with
+ * `$reset()`.
+ * @example
+ * const seed = createSeedClient<InsertModel>(schema, { seed: 1 });
+ * const { users } = await seed.users(5);
+ * const { posts } = await seed.posts((x) => x([10, 20]));
+ * // posts.authorId values are drawn from `users`.
+ */
 declare const createSeedClient: <InsertModel = Record<string, Record<string, unknown>>>(schema: Schema, options?: SeedClientOptions) => SeedClient<InsertModel>;
 export { type CountHelper, type OverrideContext, type SeedCallOptions, type SeedCallResult, type SeedClient, type SeedClientOptions, type SeedSpec, createSeedClient };

package/dist/index.d.ts

@@ -1,20 +1,20 @@
 import { Schema } from '@lunora/server';
-import { O as OverrideContext } from "./packem_shared/plan.d-BQ6LiWIk.js";
-export { type S as SeedCounts, type a as SeedOptions, type b as SeedOverrides, type T as TablePlan, s as seedPlan } from "./packem_shared/plan.d-BQ6LiWIk.js";
+import { O as OverrideContext } from "./packem_shared/plan.d-SaRxbrrI.js";
+export { type S as SeedCounts, type a as SeedOptions, type b as SeedOverrides, type T as TablePlan, s as seedPlan } from "./packem_shared/plan.d-SaRxbrrI.js";
 /**
-* A typed, schema-aware seed client — the ergonomic DX layer over {@link seedPlan}.
-*
-* Where `seedPlan` generates every table at once, the client lets you author one
-* table at a time, with autocomplete on each table's columns and live foreign-key
-* connection to whatever was seeded earlier this run. Pass your generated
-* `InsertModel` type as the type argument — or let `lunora/_generated/seed.ts`
-* do that for you — for full type inference on each table's columns.
-*
-* The client is deterministic (same `seed` ⇒ same rows and ids) and pure unless a
-* `persist` hook is supplied, in which case each generated batch is also written
-* through it (the test harness, an admin import, …). Because every row carries an
-* explicit `_id`, the returned ids are known whether or not anything is persisted.
-*/
+ * A typed, schema-aware seed client — the ergonomic DX layer over {@link seedPlan}.
+ *
+ * Where `seedPlan` generates every table at once, the client lets you author one
+ * table at a time, with autocomplete on each table's columns and live foreign-key
+ * connection to whatever was seeded earlier this run. Pass your generated
+ * `InsertModel` type as the type argument — or let `lunora/_generated/seed.ts`
+ * do that for you — for full type inference on each table's columns.
+ *
+ * The client is deterministic (same `seed` ⇒ same rows and ids) and pure unless a
+ * `persist` hook is supplied, in which case each generated batch is also written
+ * through it (the test harness, an admin import, …). Because every row carries an
+ * explicit `_id`, the returned ids are known whether or not anything is persisted.
+ */
 /** Picks a concrete count: a fixed number, or a deterministic value within `[min, max]`. */
 type CountHelper = (countOrRange: number | readonly [number, number]) => number;
 /** The per-call population spec: a count, an inclusive range, explicit partial rows, or a count callback. */
@@ -23,10 +23,10 @@ type SeedSpec<Row> = number | ReadonlyArray<Partial<Row>> | readonly [number, nu
 type FieldOverride<Value> = ((context: OverrideContext) => Value) | Value;
 /** Options for a single table call. `overrides` win over any explicit partial rows. */
 interface SeedCallOptions<Row> {
-  overrides?: { [K in keyof Row]?: FieldOverride<Row[K]> };
+  overrides?: { [K in keyof Row]?: FieldOverride<Row[K]>; };
 }
 /** The id columns the client emits, keyed by table — the result of a single table call. */
-type SeedCallResult<InsertModel, Table extends keyof InsertModel> = { [K in Table]: string[] };
+type SeedCallResult<InsertModel, Table extends keyof InsertModel> = { [K in Table]: string[]; };
 /** The seeder function exposed for one table. */
 type TableSeeder<InsertModel, Table extends keyof InsertModel> = (spec?: SeedSpec<InsertModel[Table]>, options?: SeedCallOptions<InsertModel[Table]>) => Promise<SeedCallResult<InsertModel, Table>>;
 /** The `$`-prefixed run state shared by every client. */
@@ -39,7 +39,7 @@ interface SeedClientState {
   readonly $store: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
 }
 /** The per-table seeder methods plus the `$`-prefixed run state. */
-type SeedClient<InsertModel> = SeedClientState & { [Table in keyof InsertModel]: TableSeeder<InsertModel, Table> };
+type SeedClient<InsertModel> = SeedClientState & { [Table in keyof InsertModel]: TableSeeder<InsertModel, Table>; };
 /** Options for {@link createSeedClient}. */
 interface SeedClientOptions {
   /** Default row count when a table call passes no spec (default `10`). */
@@ -50,15 +50,15 @@ interface SeedClientOptions {
   seed?: number;
 }
 /**
-* Create a typed seed client for `schema`. Each table is a method; call it with a
-* count, a range, or explicit partial rows, and its foreign keys connect to rows
-* seeded earlier this run. State accumulates on `$store`/`$ids` and clears with
-* `$reset()`.
-* @example
-* const seed = createSeedClient<InsertModel>(schema, { seed: 1 });
-* const { users } = await seed.users(5);
-* const { posts } = await seed.posts((x) => x([10, 20]));
-* // posts.authorId values are drawn from `users`.
-*/
+ * Create a typed seed client for `schema`. Each table is a method; call it with a
+ * count, a range, or explicit partial rows, and its foreign keys connect to rows
+ * seeded earlier this run. State accumulates on `$store`/`$ids` and clears with
+ * `$reset()`.
+ * @example
+ * const seed = createSeedClient<InsertModel>(schema, { seed: 1 });
+ * const { users } = await seed.users(5);
+ * const { posts } = await seed.posts((x) => x([10, 20]));
+ * // posts.authorId values are drawn from `users`.
+ */
 declare const createSeedClient: <InsertModel = Record<string, Record<string, unknown>>>(schema: Schema, options?: SeedClientOptions) => SeedClient<InsertModel>;
 export { type CountHelper, type OverrideContext, type SeedCallOptions, type SeedCallResult, type SeedClient, type SeedClientOptions, type SeedSpec, createSeedClient };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-export { createSeedClient } from './packem_shared/createSeedClient-CI9LRLTi.mjs';
-export { s as seedPlan } from './packem_shared/plan-DirmkctQ.mjs';
+export { createSeedClient } from './packem_shared/createSeedClient-CZuGqXLm.mjs';
+export { s as seedPlan } from './packem_shared/plan-DybYaa3F.mjs';

package/dist/packem_shared/{createSeedClient-CI9LRLTi.mjs → createSeedClient-CZuGqXLm.mjs}

@@ -1,4 +1,4 @@
-import { a as setHashKey, s as seedPlan, c as copycat } from './plan-DirmkctQ.mjs';
+import { a as setHashKey, s as seedPlan, c as copycat } from './plan-DybYaa3F.mjs';
 
 const isRange = (spec) => Array.isArray(spec) && spec.length === 2 && typeof spec[0] === "number" && typeof spec[1] === "number";
 const resolveSpec = (spec, table, seed, defaultCount) => {
@@ -35,7 +35,7 @@ const createSeedClient = (schema, options = {}) => {
   const store = {};
   const idsByTable = {};
   const createdCount = {};
-  const seedTable = async (table, spec, callOptions) => {
+  const runSeedTable = async (table, spec, callOptions) => {
     setHashKey(seed);
     const { count, partials } = resolveSpec(spec, table, seed, defaultCount);
     const offset = createdCount[table] ?? 0;
@@ -64,6 +64,15 @@ const createSeedClient = (schema, options = {}) => {
     }
     return { [table]: created };
   };
+  let queue = Promise.resolve();
+  const seedTable = (table, spec, callOptions) => {
+    const result = queue.then(() => runSeedTable(table, spec, callOptions));
+    queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
   const state = {
     $ids: idsByTable,
     $reset: () => {

package/dist/packem_shared/{plan-DirmkctQ.mjs → plan-DybYaa3F.mjs}

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { faker } from '@faker-js/faker';
 import { optionalInner } from '@lunora/values';
 
@@ -288,7 +289,7 @@ const orderTables = (specs, selected) => {
   }
   return ordered;
 };
-const fkParentClosure = (specs, roots) => {
+const fkParentClosure = (specs, roots, stopAt = /* @__PURE__ */ new Set()) => {
   const byName = new Map(specs.map((spec) => [spec.name, spec]));
   const result = new Set(roots);
   const stack = [...result];
@@ -301,6 +302,9 @@ const fkParentClosure = (specs, roots) => {
     if (spec === void 0) {
       continue;
     }
+    if (stopAt.has(name)) {
+      continue;
+    }
     for (const field of spec.fields) {
       if (field.fkTable !== void 0 && field.fkTable !== name && byName.has(field.fkTable) && !result.has(field.fkTable)) {
         result.add(field.fkTable);
@@ -334,7 +338,8 @@ const generateString = (fieldName, input, constraints) => {
   const value = rule === void 0 ? copycat.word(input) : rule.generate(input);
   const { maxLength, minLength } = constraints;
   if (maxLength !== void 0 && minLength !== void 0 && minLength > maxLength) {
-    throw new Error(
+    throw new LunoraError(
+      "INTERNAL",
       `Seed constraint error for field "${fieldName}": minLength (${String(minLength)}) > maxLength (${String(maxLength)}). Adjust the schema constraints.`
     );
   }
@@ -384,16 +389,28 @@ const generateValue = (validator, fieldName, input) => {
       return null;
     }
     case "number": {
-      return copycat.int(input, { max: constraints.maximum ?? 1e3, min: constraints.minimum ?? 0 });
+      const { maximum, minimum } = constraints;
+      if (maximum !== void 0 && minimum !== void 0 && minimum > maximum) {
+        throw new LunoraError(
+          "INTERNAL",
+          `Seed constraint error for field "${fieldName}": minimum (${String(minimum)}) > maximum (${String(maximum)}). Adjust the schema constraints.`
+        );
+      }
+      const min = minimum ?? 0;
+      const max = maximum ?? 1e3;
+      if (!Number.isInteger(min) || !Number.isInteger(max)) {
+        return copycat.float(input, { max, min });
+      }
+      return copycat.int(input, { max, min });
     }
     case "object": {
       const shape = metaOf(inner).shape ?? {};
       return Object.fromEntries(Object.entries(shape).map(([key, child]) => [key, generateValue(child, key, [input, key])]));
     }
     case "record": {
-      const { valueValidator } = metaOf(inner);
+      const { keyValidator, valueValidator } = metaOf(inner);
       const entries = copycat.times(input, [1, 3], (itemInput) => {
-        const key = copycat.word(["k", itemInput]);
+        const key = keyValidator === void 0 ? copycat.word(["k", itemInput]) : String(generateValue(keyValidator, fieldName, ["k", itemInput]));
         const value = valueValidator === void 0 ? copycat.word(["v", itemInput]) : generateValue(valueValidator, fieldName, ["v", itemInput]);
         return [key, value];
       });
@@ -447,8 +464,20 @@ const seedPlan = (schema, options = {}) => {
   const { counts = {}, defaultCount = 10, existingIds = {}, indexOffset = {}, only, overrides = {}, seed = 0 } = options;
   setHashKey(seed);
   const specs = introspectSchema(schema);
+  if (only !== void 0) {
+    const known = new Set(specs.map((spec) => spec.name));
+    for (const name of only) {
+      if (!known.has(name)) {
+        const available = specs.map((spec) => spec.name).join(", ");
+        throw new LunoraError("BAD_REQUEST", `unknown table "${name}" in seed \`only\` — schema defines: ${available || "(no tables)"}`);
+      }
+    }
+  }
   const requested = new Set(only ?? specs.map((spec) => spec.name));
-  const selected = new Set([...fkParentClosure(specs, requested)].filter((table) => requested.has(table) || (existingIds[table] ?? []).length === 0));
+  const covered = new Set(Object.keys(existingIds).filter((table) => !requested.has(table) && (existingIds[table] ?? []).length > 0));
+  const selected = new Set(
+    [...fkParentClosure(specs, requested, covered)].filter((table) => requested.has(table) || (existingIds[table] ?? []).length === 0)
+  );
   const order = orderTables(specs, selected);
   const specByName = new Map(specs.map((spec) => [spec.name, spec]));
   const idsByTable = /* @__PURE__ */ new Map();

package/dist/packem_shared/plan.d-SaRxbrrI.d.mts

@@ -0,0 +1,78 @@
+import { Schema } from '@lunora/server';
+/**
+ * The pure, I/O-free core of seeding. {@link seedPlan} introspects a schema,
+ * generates rows table-by-table in foreign-key order, and resolves every
+ * `v.id("parent")` column to a real id of an already-generated parent row. The
+ * result feeds every adapter (test harness, CLI, studio) — none of them
+ * re-implement generation.
+ *
+ * Determinism: a `seed` value selects the global copycat mapping, and each value
+ * is hashed from `[seed, table, index, field]`, so the same `(schema, options)`
+ * always yields byte-identical rows.
+ */
+/** A row context handed to an override function. */
+interface OverrideContext {
+  field: string;
+  /** The row's absolute index (the `indexOffset` base plus its position in this batch). */
+  index: number;
+  /** The row built so far (system `_id` first, then earlier fields). */
+  row: Record<string, unknown>;
+  /**
+   * A live, read-only view of every table's rows generated so far this run,
+   * keyed by table name. Lets an override correlate across tables (e.g. copy a
+   * field from the parent row a foreign key points at). Rows for the current
+   * table accumulate as they are built, so only earlier rows are visible.
+   */
+  store: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
+  table: string;
+}
+/**
+ * Per-table, per-field overrides. Each override is a static value or a function
+ * of the row context; field `_id` overrides the generated primary key.
+ */
+type SeedOverrides = Record<string, Record<string, unknown>>;
+/** Per-table row counts. */
+type SeedCounts = Record<string, number>;
+interface SeedOptions {
+  /** Rows per table; falls back to {@link SeedOptions.defaultCount} when a table is absent. */
+  counts?: SeedCounts;
+  /** Count used for any selected table not present in `counts` (default `10`). */
+  defaultCount?: number;
+  /**
+   * Ids of rows that already exist in the target store, keyed by table. Foreign
+   * keys may resolve to these in addition to freshly-seeded parents, and a
+   * parent table fully covered here is not re-seeded when it is only pulled in
+   * as an FK dependency (it is when named explicitly in `only`).
+   */
+  existingIds?: Readonly<Record<string, ReadonlyArray<string>>>;
+  /**
+   * Per-table absolute index base for generation. Defaults to `0`. A client
+   * seeding the same table across several calls passes the running total so
+   * each batch hashes from fresh indices and never collides ids with an
+   * earlier batch.
+   */
+  indexOffset?: Readonly<Record<string, number>>;
+  /**
+   * Restrict seeding to these tables. Transitive `v.id(...)` parents are added
+   * automatically (unless already covered by `existingIds`) so child foreign
+   * keys resolve to real rows. The result is still ordered by FK dependency.
+   * Default: all tables.
+   */
+  only?: ReadonlyArray<string>;
+  /** Static values or functions overriding generated columns. */
+  overrides?: SeedOverrides;
+  /** Deterministic mapping selector — same seed ⇒ same rows. Default `0`. */
+  seed?: number;
+}
+/** One table's generated rows, in insert order. Each row carries an explicit `_id`. */
+interface TablePlan {
+  rows: ReadonlyArray<Record<string, unknown>>;
+  table: string;
+}
+/**
+ * Build a deterministic, FK-consistent set of rows for `schema`.
+ * @returns one {@link TablePlan} per seeded table, ordered so a table's FK
+ * parents come before it.
+ */
+declare const seedPlan: (schema: Schema, options?: SeedOptions) => ReadonlyArray<TablePlan>;
+export { OverrideContext as O, SeedCounts as S, TablePlan as T, SeedOptions as a, SeedOverrides as b, seedPlan as s };

package/dist/packem_shared/plan.d-SaRxbrrI.d.ts

@@ -0,0 +1,78 @@
+import { Schema } from '@lunora/server';
+/**
+ * The pure, I/O-free core of seeding. {@link seedPlan} introspects a schema,
+ * generates rows table-by-table in foreign-key order, and resolves every
+ * `v.id("parent")` column to a real id of an already-generated parent row. The
+ * result feeds every adapter (test harness, CLI, studio) — none of them
+ * re-implement generation.
+ *
+ * Determinism: a `seed` value selects the global copycat mapping, and each value
+ * is hashed from `[seed, table, index, field]`, so the same `(schema, options)`
+ * always yields byte-identical rows.
+ */
+/** A row context handed to an override function. */
+interface OverrideContext {
+  field: string;
+  /** The row's absolute index (the `indexOffset` base plus its position in this batch). */
+  index: number;
+  /** The row built so far (system `_id` first, then earlier fields). */
+  row: Record<string, unknown>;
+  /**
+   * A live, read-only view of every table's rows generated so far this run,
+   * keyed by table name. Lets an override correlate across tables (e.g. copy a
+   * field from the parent row a foreign key points at). Rows for the current
+   * table accumulate as they are built, so only earlier rows are visible.
+   */
+  store: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
+  table: string;
+}
+/**
+ * Per-table, per-field overrides. Each override is a static value or a function
+ * of the row context; field `_id` overrides the generated primary key.
+ */
+type SeedOverrides = Record<string, Record<string, unknown>>;
+/** Per-table row counts. */
+type SeedCounts = Record<string, number>;
+interface SeedOptions {
+  /** Rows per table; falls back to {@link SeedOptions.defaultCount} when a table is absent. */
+  counts?: SeedCounts;
+  /** Count used for any selected table not present in `counts` (default `10`). */
+  defaultCount?: number;
+  /**
+   * Ids of rows that already exist in the target store, keyed by table. Foreign
+   * keys may resolve to these in addition to freshly-seeded parents, and a
+   * parent table fully covered here is not re-seeded when it is only pulled in
+   * as an FK dependency (it is when named explicitly in `only`).
+   */
+  existingIds?: Readonly<Record<string, ReadonlyArray<string>>>;
+  /**
+   * Per-table absolute index base for generation. Defaults to `0`. A client
+   * seeding the same table across several calls passes the running total so
+   * each batch hashes from fresh indices and never collides ids with an
+   * earlier batch.
+   */
+  indexOffset?: Readonly<Record<string, number>>;
+  /**
+   * Restrict seeding to these tables. Transitive `v.id(...)` parents are added
+   * automatically (unless already covered by `existingIds`) so child foreign
+   * keys resolve to real rows. The result is still ordered by FK dependency.
+   * Default: all tables.
+   */
+  only?: ReadonlyArray<string>;
+  /** Static values or functions overriding generated columns. */
+  overrides?: SeedOverrides;
+  /** Deterministic mapping selector — same seed ⇒ same rows. Default `0`. */
+  seed?: number;
+}
+/** One table's generated rows, in insert order. Each row carries an explicit `_id`. */
+interface TablePlan {
+  rows: ReadonlyArray<Record<string, unknown>>;
+  table: string;
+}
+/**
+ * Build a deterministic, FK-consistent set of rows for `schema`.
+ * @returns one {@link TablePlan} per seeded table, ordered so a table's FK
+ * parents come before it.
+ */
+declare const seedPlan: (schema: Schema, options?: SeedOptions) => ReadonlyArray<TablePlan>;
+export { OverrideContext as O, SeedCounts as S, TablePlan as T, SeedOptions as a, SeedOverrides as b, seedPlan as s };

package/dist/packem_shared/seedPlan-DbOn48o6.mjs

@@ -0,0 +1,2 @@
+import '@lunora/errors';
+export { s as seedPlan } from './plan-DybYaa3F.mjs';

package/dist/testing.d.mts

@@ -1,5 +1,5 @@
 import { Schema } from '@lunora/server';
 import { TestHarness } from '@lunora/testing';
-import { a as SeedOptions } from "./packem_shared/plan.d-BQ6LiWIk.mjs";
+import { a as SeedOptions } from "./packem_shared/plan.d-SaRxbrrI.mjs";
 declare const seed: (harness: TestHarness, schema: Schema, options?: SeedOptions) => Promise<Record<string, string[]>>;
 export { seed };

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from '@lunora/server';
 import { TestHarness } from '@lunora/testing';
-import { a as SeedOptions } from "./packem_shared/plan.d-BQ6LiWIk.js";
+import { a as SeedOptions } from "./packem_shared/plan.d-SaRxbrrI.js";
 declare const seed: (harness: TestHarness, schema: Schema, options?: SeedOptions) => Promise<Record<string, string[]>>;
 export { seed };

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { s as seedPlan, i as introspectSchema } from './packem_shared/plan-DirmkctQ.mjs';
+import { s as seedPlan, i as introspectSchema } from './packem_shared/plan-DybYaa3F.mjs';
 
 const reviveRow = (row, bigintFields, bytesFields) => {
   if (bigintFields.size === 0 && bytesFields.size === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/seed",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.30",
   "description": "Schema-driven, deterministic database seeding for Lunora: realistic fake data from defineSchema",
   "keywords": [
     "cloudflare",
@@ -22,7 +22,7 @@
     "directory": "packages/seed"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"
@@ -47,11 +47,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@faker-js/faker": "^10.5.0"
+    "@faker-js/faker": "^10.5.0",
+    "@lunora/errors": "1.0.0-alpha.8"
   },
   "peerDependencies": {
-    "@lunora/server": "1.0.0-alpha.3",
-    "@lunora/values": "1.0.0-alpha.2"
+    "@lunora/server": ">=1.0.0-alpha.24 <2.0.0-0",
+    "@lunora/values": ">=1.0.0-alpha.7 <2.0.0-0"
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"

package/dist/packem_shared/plan.d-BQ6LiWIk.d.mts

@@ -1,78 +0,0 @@
-import { Schema } from '@lunora/server';
-/**
-* The pure, I/O-free core of seeding. {@link seedPlan} introspects a schema,
-* generates rows table-by-table in foreign-key order, and resolves every
-* `v.id("parent")` column to a real id of an already-generated parent row. The
-* result feeds every adapter (test harness, CLI, studio) — none of them
-* re-implement generation.
-*
-* Determinism: a `seed` value selects the global copycat mapping, and each value
-* is hashed from `[seed, table, index, field]`, so the same `(schema, options)`
-* always yields byte-identical rows.
-*/
-/** A row context handed to an override function. */
-interface OverrideContext {
-  field: string;
-  /** The row's absolute index (the `indexOffset` base plus its position in this batch). */
-  index: number;
-  /** The row built so far (system `_id` first, then earlier fields). */
-  row: Record<string, unknown>;
-  /**
-  * A live, read-only view of every table's rows generated so far this run,
-  * keyed by table name. Lets an override correlate across tables (e.g. copy a
-  * field from the parent row a foreign key points at). Rows for the current
-  * table accumulate as they are built, so only earlier rows are visible.
-  */
-  store: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
-  table: string;
-}
-/**
-* Per-table, per-field overrides. Each override is a static value or a function
-* of the row context; field `_id` overrides the generated primary key.
-*/
-type SeedOverrides = Record<string, Record<string, unknown>>;
-/** Per-table row counts. */
-type SeedCounts = Record<string, number>;
-interface SeedOptions {
-  /** Rows per table; falls back to {@link SeedOptions.defaultCount} when a table is absent. */
-  counts?: SeedCounts;
-  /** Count used for any selected table not present in `counts` (default `10`). */
-  defaultCount?: number;
-  /**
-  * Ids of rows that already exist in the target store, keyed by table. Foreign
-  * keys may resolve to these in addition to freshly-seeded parents, and a
-  * parent table fully covered here is not re-seeded when it is only pulled in
-  * as an FK dependency (it is when named explicitly in `only`).
-  */
-  existingIds?: Readonly<Record<string, ReadonlyArray<string>>>;
-  /**
-  * Per-table absolute index base for generation. Defaults to `0`. A client
-  * seeding the same table across several calls passes the running total so
-  * each batch hashes from fresh indices and never collides ids with an
-  * earlier batch.
-  */
-  indexOffset?: Readonly<Record<string, number>>;
-  /**
-  * Restrict seeding to these tables. Transitive `v.id(...)` parents are added
-  * automatically (unless already covered by `existingIds`) so child foreign
-  * keys resolve to real rows. The result is still ordered by FK dependency.
-  * Default: all tables.
-  */
-  only?: ReadonlyArray<string>;
-  /** Static values or functions overriding generated columns. */
-  overrides?: SeedOverrides;
-  /** Deterministic mapping selector — same seed ⇒ same rows. Default `0`. */
-  seed?: number;
-}
-/** One table's generated rows, in insert order. Each row carries an explicit `_id`. */
-interface TablePlan {
-  rows: ReadonlyArray<Record<string, unknown>>;
-  table: string;
-}
-/**
-* Build a deterministic, FK-consistent set of rows for `schema`.
-* @returns one {@link TablePlan} per seeded table, ordered so a table's FK
-* parents come before it.
-*/
-declare const seedPlan: (schema: Schema, options?: SeedOptions) => ReadonlyArray<TablePlan>;
-export { OverrideContext as O, SeedCounts as S, TablePlan as T, SeedOptions as a, SeedOverrides as b, seedPlan as s };

package/dist/packem_shared/plan.d-BQ6LiWIk.d.ts

@@ -1,78 +0,0 @@
-import { Schema } from '@lunora/server';
-/**
-* The pure, I/O-free core of seeding. {@link seedPlan} introspects a schema,
-* generates rows table-by-table in foreign-key order, and resolves every
-* `v.id("parent")` column to a real id of an already-generated parent row. The
-* result feeds every adapter (test harness, CLI, studio) — none of them
-* re-implement generation.
-*
-* Determinism: a `seed` value selects the global copycat mapping, and each value
-* is hashed from `[seed, table, index, field]`, so the same `(schema, options)`
-* always yields byte-identical rows.
-*/
-/** A row context handed to an override function. */
-interface OverrideContext {
-  field: string;
-  /** The row's absolute index (the `indexOffset` base plus its position in this batch). */
-  index: number;
-  /** The row built so far (system `_id` first, then earlier fields). */
-  row: Record<string, unknown>;
-  /**
-  * A live, read-only view of every table's rows generated so far this run,
-  * keyed by table name. Lets an override correlate across tables (e.g. copy a
-  * field from the parent row a foreign key points at). Rows for the current
-  * table accumulate as they are built, so only earlier rows are visible.
-  */
-  store: Readonly<Record<string, ReadonlyArray<Record<string, unknown>>>>;
-  table: string;
-}
-/**
-* Per-table, per-field overrides. Each override is a static value or a function
-* of the row context; field `_id` overrides the generated primary key.
-*/
-type SeedOverrides = Record<string, Record<string, unknown>>;
-/** Per-table row counts. */
-type SeedCounts = Record<string, number>;
-interface SeedOptions {
-  /** Rows per table; falls back to {@link SeedOptions.defaultCount} when a table is absent. */
-  counts?: SeedCounts;
-  /** Count used for any selected table not present in `counts` (default `10`). */
-  defaultCount?: number;
-  /**
-  * Ids of rows that already exist in the target store, keyed by table. Foreign
-  * keys may resolve to these in addition to freshly-seeded parents, and a
-  * parent table fully covered here is not re-seeded when it is only pulled in
-  * as an FK dependency (it is when named explicitly in `only`).
-  */
-  existingIds?: Readonly<Record<string, ReadonlyArray<string>>>;
-  /**
-  * Per-table absolute index base for generation. Defaults to `0`. A client
-  * seeding the same table across several calls passes the running total so
-  * each batch hashes from fresh indices and never collides ids with an
-  * earlier batch.
-  */
-  indexOffset?: Readonly<Record<string, number>>;
-  /**
-  * Restrict seeding to these tables. Transitive `v.id(...)` parents are added
-  * automatically (unless already covered by `existingIds`) so child foreign
-  * keys resolve to real rows. The result is still ordered by FK dependency.
-  * Default: all tables.
-  */
-  only?: ReadonlyArray<string>;
-  /** Static values or functions overriding generated columns. */
-  overrides?: SeedOverrides;
-  /** Deterministic mapping selector — same seed ⇒ same rows. Default `0`. */
-  seed?: number;
-}
-/** One table's generated rows, in insert order. Each row carries an explicit `_id`. */
-interface TablePlan {
-  rows: ReadonlyArray<Record<string, unknown>>;
-  table: string;
-}
-/**
-* Build a deterministic, FK-consistent set of rows for `schema`.
-* @returns one {@link TablePlan} per seeded table, ordered so a table's FK
-* parents come before it.
-*/
-declare const seedPlan: (schema: Schema, options?: SeedOptions) => ReadonlyArray<TablePlan>;
-export { OverrideContext as O, SeedCounts as S, TablePlan as T, SeedOptions as a, SeedOverrides as b, seedPlan as s };

package/dist/packem_shared/seedPlan-CDSmSgjY.mjs

@@ -1 +0,0 @@
-export { s as seedPlan } from './plan-DirmkctQ.mjs';