@lunora/seed 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/plan-DirmkctQ.mjs

@@ -0,0 +1,497 @@
+import { faker } from '@faker-js/faker';
+import { optionalInner } from '@lunora/values';
+
+let hashSalt = 0;
+const compareStrings = (a, b) => {
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+};
+const stableStringify = (input) => {
+  if (input === void 0) {
+    return "undefined";
+  }
+  if (typeof input === "bigint") {
+    return `${input.toString()}n`;
+  }
+  if (input === null || typeof input !== "object") {
+    return JSON.stringify(input) ?? "null";
+  }
+  if (Array.isArray(input)) {
+    return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.keys(input).toSorted(compareStrings).map((key) => `${JSON.stringify(key)}:${stableStringify(input[key])}`);
+  return `{${entries.join(",")}}`;
+};
+const cyrb53 = (text, seed) => {
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let index = 0; index < text.length; index += 1) {
+    const ch = text.codePointAt(index) ?? 0;
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+const STRING_DOMAIN_TAG = "\0";
+const hashInput = (input) => {
+  const text = typeof input === "string" ? STRING_DOMAIN_TAG + input : stableStringify(input);
+  return cyrb53(text, hashSalt) % 4294967296;
+};
+const setHashKey = (key) => {
+  if (typeof key === "number") {
+    hashSalt = key >>> 0;
+    return;
+  }
+  if (typeof key === "string") {
+    hashSalt = cyrb53(key, 0) % 4294967296;
+    return;
+  }
+  let folded = 0;
+  for (const word of key) {
+    folded = Math.imul(folded ^ word, 2654435761) >>> 0;
+  }
+  hashSalt = folded;
+};
+
+const seeded = (input, produce) => {
+  faker.seed(hashInput(input));
+  return produce();
+};
+const resolveCount = (input, range) => {
+  if (typeof range === "number") {
+    return range;
+  }
+  const [min, max] = range;
+  return seeded(["__count__", input], () => faker.number.int({ max, min }));
+};
+const capitalizeWord = (word) => word.length === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1);
+const LOWER_ALPHA = /[a-z]/;
+const UPPER_ALPHA = /[A-Z]/;
+const DIGIT = /\d/;
+const copycat = {
+  bool(input) {
+    return seeded(input, () => faker.datatype.boolean());
+  },
+  char(input) {
+    return seeded(input, () => faker.string.alpha(1));
+  },
+  city(input) {
+    return seeded(input, () => faker.location.city());
+  },
+  country(input) {
+    return seeded(input, () => faker.location.country());
+  },
+  countryCode(input) {
+    return seeded(input, () => faker.location.countryCode());
+  },
+  /** ISO-8601 date string between `min`/`max` (default years 1980–2020). */
+  dateString(input, options) {
+    const min = options?.min ?? /* @__PURE__ */ new Date("1980-01-01T00:00:00.000Z");
+    const max = options?.max ?? /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
+    return seeded(input, () => faker.date.between({ from: min, to: max }).toISOString());
+  },
+  digit(input) {
+    return seeded(input, () => String(faker.number.int({ max: 9, min: 0 })));
+  },
+  email(input) {
+    return seeded(input, () => faker.internet.email().toLowerCase());
+  },
+  firstName(input) {
+    return seeded(input, () => faker.person.firstName());
+  },
+  float(input, options) {
+    const { fractionDigits = 2, max = 1e3, min = 0 } = options ?? {};
+    return seeded(input, () => faker.number.float({ fractionDigits, max, min }));
+  },
+  fullName(input) {
+    return seeded(input, () => faker.person.fullName());
+  },
+  hex(input) {
+    return seeded(input, () => faker.string.hexadecimal({ casing: "lower", length: 1, prefix: "" }));
+  },
+  int(input, options) {
+    const { max = 1e3, min = 0 } = options ?? {};
+    return seeded(input, () => faker.number.int({ max, min }));
+  },
+  ipv4(input) {
+    return seeded(input, () => faker.internet.ipv4());
+  },
+  lastName(input) {
+    return seeded(input, () => faker.person.lastName());
+  },
+  mac(input) {
+    return seeded(input, () => faker.internet.mac());
+  },
+  /** Pick the array element corresponding to `input`. Returns `undefined` for an empty array. */
+  oneOf(input, values) {
+    if (values.length === 0) {
+      return void 0;
+    }
+    return seeded(input, () => faker.helpers.arrayElement(values));
+  },
+  paragraph(input) {
+    return seeded(input, () => faker.lorem.paragraph());
+  },
+  password(input) {
+    return seeded(input, () => faker.internet.password());
+  },
+  phoneNumber(input) {
+    return seeded(input, () => faker.phone.number());
+  },
+  /**
+   * Scramble a string in place: letters become seeded letters (case
+   * preserved), digits become seeded digits, every other character is kept.
+   * Length is preserved. Characters listed in `preserve` pass through untouched.
+   */
+  scramble(input, options) {
+    const preserve = new Set(options?.preserve);
+    return Array.from({ length: input.length }, (_unused, index) => {
+      const char = input.charAt(index);
+      if (preserve.has(char)) {
+        return char;
+      }
+      if (LOWER_ALPHA.test(char)) {
+        return seeded([input, index, "l"], () => faker.string.alpha({ casing: "lower", length: 1 }));
+      }
+      if (UPPER_ALPHA.test(char)) {
+        return seeded([input, index, "u"], () => faker.string.alpha({ casing: "upper", length: 1 }));
+      }
+      if (DIGIT.test(char)) {
+        return seeded([input, index, "d"], () => String(faker.number.int({ max: 9, min: 0 })));
+      }
+      return char;
+    }).join("");
+  },
+  sentence(input, options) {
+    return seeded(input, () => faker.lorem.sentence(options ? { max: options.max ?? 8, min: options.min ?? 3 } : void 0));
+  },
+  slug(input) {
+    return seeded(input, () => faker.lorem.slug());
+  },
+  /** Pick a deterministic subset (size within `range`) of `values`, no repeats. */
+  someOf(input, range, values) {
+    const count = Math.min(resolveCount(["__some__", input], range), values.length);
+    return seeded(input, () => faker.helpers.arrayElements(values, count));
+  },
+  streetAddress(input) {
+    return seeded(input, () => faker.location.streetAddress());
+  },
+  streetName(input) {
+    return seeded(input, () => faker.location.street());
+  },
+  timezone(input) {
+    return seeded(input, () => faker.location.timeZone());
+  },
+  /**
+   * Call `produce` once per element for a deterministic count within `range`,
+   * passing each a distinct sub-input so the elements differ but stay stable.
+   */
+  times(input, range, produce) {
+    const count = resolveCount(input, range);
+    const out = [];
+    for (let index = 0; index < count; index += 1) {
+      out.push(produce([input, index]));
+    }
+    return out;
+  },
+  url(input) {
+    return seeded(input, () => faker.internet.url());
+  },
+  username(input) {
+    return seeded(input, () => faker.internet.username());
+  },
+  uuid(input) {
+    return seeded(input, () => faker.string.uuid());
+  },
+  word(input, options) {
+    const word = seeded(input, () => faker.lorem.word());
+    return options?.capitalize === true ? capitalizeWord(word) : word;
+  },
+  words(input, options) {
+    return seeded(input, () => faker.lorem.words(options ? { max: options.max ?? 5, min: options.min ?? 2 } : void 0));
+  }
+};
+
+const metaOf = (validator) => validator._meta ?? {};
+const unwrapOptional = (validator) => optionalInner(validator) ?? validator;
+const hasServerDefault = (validator) => {
+  const { column } = metaOf(validator);
+  if (column?.defaultValue !== void 0 || column?.defaultFn !== void 0) {
+    return true;
+  }
+  const inner = optionalInner(validator);
+  return inner === void 0 ? false : hasServerDefault(inner);
+};
+const describeField = (name, validator) => {
+  const inner = unwrapOptional(validator);
+  const meta = metaOf(inner);
+  return {
+    fkTable: inner.kind === "id" ? meta.tableName : void 0,
+    hasServerDefault: hasServerDefault(validator),
+    kind: inner.kind,
+    name,
+    // `notNull` is tri-state: `true` (default / `.notNull()`), `false`
+    // (`.nullable()`), or `undefined` (no column metadata). Only an explicit
+    // `false` means the user opted the column into SQL `NULL` — which is what
+    // `fkFallback` keys off to emit `null` for an unresolved nullable FK. This
+    // mirrors codegen's own `isNullable` (`column?.notNull === false`).
+    nullable: meta.column?.notNull === false,
+    optional: validator.kind === "optional",
+    validator: inner
+  };
+};
+const introspectSchema = (schema) => {
+  const { tables } = schema;
+  return Object.entries(tables).map(([name, table]) => {
+    return {
+      fields: Object.entries(table.shape).map(([fieldName, validator]) => describeField(fieldName, validator)),
+      name
+    };
+  });
+};
+const orderTables = (specs, selected) => {
+  const byName = new Map(specs.map((spec) => [spec.name, spec]));
+  const parentsOf = (name) => {
+    const spec = byName.get(name);
+    if (spec === void 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    const parents = /* @__PURE__ */ new Set();
+    for (const field of spec.fields) {
+      if (field.fkTable !== void 0 && field.fkTable !== name && selected.has(field.fkTable)) {
+        parents.add(field.fkTable);
+      }
+    }
+    return parents;
+  };
+  const ordered = [];
+  const placed = /* @__PURE__ */ new Set();
+  const pending = [...selected].filter((name) => byName.has(name));
+  while (pending.length > 0) {
+    const readyIndex = pending.findIndex((name2) => [...parentsOf(name2)].every((parent) => placed.has(parent)));
+    const index = readyIndex === -1 ? 0 : readyIndex;
+    const [name] = pending.splice(index, 1);
+    if (name === void 0) {
+      break;
+    }
+    ordered.push(name);
+    placed.add(name);
+  }
+  return ordered;
+};
+const fkParentClosure = (specs, roots) => {
+  const byName = new Map(specs.map((spec) => [spec.name, spec]));
+  const result = new Set(roots);
+  const stack = [...result];
+  while (stack.length > 0) {
+    const name = stack.pop();
+    if (name === void 0) {
+      break;
+    }
+    const spec = byName.get(name);
+    if (spec === void 0) {
+      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);
+        stack.push(field.fkTable);
+      }
+    }
+  }
+  return result;
+};
+
+const constraintsOf = (validator) => metaOf(validator).constraints ?? {};
+const STRING_HEURISTICS = [
+  { generate: (input) => copycat.email(input), keywords: ["email"] },
+  { generate: (input) => copycat.firstName(input), keywords: ["firstname"] },
+  { generate: (input) => copycat.lastName(input), keywords: ["lastname", "surname"] },
+  { generate: (input) => copycat.username(input), keywords: ["username"] },
+  { generate: (input) => copycat.fullName(input), keywords: ["name"] },
+  { generate: (input) => copycat.sentence(input, { max: 5, min: 2 }), keywords: ["title"] },
+  { generate: (input) => copycat.url(input), keywords: ["url", "link", "image", "avatar"] },
+  { generate: (input) => copycat.phoneNumber(input), keywords: ["phone"] },
+  { generate: (input) => copycat.paragraph(input), keywords: ["description", "bio", "body", "content", "text"] },
+  { generate: (input) => copycat.slug(input), keywords: ["slug", "key", "code"] },
+  { generate: (input) => copycat.city(input), keywords: ["city"] },
+  { generate: (input) => copycat.country(input), keywords: ["country"] },
+  { generate: (input) => copycat.streetAddress(input), keywords: ["address", "street"] },
+  { generate: (input) => copycat.password(input), keywords: ["password", "secret", "token"] }
+];
+const generateString = (fieldName, input, constraints) => {
+  const lower = fieldName.toLowerCase();
+  const rule = STRING_HEURISTICS.find((entry) => entry.keywords.some((keyword) => lower.includes(keyword)));
+  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(
+      `Seed constraint error for field "${fieldName}": minLength (${String(minLength)}) > maxLength (${String(maxLength)}). Adjust the schema constraints.`
+    );
+  }
+  const truncated = maxLength !== void 0 && value.length > maxLength ? value.slice(0, maxLength) : value;
+  if (minLength !== void 0 && truncated.length < minLength) {
+    return truncated.padEnd(minLength, truncated.length > 0 ? truncated : "x");
+  }
+  return truncated;
+};
+const generateValue = (validator, fieldName, input) => {
+  const inner = unwrapOptional(validator);
+  const constraints = constraintsOf(inner);
+  if (constraints.enum !== void 0 && constraints.enum.length > 0) {
+    return copycat.oneOf(input, constraints.enum);
+  }
+  switch (inner.kind) {
+    case "any": {
+      return copycat.word(input);
+    }
+    case "array": {
+      const element = metaOf(inner).inner;
+      if (element === void 0) {
+        return [];
+      }
+      return copycat.times(input, [1, 3], (itemInput) => generateValue(element, fieldName, itemInput));
+    }
+    case "bigint": {
+      return copycat.int(input, { max: 1e6, min: 0 });
+    }
+    case "boolean": {
+      return copycat.bool(input);
+    }
+    case "bytes": {
+      return Array.from({ length: 8 }, (_, index) => copycat.int([input, index], { max: 255, min: 0 }));
+    }
+    case "date":
+    case "timestamp": {
+      return new Date(copycat.dateString(input)).getTime();
+    }
+    case "id": {
+      return copycat.uuid(input);
+    }
+    case "literal": {
+      return metaOf(inner).value;
+    }
+    case "null": {
+      return null;
+    }
+    case "number": {
+      return copycat.int(input, { max: constraints.maximum ?? 1e3, min: constraints.minimum ?? 0 });
+    }
+    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 entries = copycat.times(input, [1, 3], (itemInput) => {
+        const key = copycat.word(["k", itemInput]);
+        const value = valueValidator === void 0 ? copycat.word(["v", itemInput]) : generateValue(valueValidator, fieldName, ["v", itemInput]);
+        return [key, value];
+      });
+      return Object.fromEntries(entries);
+    }
+    case "storage": {
+      return `seed/${copycat.uuid(input)}`;
+    }
+    case "string": {
+      return generateString(fieldName, input, constraints);
+    }
+    case "union": {
+      const members = metaOf(inner).members ?? [];
+      const chosen = copycat.oneOf(input, members);
+      return chosen === void 0 ? copycat.word(input) : generateValue(chosen, fieldName, [input, "u"]);
+    }
+    default: {
+      return copycat.word(input);
+    }
+  }
+};
+
+const resolveOverride = (override, context) => typeof override === "function" ? override(context) : override;
+const fkFallback = (field, input) => {
+  if (field.optional) {
+    return void 0;
+  }
+  return field.nullable ? null : copycat.uuid(input);
+};
+const fkPool = (field, table, localIndex, idsByTable, existingIds) => {
+  const fkTable = field.fkTable;
+  const seeded = fkTable === table ? (idsByTable.get(table) ?? []).slice(0, localIndex) : idsByTable.get(fkTable) ?? [];
+  const existing = existingIds[fkTable] ?? [];
+  return existing.length === 0 ? seeded : [...seeded, ...existing];
+};
+const cellInput = (seed, table, index, column) => [seed, table, index, column];
+const generateField = (field, table, input, localIndex, idsByTable, existingIds) => {
+  if (field.fkTable !== void 0) {
+    const pool = fkPool(field, table, localIndex, idsByTable, existingIds);
+    if (pool.length === 0) {
+      return fkFallback(field, input);
+    }
+    return copycat.oneOf(input, pool);
+  }
+  if (field.hasServerDefault) {
+    return void 0;
+  }
+  return generateValue(field.validator, field.name, input);
+};
+const seedPlan = (schema, options = {}) => {
+  const { counts = {}, defaultCount = 10, existingIds = {}, indexOffset = {}, only, overrides = {}, seed = 0 } = options;
+  setHashKey(seed);
+  const specs = introspectSchema(schema);
+  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 order = orderTables(specs, selected);
+  const specByName = new Map(specs.map((spec) => [spec.name, spec]));
+  const idsByTable = /* @__PURE__ */ new Map();
+  const storeRows = {};
+  const plan = [];
+  for (const table of order) {
+    const spec = specByName.get(table);
+    if (spec === void 0) {
+      continue;
+    }
+    const tableOverrides = overrides[table] ?? {};
+    const count = counts[table] ?? defaultCount;
+    const offset = indexOffset[table] ?? 0;
+    const ids = [];
+    idsByTable.set(table, ids);
+    const rows = [];
+    storeRows[table] = rows;
+    for (let localIndex = 0; localIndex < count; localIndex += 1) {
+      const index = offset + localIndex;
+      const row = {};
+      const apply = (field, fallback) => {
+        if (Object.hasOwn(tableOverrides, field)) {
+          const overridden = resolveOverride(tableOverrides[field], { field, index, row, store: storeRows, table });
+          if (overridden !== void 0) {
+            row[field] = overridden;
+            return;
+          }
+        }
+        const value = fallback();
+        if (value !== void 0) {
+          row[field] = value;
+        }
+      };
+      apply("_id", () => copycat.uuid(cellInput(seed, table, index, "_id")));
+      ids.push(row._id);
+      for (const field of spec.fields) {
+        apply(field.name, () => generateField(field, table, cellInput(seed, table, index, field.name), localIndex, idsByTable, existingIds));
+      }
+      rows.push(row);
+    }
+    plan.push({ rows, table });
+  }
+  return plan;
+};
+
+export { setHashKey as a, copycat as c, introspectSchema as i, seedPlan as s };

package/dist/packem_shared/plan.d-BQ6LiWIk.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-BQ6LiWIk.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-CDSmSgjY.mjs

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

package/dist/testing.d.mts

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

package/dist/testing.d.ts

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