@lunora/seed 1.0.0-alpha.26 → 1.0.0-alpha.28

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/seed",
-  "version": "1.0.0-alpha.26",
+  "version": "1.0.0-alpha.28",
   "description": "Schema-driven, deterministic database seeding for Lunora: realistic fake data from defineSchema",
   "keywords": [
     "cloudflare",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@faker-js/faker": "^10.5.0",
-    "@lunora/errors": "1.0.0-alpha.5"
+    "@lunora/errors": "1.0.0-alpha.6"
   },
   "peerDependencies": {
     "@lunora/server": ">=1.0.0-alpha.24 <2.0.0-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 };