@prisma-next/sql-contract 0.13.0 → 0.14.0-dev.2

package/dist/{types-DqhaAjCH.mjs → entity-kinds-Cl36zL5j.mjs}

@@ -1,56 +1,102 @@
-import { IRNodeBase, NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode } from "@prisma-next/framework-components/ir";
-import { blindCast, castAs } from "@prisma-next/utils/casts";
+import { type } from "arktype";
+import { IRNodeBase, freezeNode } from "@prisma-next/framework-components/ir";
 import { asNamespaceId } from "@prisma-next/contract/types";
-//#region src/ir/sql-unbound-namespace.ts
+//#region src/ir/storage-entry-schemas.ts
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+const ColumnDefaultLiteralSchema = type.declare().type({
+	kind: literalKindSchema,
+	value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
+});
+const ColumnDefaultFunctionSchema = type.declare().type({
+	kind: functionKindSchema,
+	expression: "string"
+});
+const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+const StorageValueSetRefSchema = type({
+	plane: "'storage'",
+	namespaceId: "string",
+	entityKind: "'valueSet'",
+	entityName: "string",
+	"spaceId?": "string"
+});
+const StorageColumnSchema = type({
+	"+": "reject",
+	nativeType: "string",
+	codecId: "string",
+	nullable: "boolean",
+	"typeParams?": "Record<string, unknown>",
+	"typeRef?": "string",
+	"default?": ColumnDefaultSchema,
+	"control?": ControlPolicySchema,
+	"valueSet?": StorageValueSetRefSchema
+}).narrow((col, ctx) => {
+	if (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe("a column with either typeParams or typeRef, not both");
+	return true;
+});
 /**
-* Family-layer placeholder for the SQL unbound-namespace singleton —
-* the late-bound slot whose binding the target resolves at connection
-* time rather than at authoring time.
-*
-* SQL contracts honour the framework `Storage.namespaces` invariant from
-* the moment they appear in the IR. Today `SqlStorage` is family-shared
-* (Postgres + SQLite consume the same class); a per-target namespace
-* concretion (`PostgresSchema.unbound`, `SqliteUnboundDatabase.instance`)
-* earns its existence when each target's namespace shape lands. Until
-* then the family ships a single placeholder singleton so the JSON
-* envelope and runtime walk are honest at every layer.
-*
-* The `kind` discriminator is installed as a non-enumerable own property
-* so the JSON envelope reads `{ "id": "__unbound__", "entries": { … } }`
-* — symmetric with the family-level non-enumerable `kind` on `SqlNode`
-* and bounded to the minimum data the framework `Namespace` interface
-* promises.
-*
-* **Freeze-trap warning.** The leaf constructor calls
-* `freezeNode(this)` after installing `kind`. The leaf-class shape
-* works today only because `NamespaceBase` does NOT freeze in its
-* constructor — the `Object.defineProperty(this, 'kind', …)` call after
-* `super()` succeeds because the instance is still mutable at that
-* point. Subclasses that add instance fields will still hit the freeze
-* trap once leaf-class `freezeNode(this)` runs; and if a future
-* framework change lifts the freeze to `NamespaceBase`, even the
-* `defineProperty` here would silently fail. To add subclass instance
-* fields safely, lift `freezeNode` to a leaf-class `seal()` hook each
-* leaf calls explicitly at the end of its own constructor.
+* Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
+* Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
+* ordered `values` array of codec-encoded permitted values.
 */
-var SqlUnboundNamespace = class SqlUnboundNamespace extends NamespaceBase {
-	static instance = new SqlUnboundNamespace();
-	id = UNBOUND_NAMESPACE_ID;
-	entries = Object.freeze({ table: Object.freeze({}) });
-	constructor() {
-		super();
-		Object.defineProperty(this, "kind", {
-			value: "sql-namespace",
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		freezeNode(this);
-	}
-	qualifyTable(tableName) {
-		return `"${tableName}"`;
-	}
-};
+const StorageValueSetSchema = type({
+	kind: "'valueSet'",
+	values: type("string | number | boolean | null | unknown[] | Record<string, unknown>").array().readonly()
+});
+const PrimaryKeySchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const UniqueConstraintSchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const IndexSchema = type({
+	columns: type.string.array().readonly(),
+	"name?": "string",
+	"type?": "string",
+	"options?": "Record<string, unknown>"
+});
+const ForeignKeyReferenceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly(),
+	"spaceId?": "string"
+});
+const ForeignKeySourceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly()
+});
+const ReferentialActionSchema = type.declare().type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+const ForeignKeySchema = type.declare().type({
+	source: ForeignKeySourceSchema,
+	target: ForeignKeyReferenceSchema,
+	"name?": "string",
+	"onDelete?": ReferentialActionSchema,
+	"onUpdate?": ReferentialActionSchema,
+	constraint: "boolean",
+	index: "boolean"
+});
+const CheckConstraintSchema = type({
+	"+": "reject",
+	name: "string",
+	column: "string",
+	valueSet: StorageValueSetRefSchema
+});
+const StorageTableSchema = type({
+	"+": "reject",
+	columns: type({ "[string]": StorageColumnSchema }),
+	"primaryKey?": PrimaryKeySchema,
+	uniques: UniqueConstraintSchema.array().readonly(),
+	indexes: IndexSchema.array().readonly(),
+	foreignKeys: ForeignKeySchema.array().readonly(),
+	"control?": ControlPolicySchema,
+	"checks?": CheckConstraintSchema.array().readonly()
+});
 //#endregion
 //#region src/ir/sql-node.ts
 /**
@@ -310,7 +356,7 @@ var StorageTable = class extends SqlNode {
 * column that references it already holds the codec; the value-set holds
 * only the permitted values.
 *
-* The node's `kind` is enumerable (`'value-set'`) so the JSON envelope
+* The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope
 * carries the discriminator and the serializer hydration walker can
 * dispatch on it. This follows the per-leaf enumerable-kind convention
 * established in the SQL-node comment (future polymorphic dispatch on
@@ -320,7 +366,7 @@ var StorageTable = class extends SqlNode {
 * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.
 */
 var StorageValueSet = class extends SqlNode {
-	kind = "value-set";
+	kind = "valueSet";
 	values;
 	constructor(input) {
 		super();
@@ -329,164 +375,34 @@ var StorageValueSet = class extends SqlNode {
 	}
 };
 //#endregion
-//#region src/ir/build-sql-namespace.ts
-const SQL_NAMESPACE_KIND = "sql-namespace";
-function isMaterializedSqlNamespace(ns) {
-	if (typeof ns !== "object" || ns === null) return false;
-	const proto = Object.getPrototypeOf(ns);
-	if (proto === Object.prototype || proto === null) return false;
-	return ns.kind === SQL_NAMESPACE_KIND;
-}
-var SqlBoundNamespace = class SqlBoundNamespace extends NamespaceBase {
-	id;
-	entries;
-	static fromTablesInput(input) {
-		const tableCount = Object.keys(input.entries.table).length;
-		const hasValueSets = input.entries.valueSet !== void 0 && Object.keys(input.entries.valueSet).length > 0;
-		if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && !hasValueSets) return castAs(SqlUnboundNamespace.instance);
-		return castAs(new SqlBoundNamespace(input));
-	}
-	constructor(input) {
-		super();
-		this.id = input.id;
-		const table = Object.freeze(Object.fromEntries(Object.entries(input.entries.table).map(([k, v]) => [k, new StorageTable(v)])));
-		if (input.entries.valueSet !== void 0) {
-			const valueSet = Object.freeze(Object.fromEntries(Object.entries(input.entries.valueSet).map(([k, v]) => [k, new StorageValueSet(v)])));
-			this.entries = Object.freeze({
-				table,
-				valueSet
-			});
-		} else this.entries = Object.freeze({ table });
-		Object.defineProperty(this, "kind", {
-			value: SQL_NAMESPACE_KIND,
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		freezeNode(this);
-	}
-	qualifyTable(tableName) {
-		if (this.id === UNBOUND_NAMESPACE_ID) return `"${tableName}"`;
-		return `"${this.id}"."${tableName}"`;
-	}
+//#region src/entity-kinds.ts
+const tableEntityKind = {
+	kind: "table",
+	schema: StorageTableSchema,
+	construct: (input) => new StorageTable(input)
 };
-function buildSqlNamespace(input) {
-	return SqlBoundNamespace.fromTablesInput(input);
-}
-function buildSqlNamespaceMap(namespaces) {
-	return Object.fromEntries(Object.entries(namespaces).map(([nsKey, ns]) => [nsKey, isMaterializedSqlNamespace(ns) ? blindCast(ns) : SqlBoundNamespace.fromTablesInput(blindCast(ns))]));
-}
-//#endregion
-//#region src/ir/postgres-enum-storage-entry.ts
-/**
-* Discriminator literal for the Postgres-enum variant on the polymorphic
-* `SqlStorage.types` slot.
-*
-* Enums are a target-level concept: Postgres ships native
-* `CREATE TYPE … AS ENUM` while other SQL targets approximate enums via
-* constraints. The literal lives at the SQL family layer because every
-* SQL-family consumer (verifier, planner, lowering, …) needs to
-* discriminate enum-typed slot entries from codec-typed ones. The
-* concrete IR class (`PostgresEnumType`) lives in the target-postgres
-* package and implements this structural contract; cross-domain
-* layering rules forbid the SQL family from importing the concrete
-* target class directly, so the discriminator and structural interface
-* carry the dispatch.
-*/
-const POSTGRES_ENUM_KIND = "postgres-enum";
-/**
-* Narrow a polymorphic `StorageType` entry to the Postgres-enum shape
-* via its enumerable `kind` discriminator. Type guard returns true for
-* both live `PostgresEnumType` instances and raw JSON envelopes.
-*/
-function isPostgresEnumStorageEntry(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return value.kind === POSTGRES_ENUM_KIND;
-}
-//#endregion
-//#region src/ir/storage-type-instance.ts
-/**
-* Sentinel kind for the legacy codec-triple shape persisted under
-* `SqlStorage.types`. Plain JSON-clean object literals carry this
-* discriminator so the polymorphic slot dispatch can route them down
-* the codec path while target-specific IR class instances (e.g. the
-* Postgres enum class) keep their own narrower `kind` literal.
-*/
-const CODEC_INSTANCE_KIND = "codec-instance";
-/**
-* Stamp the codec-instance `kind` discriminator on a caller-supplied
-* codec triple. Idempotent: input that already carries the discriminator
-* passes through unchanged. Missing `typeParams` is normalised to `{}`.
-*/
-function toStorageTypeInstance(input) {
-	return {
-		kind: CODEC_INSTANCE_KIND,
-		codecId: input.codecId,
-		nativeType: input.nativeType,
-		typeParams: input.typeParams ?? {}
-	};
-}
-/**
-* Type-guard for codec-typed entries on the polymorphic
-* `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
-* class-instance kinds (e.g. `PostgresEnumType`).
-*/
-function isStorageTypeInstance(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return value.kind === CODEC_INSTANCE_KIND;
-}
-//#endregion
-//#region src/ir/sql-storage.ts
-var SqlStorage = class extends SqlNode {
-	storageHash;
-	namespaces;
-	constructor(input) {
-		super();
-		this.storageHash = input.storageHash;
-		this.namespaces = Object.freeze(input.namespaces);
-		if (input.types !== void 0) this.types = Object.freeze(Object.fromEntries(Object.entries(input.types).map(([name, ti]) => [name, normaliseTypeEntry(name, ti)])));
-		freezeNode(this);
-	}
+const valueSetEntityKind = {
+	kind: "valueSet",
+	schema: StorageValueSetSchema,
+	construct: (input) => new StorageValueSet(input)
 };
-function storageTableAt(storage, namespaceId, tableName) {
-	return storage.namespaces[namespaceId]?.entries.table[tableName];
-}
 /**
-* Strict polymorphic-slot dispatch for `SqlStorage.types` entries.
-* Every entry must carry a `kind: 'codec-instance'` discriminator or
-* be an already-constructed `StorageTypeInstance`. Untagged or
-* unrecognised inputs throw a diagnostic naming the entry and its
-* `kind`, so format drift surfaces loudly at the deserializer
-* boundary instead of slipping past the seam and corrupting
-* downstream IR walks.
-*
-* Codec-triple authors that have an untagged shape on hand can call
-* `toStorageTypeInstance(...)` (which stamps the `'codec-instance'`
-* discriminator) before constructing `SqlStorage`. On-disk reads
-* cross `familyInstance.deserializeContract` first; the structural
-* arktype schema rejects untagged entries earlier, so this throw
-* only fires for in-memory authoring bugs.
+* Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+* `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+* lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+* later consumes this registry to turn a namespace's raw entries into IR
+* instances, and `createSqlContractSchema` derives validation from the same
+* registry. Throws on a duplicate kind.
 */
-function normaliseTypeEntry(name, entry) {
-	if (isStorageTypeInstance(entry)) {
-		if ("typeParams" in entry) return entry;
-		return toStorageTypeInstance(entry);
+function composeSqlEntityKinds(packKinds = []) {
+	const kinds = new Map([["table", tableEntityKind], ["valueSet", valueSetEntityKind]]);
+	for (const descriptor of packKinds) {
+		if (kinds.has(descriptor.kind)) throw new Error(`composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`);
+		kinds.set(descriptor.kind, descriptor);
 	}
-	const rawKind = entry.kind;
-	const kindDescription = rawKind === void 0 ? "missing `kind` discriminator" : `unrecognised \`kind\` discriminator ${JSON.stringify(rawKind)}`;
-	throw new Error(`storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify("codec-instance")}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`);
-}
-//#endregion
-//#region src/types.ts
-const DEFAULT_FK_CONSTRAINT = true;
-const DEFAULT_FK_INDEX = true;
-function applyFkDefaults(fk, overrideDefaults) {
-	return {
-		constraint: fk.constraint ?? overrideDefaults?.constraint ?? true,
-		index: fk.index ?? overrideDefaults?.index ?? true
-	};
+	return kinds;
 }
 //#endregion
-export { SqlUnboundNamespace as C, SqlNode as S, Index as _, storageTableAt as a, ForeignKeyReference as b, toStorageTypeInstance as c, buildSqlNamespace as d, buildSqlNamespaceMap as f, StorageColumn as g, UniqueConstraint as h, SqlStorage as i, POSTGRES_ENUM_KIND as l, StorageTable as m, DEFAULT_FK_INDEX as n, CODEC_INSTANCE_KIND as o, StorageValueSet as p, applyFkDefaults as r, isStorageTypeInstance as s, DEFAULT_FK_CONSTRAINT as t, isPostgresEnumStorageEntry as u, PrimaryKey as v, CheckConstraint as x, ForeignKey as y };
+export { StorageTableSchema as C, ReferentialActionSchema as S, ColumnDefaultSchema as _, StorageTable as a, ForeignKeySourceSchema as b, Index as c, ForeignKeyReference as d, CheckConstraint as f, ColumnDefaultLiteralSchema as g, ColumnDefaultFunctionSchema as h, StorageValueSet as i, PrimaryKey as l, CheckConstraintSchema as m, tableEntityKind as n, UniqueConstraint as o, SqlNode as p, valueSetEntityKind as r, StorageColumn as s, composeSqlEntityKinds as t, ForeignKey as u, ForeignKeyReferenceSchema as v, StorageValueSetSchema as w, IndexSchema as x, ForeignKeySchema as y };
 
-//# sourceMappingURL=types-DqhaAjCH.mjs.map
+//# sourceMappingURL=entity-kinds-Cl36zL5j.mjs.map

package/dist/entity-kinds-Cl36zL5j.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-Cl36zL5j.mjs","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/ir/sql-node.ts","../src/ir/check-constraint.ts","../src/ir/foreign-key-reference.ts","../src/ir/foreign-key.ts","../src/ir/primary-key.ts","../src/ir/sql-index.ts","../src/ir/storage-column.ts","../src/ir/unique-constraint.ts","../src/ir/storage-table.ts","../src/ir/storage-value-set.ts","../src/entity-kinds.ts"],"sourcesContent":["import { type Type, type } from 'arktype';\nimport type { ForeignKeyInput, ReferentialAction } from './foreign-key';\nimport type { ForeignKeyReferenceInput } from './foreign-key-reference';\nimport type { PrimaryKeyInput } from './primary-key';\nimport type { UniqueConstraintInput } from './unique-constraint';\n\ntype ColumnDefaultLiteral = {\n  readonly kind: 'literal';\n  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;\n};\ntype ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };\n\nconst literalKindSchema = type(\"'literal'\");\nconst functionKindSchema = type(\"'function'\");\nconst ControlPolicySchema = type(\"'managed' | 'tolerated' | 'external' | 'observed'\");\n\nexport const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({\n  kind: literalKindSchema,\n  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',\n});\n\nexport const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({\n  kind: functionKindSchema,\n  expression: 'string',\n});\n\nexport const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);\n\nconst StorageValueSetRefSchema = type({\n  plane: \"'storage'\",\n  namespaceId: 'string',\n  entityKind: \"'valueSet'\",\n  entityName: 'string',\n  'spaceId?': 'string',\n});\n\nconst StorageColumnSchema = type({\n  '+': 'reject',\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n  'typeParams?': 'Record<string, unknown>',\n  'typeRef?': 'string',\n  'default?': ColumnDefaultSchema,\n  'control?': ControlPolicySchema,\n  'valueSet?': StorageValueSetRefSchema,\n}).narrow((col, ctx) => {\n  if (col.typeParams !== undefined && col.typeRef !== undefined) {\n    return ctx.mustBe('a column with either typeParams or typeRef, not both');\n  }\n  return true;\n});\n\n/**\n * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.\n * Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an\n * ordered `values` array of codec-encoded permitted values.\n */\nexport const StorageValueSetSchema = type({\n  kind: \"'valueSet'\",\n  values: type('string | number | boolean | null | unknown[] | Record<string, unknown>')\n    .array()\n    .readonly(),\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKeyInput>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nexport const IndexSchema = type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n  'type?': 'string',\n  'options?': 'Record<string, unknown>',\n});\n\nexport const ForeignKeyReferenceSchema = type({\n  '+': 'reject',\n  namespaceId: 'string',\n  tableName: 'string',\n  columns: type.string.array().readonly(),\n  'spaceId?': 'string',\n}) satisfies Type<ForeignKeyReferenceInput>;\n\nexport const ForeignKeySourceSchema = type({\n  '+': 'reject',\n  namespaceId: 'string',\n  tableName: 'string',\n  columns: type.string.array().readonly(),\n}) satisfies Type<ForeignKeyReferenceInput>;\n\nexport const ReferentialActionSchema = type\n  .declare<ReferentialAction>()\n  .type(\"'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'\");\n\nexport const ForeignKeySchema = type.declare<ForeignKeyInput>().type({\n  source: ForeignKeySourceSchema,\n  target: ForeignKeyReferenceSchema,\n  'name?': 'string',\n  'onDelete?': ReferentialActionSchema,\n  'onUpdate?': ReferentialActionSchema,\n  constraint: 'boolean',\n  index: 'boolean',\n});\n\nexport const CheckConstraintSchema = type({\n  '+': 'reject',\n  name: 'string',\n  column: 'string',\n  valueSet: StorageValueSetRefSchema,\n});\n\nexport const StorageTableSchema = type({\n  '+': 'reject',\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n  'control?': ControlPolicySchema,\n  'checks?': CheckConstraintSchema.array().readonly(),\n});\n","import { IRNodeBase } from '@prisma-next/framework-components/ir';\n\n/**\n * SQL family IR node base. Carries the family-level `kind` discriminator\n * `'sql'` and inherits the framework's `freezeNode` affordance.\n *\n * Single family-level discriminator (not per-leaf) reflects the fact that\n * SQL IR has no polymorphic dispatch today — verifiers and serializers\n * walk by structural position (`storage.tables[name].columns[name]`),\n * not by inspecting `kind`. The abstract bar for per-leaf discriminators\n * isn't earned until a future polymorphic consumer arrives.\n *\n * `kind` is installed as a non-enumerable own property on every instance,\n * which keeps three things clean simultaneously:\n *\n * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope\n *   shape (no `kind` field), so emitted contract.json files and the\n *   `validateSqlContractFully` arktype schemas stay unchanged.\n * - Test assertions that use `toEqual({...})` against the pre-lift flat\n *   shape continue to pass — only enumerable own properties are\n *   compared.\n * - Direct access (`node.kind`) and runtime narrowing\n *   (`if (node.kind === 'sql')`) still work, so future polymorphic\n *   dispatch can begin reading `kind` without a runtime change.\n *\n * Future per-leaf overrides land cleanly: a class that gains a\n * polymorphic-dispatch consumer (e.g. an enum type instance walked\n * alongside other types) overrides `kind` with its narrower literal\n * at that leaf level. Per-leaf overrides will use enumerable kind\n * (matching the Mongo per-class-discriminator precedent) because they\n * encode dispatch-relevant information that callers need to see in\n * JSON envelopes; the family-level `'sql'` is uniform across all SQL\n * IR and carries no dispatch-relevant information.\n */\nexport abstract class SqlNode extends IRNodeBase {\n  readonly kind?: string;\n\n  constructor() {\n    super();\n    Object.defineProperty(this, 'kind', {\n      value: 'sql',\n      writable: false,\n      enumerable: false,\n      // configurable so per-leaf subclasses (e.g. StorageValueSet)\n      // can override `kind` with their narrower\n      // enumerable literal via a class-field initializer. SqlNode\n      // itself never needs to mutate the property again, so\n      // configurability has no surface impact at this layer.\n      configurable: true,\n    });\n  }\n}\n","import type { ValueSetRef } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Hydration / construction input shape for {@link CheckConstraint}.\n * Mirrors the on-disk storage JSON envelope so the serializer hydration\n * walker can hand a validated literal straight to `new`.\n */\nexport interface CheckConstraintInput {\n  readonly name: string;\n  readonly column: string;\n  readonly valueSet: ValueSetRef;\n}\n\n/**\n * SQL Contract IR node for a table-level check constraint that restricts\n * a column to the permitted values of a value-set.\n *\n * The constraint is **structured** (names a column and a value-set\n * reference), not a raw SQL expression. Each target renders its own DDL\n * from the structured form, keeping the contract target-agnostic.\n *\n * Construction is idempotent: passing an existing `CheckConstraint`\n * instance as input produces a new instance with identical fields.\n * The constructor does not use `instanceof` for input discrimination —\n * it reads plain named properties, which is sufficient since\n * `CheckConstraintInput` is a structural type.\n */\nexport class CheckConstraint extends SqlNode {\n  readonly name: string;\n  readonly column: string;\n  readonly valueSet: ValueSetRef;\n\n  constructor(input: CheckConstraintInput) {\n    super();\n    this.name = input.name;\n    this.column = input.column;\n    this.valueSet = input.valueSet;\n    freezeNode(this);\n  }\n}\n","import { asNamespaceId, type NamespaceId } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Input for a foreign-key reference (one side of a foreign-key declaration).\n *\n * When `spaceId` is absent the reference is local — the referenced table lives\n * in the same contract-space. When `spaceId` is present the reference is\n * cross-space — the referenced table lives in a different contract-space\n * identified by `spaceId`.\n *\n * Presence-based discrimination keeps local FK JSON byte-identical to\n * contracts authored before cross-space support was added.\n */\nexport interface ForeignKeyReferenceInput {\n  readonly namespaceId: string;\n  readonly tableName: string;\n  readonly columns: readonly string[];\n  readonly spaceId?: string;\n}\n\n/**\n * SQL Contract IR node for one side (source or target) of a foreign-key\n * declaration. Carries the full coordinate: namespace, table, and columns.\n *\n * Cross-space discrimination is based on `spaceId` presence: absent means\n * local (same contract-space); present means cross-space (the referenced\n * table lives in the contract-space identified by `spaceId`).\n *\n * For local references `spaceId` is absent from JSON, keeping the serialized\n * shape byte-identical to contracts authored before cross-space support was\n * added. For cross-space references `spaceId` appears in JSON so round-trips\n * are lossless.\n *\n * Use `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`\n * as the sentinel `namespaceId` for single-namespace (unbound) references.\n */\nexport class ForeignKeyReference extends SqlNode {\n  readonly namespaceId: NamespaceId;\n  readonly tableName: string;\n  readonly columns: readonly string[];\n  declare readonly spaceId?: string;\n\n  constructor(input: ForeignKeyReferenceInput) {\n    super();\n    this.namespaceId = asNamespaceId(input.namespaceId);\n    this.tableName = input.tableName;\n    this.columns = input.columns;\n    if (input.spaceId !== undefined) this.spaceId = input.spaceId;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { ForeignKeyReference, type ForeignKeyReferenceInput } from './foreign-key-reference';\nimport { SqlNode } from './sql-node';\n\nexport type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';\n\nexport interface ForeignKeyInput {\n  readonly source: ForeignKeyReference | ForeignKeyReferenceInput;\n  readonly target: ForeignKeyReference | ForeignKeyReferenceInput;\n  readonly name?: string;\n  readonly onDelete?: ReferentialAction;\n  readonly onUpdate?: ReferentialAction;\n  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */\n  readonly constraint: boolean;\n  /** Whether to emit a backing index for the FK columns. */\n  readonly index: boolean;\n}\n\n/**\n * SQL Contract IR node for a table-level foreign-key declaration.\n *\n * Each FK carries explicit `source` and `target` {@link ForeignKeyReference}\n * coordinates (namespace, table, columns). For single-namespace contracts the\n * sentinel `UNBOUND_NAMESPACE_ID` appears on both sides.\n *\n * The nested references are normalised to {@link ForeignKeyReference}\n * instances inside the constructor so downstream walks see a uniform AST\n * regardless of whether the input was a JSON literal or an already-constructed\n * class instance.\n */\nexport class ForeignKey extends SqlNode {\n  readonly source: ForeignKeyReference;\n  readonly target: ForeignKeyReference;\n  readonly constraint: boolean;\n  readonly index: boolean;\n  declare readonly name?: string;\n  declare readonly onDelete?: ReferentialAction;\n  declare readonly onUpdate?: ReferentialAction;\n\n  constructor(input: ForeignKeyInput) {\n    super();\n    this.source =\n      input.source instanceof ForeignKeyReference\n        ? input.source\n        : new ForeignKeyReference(input.source);\n    this.target =\n      input.target instanceof ForeignKeyReference\n        ? input.target\n        : new ForeignKeyReference(input.target);\n    this.constraint = input.constraint;\n    this.index = input.index;\n    if (input.name !== undefined) this.name = input.name;\n    if (input.onDelete !== undefined) this.onDelete = input.onDelete;\n    if (input.onUpdate !== undefined) this.onUpdate = input.onUpdate;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\nexport interface PrimaryKeyInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n}\n\n/**\n * SQL Contract IR node for a table's primary-key constraint.\n */\nexport class PrimaryKey extends SqlNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n\n  constructor(input: PrimaryKeyInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\nexport interface IndexInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n  readonly type?: string;\n  readonly options?: Record<string, unknown>;\n}\n\n/**\n * SQL Contract IR node for a table-level secondary index.\n *\n * Note that this class shadows the global TypeScript `Index` lib type\n * at the family-shared name; consumer files that need both should\n * alias one (e.g.\n * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).\n */\nexport class Index extends SqlNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n  declare readonly type?: string;\n  declare readonly options?: Record<string, unknown>;\n\n  constructor(input: IndexInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    if (input.type !== undefined) this.type = input.type;\n    if (input.options !== undefined) this.options = input.options;\n    freezeNode(this);\n  }\n}\n","import type { ColumnDefault, ControlPolicy, ValueSetRef } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Hydration / construction input shape for {@link StorageColumn}. Mirrors\n * the on-disk storage JSON envelope exactly so the family-base\n * serializer's hydration walker can hand an arktype-validated literal\n * straight to `new`.\n *\n * `typeParams` and `typeRef` remain mutually exclusive (one or the\n * other, not both); the constructor preserves whichever caller-side\n * choice the input encodes.\n */\nexport interface StorageColumnInput {\n  readonly nativeType: string;\n  readonly codecId: string;\n  readonly nullable: boolean;\n  readonly typeParams?: Record<string, unknown>;\n  readonly typeRef?: string;\n  readonly default?: ColumnDefault;\n  readonly control?: ControlPolicy;\n  readonly valueSet?: ValueSetRef;\n}\n\n/**\n * SQL Contract IR node for a single column entry in `StorageTable.columns`.\n *\n * Single concrete family-shared class — every SQL target reads the\n * same column shape today, so there is no per-target subclass. The\n * class type accepts any caller that constructs via\n * `new StorageColumn(input)`; literal construction sites must pass\n * through the constructor or the family-base hydration walker.\n *\n * The column's `name` is not on the class — columns are keyed by name\n * in the parent `StorageTable.columns: Record<string, StorageColumn>`\n * map, so a `name` field would be redundant with the key.\n */\nexport class StorageColumn extends SqlNode {\n  readonly nativeType: string;\n  readonly codecId: string;\n  readonly nullable: boolean;\n  declare readonly typeParams?: Record<string, unknown>;\n  declare readonly typeRef?: string;\n  declare readonly default?: ColumnDefault;\n  declare readonly control?: ControlPolicy;\n  declare readonly valueSet?: ValueSetRef;\n\n  constructor(input: StorageColumnInput) {\n    super();\n    this.nativeType = input.nativeType;\n    this.codecId = input.codecId;\n    this.nullable = input.nullable;\n    if (input.typeParams !== undefined) this.typeParams = input.typeParams;\n    if (input.typeRef !== undefined) this.typeRef = input.typeRef;\n    if (input.default !== undefined) this.default = input.default;\n    if (input.control !== undefined) this.control = input.control;\n    if (input.valueSet !== undefined) this.valueSet = input.valueSet;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\nexport interface UniqueConstraintInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n}\n\n/**\n * SQL Contract IR node for a table-level unique constraint.\n */\nexport class UniqueConstraint extends SqlNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n\n  constructor(input: UniqueConstraintInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    freezeNode(this);\n  }\n}\n","import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { CheckConstraint, type CheckConstraintInput } from './check-constraint';\nimport { ForeignKey, type ForeignKeyInput } from './foreign-key';\nimport { PrimaryKey, type PrimaryKeyInput } from './primary-key';\nimport { Index, type IndexInput } from './sql-index';\nimport { SqlNode } from './sql-node';\nimport { StorageColumn, type StorageColumnInput } from './storage-column';\nimport { UniqueConstraint, type UniqueConstraintInput } from './unique-constraint';\n\nexport interface StorageTableInput {\n  readonly columns: Record<string, StorageColumn | StorageColumnInput>;\n  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;\n  readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;\n  readonly indexes: ReadonlyArray<Index | IndexInput>;\n  readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;\n  readonly control?: ControlPolicy;\n  readonly checks?: ReadonlyArray<CheckConstraint | CheckConstraintInput>;\n}\n\n/**\n * SQL Contract IR node for a single table entry in a namespace's\n * `tables` map.\n *\n * The constructor normalises nested IR-class fields (columns, primary\n * key, uniques, indexes, foreign keys) into the appropriate class\n * instances so downstream walks see a uniform AST regardless of whether\n * the input was a JSON literal or an already-constructed class.\n *\n * The table's `name` is not on the class — tables are keyed by name in\n * the parent namespace's `tables: Record<string, StorageTable>` map.\n */\nexport class StorageTable extends SqlNode {\n  readonly columns: Readonly<Record<string, StorageColumn>>;\n  readonly uniques: ReadonlyArray<UniqueConstraint>;\n  readonly indexes: ReadonlyArray<Index>;\n  readonly foreignKeys: ReadonlyArray<ForeignKey>;\n  declare readonly primaryKey?: PrimaryKey;\n  declare readonly control?: ControlPolicy;\n  declare readonly checks?: ReadonlyArray<CheckConstraint>;\n\n  constructor(input: StorageTableInput) {\n    super();\n    this.columns = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.columns).map(([name, col]) => [\n          name,\n          col instanceof StorageColumn ? col : new StorageColumn(col),\n        ]),\n      ),\n    );\n    if (input.primaryKey !== undefined) {\n      this.primaryKey =\n        input.primaryKey instanceof PrimaryKey\n          ? input.primaryKey\n          : new PrimaryKey(input.primaryKey);\n    }\n    this.uniques = Object.freeze(\n      input.uniques.map((u) => (u instanceof UniqueConstraint ? u : new UniqueConstraint(u))),\n    );\n    this.indexes = Object.freeze(input.indexes.map((i) => (i instanceof Index ? i : new Index(i))));\n    this.foreignKeys = Object.freeze(\n      input.foreignKeys.map((fk) => (fk instanceof ForeignKey ? fk : new ForeignKey(fk))),\n    );\n    if (input.control !== undefined) this.control = input.control;\n    if (input.checks !== undefined && input.checks.length > 0) {\n      this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));\n    }\n    freezeNode(this);\n  }\n}\n","import type { JsonValue } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Hydration / construction input shape for {@link StorageValueSet}.\n * Mirrors the on-disk storage JSON envelope so the serializer hydration\n * walker can hand a validated literal straight to `new`.\n */\nexport interface StorageValueSetInput {\n  readonly kind: 'valueSet';\n  /** Ordered permitted values, codec-encoded. Declaration order is preserved. */\n  readonly values: readonly JsonValue[];\n}\n\n/**\n * SQL Contract IR node for a value-set entry in a namespace's `valueSet`\n * map (`SqlNamespace.entries.valueSet`).\n *\n * A value-set records the ordered set of permitted codec-encoded values for\n * an enum-like column restriction. It does not carry a `codecId` — the\n * column that references it already holds the codec; the value-set holds\n * only the permitted values.\n *\n * The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope\n * carries the discriminator and the serializer hydration walker can\n * dispatch on it. This follows the per-leaf enumerable-kind convention\n * established in the SQL-node comment (future polymorphic dispatch on\n * namespace entries needs the discriminator in JSON).\n *\n * The entry's name is not on the class — value-sets are keyed by name in\n * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.\n */\nexport class StorageValueSet extends SqlNode {\n  override readonly kind = 'valueSet' as const;\n  readonly values: readonly JsonValue[];\n\n  constructor(input: StorageValueSetInput) {\n    super();\n    this.values = Object.freeze([...input.values]);\n    freezeNode(this);\n  }\n}\n","import type {\n  AnyEntityKindDescriptor,\n  EntityKindDescriptor,\n} from '@prisma-next/framework-components/ir';\nimport { StorageTableSchema, StorageValueSetSchema } from './ir/storage-entry-schemas';\nimport { StorageTable, type StorageTableInput } from './ir/storage-table';\nimport { StorageValueSet, type StorageValueSetInput } from './ir/storage-value-set';\n\nexport const tableEntityKind: EntityKindDescriptor<StorageTableInput, StorageTable> = {\n  kind: 'table',\n  schema: StorageTableSchema,\n  construct: (input) => new StorageTable(input),\n};\n\nexport const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet> = {\n  kind: 'valueSet',\n  schema: StorageValueSetSchema,\n  construct: (input) => new StorageValueSet(input),\n};\n\n/**\n * Assembles the `kind → descriptor` registry for SQL namespaces: the built-in\n * `table` and `valueSet` kinds plus any target `packKinds`. This builds the\n * lookup table — it does not touch contract data. `hydrateNamespaceEntities`\n * later consumes this registry to turn a namespace's raw entries into IR\n * instances, and `createSqlContractSchema` derives validation from the same\n * registry. Throws on a duplicate kind.\n */\nexport function composeSqlEntityKinds(\n  packKinds: readonly AnyEntityKindDescriptor[] = [],\n): ReadonlyMap<string, AnyEntityKindDescriptor> {\n  const kinds = new Map<string, AnyEntityKindDescriptor>([\n    ['table', tableEntityKind],\n    ['valueSet', valueSetEntityKind],\n  ]);\n  for (const descriptor of packKinds) {\n    if (kinds.has(descriptor.kind)) {\n      throw new Error(\n        `composeSqlEntityKinds: duplicate entity kind \"${descriptor.kind}\" — each kind may be registered only once`,\n      );\n    }\n    kinds.set(descriptor.kind, descriptor);\n  }\n  return kinds;\n}\n"],"mappings":"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"}

package/dist/entity-kinds.d.mts

@@ -0,0 +1,18 @@
+import { i as StorageTableInput, n as StorageValueSetInput, r as StorageTable, t as StorageValueSet } from "./storage-value-set-WnYsIFM8.mjs";
+import { AnyEntityKindDescriptor, EntityKindDescriptor } from "@prisma-next/framework-components/ir";
+
+//#region src/entity-kinds.d.ts
+declare const tableEntityKind: EntityKindDescriptor<StorageTableInput, StorageTable>;
+declare const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet>;
+/**
+ * Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+ * `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+ * lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+ * later consumes this registry to turn a namespace's raw entries into IR
+ * instances, and `createSqlContractSchema` derives validation from the same
+ * registry. Throws on a duplicate kind.
+ */
+declare function composeSqlEntityKinds(packKinds?: readonly AnyEntityKindDescriptor[]): ReadonlyMap<string, AnyEntityKindDescriptor>;
+//#endregion
+export { composeSqlEntityKinds, tableEntityKind, valueSetEntityKind };
+//# sourceMappingURL=entity-kinds.d.mts.map

package/dist/entity-kinds.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;cAQa,eAAA,EAAiB,oBAAA,CAAqB,iBAAA,EAAmB,YAAA;AAAA,cAMzD,kBAAA,EAAoB,oBAAA,CAAqB,oBAAA,EAAsB,eAAA;;;;;;;;;iBAc5D,qBAAA,CACd,SAAA,YAAoB,uBAAA,KACnB,WAAA,SAAoB,uBAAA"}

package/dist/entity-kinds.mjs

@@ -0,0 +1,2 @@
+import { n as tableEntityKind, r as valueSetEntityKind, t as composeSqlEntityKinds } from "./entity-kinds-Cl36zL5j.mjs";
+export { composeSqlEntityKinds, tableEntityKind, valueSetEntityKind };

package/dist/factories.d.mts

@@ -1,6 +1,6 @@
 import { t as ForeignKey } from "./foreign-key-BATxB95l.mjs";
-import { S as PrimaryKey, b as Index, g as UniqueConstraint, m as StorageTable, v as StorageColumn, y as StorageColumnInput } from "./sql-storage-CXf9xjAL.mjs";
-import { b as SqlModelFieldStorage, f as ForeignKeyOptions, x as SqlModelStorage } from "./types-DEnWD3xB.mjs";
+import { a as UniqueConstraint, c as StorageColumnInput, d as PrimaryKey, l as Index, r as StorageTable, s as StorageColumn } from "./storage-value-set-WnYsIFM8.mjs";
+import { b as SqlModelFieldStorage, f as ForeignKeyOptions, x as SqlModelStorage } from "./types-B1N8w0I2.mjs";
 import { ScalarFieldType } from "@prisma-next/contract/types";
 
 //#region src/factories.d.ts

package/dist/factories.mjs

@@ -1,4 +1,5 @@
-import { _ as Index, g as StorageColumn, h as UniqueConstraint, m as StorageTable, r as applyFkDefaults, v as PrimaryKey, y as ForeignKey } from "./types-DqhaAjCH.mjs";
+import { a as StorageTable, c as Index, l as PrimaryKey, o as UniqueConstraint, s as StorageColumn, u as ForeignKey } from "./entity-kinds-Cl36zL5j.mjs";
+import { r as applyFkDefaults } from "./types-B-eiQXff.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { asNamespaceId } from "@prisma-next/contract/types";
 //#region src/factories.ts

package/dist/factories.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"factories.mjs","names":[],"sources":["../src/factories.ts"],"sourcesContent":["import { asNamespaceId, type ScalarFieldType } from '@prisma-next/contract/types';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  applyFkDefaults,\n  ForeignKey,\n  type ForeignKeyOptions,\n  Index,\n  PrimaryKey,\n  type SqlModelFieldStorage,\n  type SqlModelStorage,\n  StorageColumn,\n  type StorageColumnInput,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nexport function col(nativeType: string, codecId: string, nullable = false): StorageColumn {\n  return new StorageColumn({ nativeType, codecId, nullable });\n}\n\nexport function pk(...columns: readonly string[]): PrimaryKey {\n  return new PrimaryKey({ columns });\n}\n\nexport function unique(...columns: readonly string[]): UniqueConstraint {\n  return new UniqueConstraint({ columns });\n}\n\nexport function index(...columns: readonly string[]): Index {\n  return new Index({ columns });\n}\n\nexport function fk(\n  srcTableName: string,\n  srcColumns: readonly string[],\n  targetTableName: string,\n  targetColumns: readonly string[],\n  opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean; namespaceId?: string },\n): ForeignKey {\n  const defaults = applyFkDefaults({ constraint: opts?.constraint, index: opts?.index });\n  const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);\n  return new ForeignKey({\n    source: { namespaceId, tableName: srcTableName, columns: srcColumns },\n    target: { namespaceId, tableName: targetTableName, columns: targetColumns },\n    ...(opts?.name !== undefined && { name: opts.name }),\n    ...(opts?.onDelete !== undefined && { onDelete: opts.onDelete }),\n    ...(opts?.onUpdate !== undefined && { onUpdate: opts.onUpdate }),\n    constraint: defaults.constraint,\n    index: defaults.index,\n  });\n}\n\nexport function table(\n  columns: Record<string, StorageColumn | StorageColumnInput>,\n  opts?: {\n    pk?: PrimaryKey;\n    uniques?: readonly UniqueConstraint[];\n    indexes?: readonly Index[];\n    fks?: readonly ForeignKey[];\n  },\n): StorageTable {\n  return new StorageTable({\n    columns,\n    ...(opts?.pk !== undefined && { primaryKey: opts.pk }),\n    uniques: opts?.uniques ?? [],\n    indexes: opts?.indexes ?? [],\n    foreignKeys: opts?.fks ?? [],\n  });\n}\n\nexport function model(\n  tableName: string,\n  fields: Record<string, SqlModelFieldStorage>,\n  relations: Record<string, unknown> = {},\n  namespaceId: string = UNBOUND_NAMESPACE_ID,\n): {\n  storage: SqlModelStorage;\n  fields: Record<string, { readonly nullable: boolean; readonly type: ScalarFieldType }>;\n  relations: Record<string, unknown>;\n} {\n  const storage: SqlModelStorage = { table: tableName, namespaceId, fields };\n  const domainFields = Object.fromEntries(\n    Object.entries(fields).map(([name, field]) => [\n      name,\n      {\n        nullable: field.nullable ?? false,\n        type: { kind: 'scalar' as const, codecId: field.codecId ?? 'core/unknown@1' },\n      },\n    ]),\n  ) as Record<string, { nullable: boolean; type: ScalarFieldType }>;\n  return {\n    storage,\n    fields: domainFields,\n    relations,\n  };\n}\n"],"mappings":";;;;AAgBA,SAAgB,IAAI,YAAoB,SAAiB,WAAW,OAAsB;CACxF,OAAO,IAAI,cAAc;EAAE;EAAY;EAAS;CAAS,CAAC;AAC5D;AAEA,SAAgB,GAAG,GAAG,SAAwC;CAC5D,OAAO,IAAI,WAAW,EAAE,QAAQ,CAAC;AACnC;AAEA,SAAgB,OAAO,GAAG,SAA8C;CACtE,OAAO,IAAI,iBAAiB,EAAE,QAAQ,CAAC;AACzC;AAEA,SAAgB,MAAM,GAAG,SAAmC;CAC1D,OAAO,IAAI,MAAM,EAAE,QAAQ,CAAC;AAC9B;AAEA,SAAgB,GACd,cACA,YACA,iBACA,eACA,MACY;CACZ,MAAM,WAAW,gBAAgB;EAAE,YAAY,MAAM;EAAY,OAAO,MAAM;CAAM,CAAC;CACrF,MAAM,cAAc,cAAc,MAAM,eAAe,oBAAoB;CAC3E,OAAO,IAAI,WAAW;EACpB,QAAQ;GAAE;GAAa,WAAW;GAAc,SAAS;EAAW;EACpE,QAAQ;GAAE;GAAa,WAAW;GAAiB,SAAS;EAAc;EAC1E,GAAI,MAAM,SAAS,KAAA,KAAa,EAAE,MAAM,KAAK,KAAK;EAClD,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,YAAY,SAAS;EACrB,OAAO,SAAS;CAClB,CAAC;AACH;AAEA,SAAgB,MACd,SACA,MAMc;CACd,OAAO,IAAI,aAAa;EACtB;EACA,GAAI,MAAM,OAAO,KAAA,KAAa,EAAE,YAAY,KAAK,GAAG;EACpD,SAAS,MAAM,WAAW,CAAC;EAC3B,SAAS,MAAM,WAAW,CAAC;EAC3B,aAAa,MAAM,OAAO,CAAC;CAC7B,CAAC;AACH;AAEA,SAAgB,MACd,WACA,QACA,YAAqC,CAAC,GACtC,cAAsB,sBAKtB;CAWA,OAAO;EACL,SAAA;GAXiC,OAAO;GAAW;GAAa;EAW1D;EACN,QAXmB,OAAO,YAC1B,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,CAC5C,MACA;GACE,UAAU,MAAM,YAAY;GAC5B,MAAM;IAAE,MAAM;IAAmB,SAAS,MAAM,WAAW;GAAiB;EAC9E,CACF,CAAC,CAIkB;EACnB;CACF;AACF"}
+{"version":3,"file":"factories.mjs","names":[],"sources":["../src/factories.ts"],"sourcesContent":["import { asNamespaceId, type ScalarFieldType } from '@prisma-next/contract/types';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  applyFkDefaults,\n  ForeignKey,\n  type ForeignKeyOptions,\n  Index,\n  PrimaryKey,\n  type SqlModelFieldStorage,\n  type SqlModelStorage,\n  StorageColumn,\n  type StorageColumnInput,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nexport function col(nativeType: string, codecId: string, nullable = false): StorageColumn {\n  return new StorageColumn({ nativeType, codecId, nullable });\n}\n\nexport function pk(...columns: readonly string[]): PrimaryKey {\n  return new PrimaryKey({ columns });\n}\n\nexport function unique(...columns: readonly string[]): UniqueConstraint {\n  return new UniqueConstraint({ columns });\n}\n\nexport function index(...columns: readonly string[]): Index {\n  return new Index({ columns });\n}\n\nexport function fk(\n  srcTableName: string,\n  srcColumns: readonly string[],\n  targetTableName: string,\n  targetColumns: readonly string[],\n  opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean; namespaceId?: string },\n): ForeignKey {\n  const defaults = applyFkDefaults({ constraint: opts?.constraint, index: opts?.index });\n  const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);\n  return new ForeignKey({\n    source: { namespaceId, tableName: srcTableName, columns: srcColumns },\n    target: { namespaceId, tableName: targetTableName, columns: targetColumns },\n    ...(opts?.name !== undefined && { name: opts.name }),\n    ...(opts?.onDelete !== undefined && { onDelete: opts.onDelete }),\n    ...(opts?.onUpdate !== undefined && { onUpdate: opts.onUpdate }),\n    constraint: defaults.constraint,\n    index: defaults.index,\n  });\n}\n\nexport function table(\n  columns: Record<string, StorageColumn | StorageColumnInput>,\n  opts?: {\n    pk?: PrimaryKey;\n    uniques?: readonly UniqueConstraint[];\n    indexes?: readonly Index[];\n    fks?: readonly ForeignKey[];\n  },\n): StorageTable {\n  return new StorageTable({\n    columns,\n    ...(opts?.pk !== undefined && { primaryKey: opts.pk }),\n    uniques: opts?.uniques ?? [],\n    indexes: opts?.indexes ?? [],\n    foreignKeys: opts?.fks ?? [],\n  });\n}\n\nexport function model(\n  tableName: string,\n  fields: Record<string, SqlModelFieldStorage>,\n  relations: Record<string, unknown> = {},\n  namespaceId: string = UNBOUND_NAMESPACE_ID,\n): {\n  storage: SqlModelStorage;\n  fields: Record<string, { readonly nullable: boolean; readonly type: ScalarFieldType }>;\n  relations: Record<string, unknown>;\n} {\n  const storage: SqlModelStorage = { table: tableName, namespaceId, fields };\n  const domainFields = Object.fromEntries(\n    Object.entries(fields).map(([name, field]) => [\n      name,\n      {\n        nullable: field.nullable ?? false,\n        type: { kind: 'scalar' as const, codecId: field.codecId ?? 'core/unknown@1' },\n      },\n    ]),\n  ) as Record<string, { nullable: boolean; type: ScalarFieldType }>;\n  return {\n    storage,\n    fields: domainFields,\n    relations,\n  };\n}\n"],"mappings":";;;;;AAgBA,SAAgB,IAAI,YAAoB,SAAiB,WAAW,OAAsB;CACxF,OAAO,IAAI,cAAc;EAAE;EAAY;EAAS;CAAS,CAAC;AAC5D;AAEA,SAAgB,GAAG,GAAG,SAAwC;CAC5D,OAAO,IAAI,WAAW,EAAE,QAAQ,CAAC;AACnC;AAEA,SAAgB,OAAO,GAAG,SAA8C;CACtE,OAAO,IAAI,iBAAiB,EAAE,QAAQ,CAAC;AACzC;AAEA,SAAgB,MAAM,GAAG,SAAmC;CAC1D,OAAO,IAAI,MAAM,EAAE,QAAQ,CAAC;AAC9B;AAEA,SAAgB,GACd,cACA,YACA,iBACA,eACA,MACY;CACZ,MAAM,WAAW,gBAAgB;EAAE,YAAY,MAAM;EAAY,OAAO,MAAM;CAAM,CAAC;CACrF,MAAM,cAAc,cAAc,MAAM,eAAe,oBAAoB;CAC3E,OAAO,IAAI,WAAW;EACpB,QAAQ;GAAE;GAAa,WAAW;GAAc,SAAS;EAAW;EACpE,QAAQ;GAAE;GAAa,WAAW;GAAiB,SAAS;EAAc;EAC1E,GAAI,MAAM,SAAS,KAAA,KAAa,EAAE,MAAM,KAAK,KAAK;EAClD,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,YAAY,SAAS;EACrB,OAAO,SAAS;CAClB,CAAC;AACH;AAEA,SAAgB,MACd,SACA,MAMc;CACd,OAAO,IAAI,aAAa;EACtB;EACA,GAAI,MAAM,OAAO,KAAA,KAAa,EAAE,YAAY,KAAK,GAAG;EACpD,SAAS,MAAM,WAAW,CAAC;EAC3B,SAAS,MAAM,WAAW,CAAC;EAC3B,aAAa,MAAM,OAAO,CAAC;CAC7B,CAAC;AACH;AAEA,SAAgB,MACd,WACA,QACA,YAAqC,CAAC,GACtC,cAAsB,sBAKtB;CAWA,OAAO;EACL,SAAA;GAXiC,OAAO;GAAW;GAAa;EAW1D;EACN,QAXmB,OAAO,YAC1B,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,CAC5C,MACA;GACE,UAAU,MAAM,YAAY;GAC5B,MAAM;IAAE,MAAM;IAAmB,SAAS,MAAM,WAAW;GAAiB;EAC9E,CACF,CAAC,CAIkB;EACnB;CACF;AACF"}

package/dist/index-type-validation.d.mts

@@ -1,4 +1,4 @@
-import { r as SqlStorage } from "./sql-storage-CXf9xjAL.mjs";
+import { i as SqlStorage } from "./sql-storage-Dga0jwP2.mjs";
 import { a as IndexTypeRegistry } from "./index-types-Czsyu7Iw.mjs";
 import { Contract } from "@prisma-next/contract/types";
 

package/dist/index-type-validation.mjs

@@ -1,18 +1,15 @@
-import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
 import { type } from "arktype";
+import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
 //#region src/index-type-validation.ts
 function validateIndexTypes(contract, indexTypeRegistry) {
-	for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) for (const [tableName, rawTable] of Object.entries(ns.entries.table)) {
-		const table = rawTable;
-		for (const index of table.indexes) {
-			if (index.type === void 0 && index.options !== void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] has options without a type`, "storage");
-			if (index.type === void 0) continue;
-			const entry = indexTypeRegistry.get(index.type);
-			if (entry === void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] uses unregistered index type "${index.type}"`, "storage");
-			const optionsValue = index.options ?? {};
-			const result = entry.options(optionsValue);
-			if (result instanceof type.errors) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] has invalid options for type "${index.type}": ${result.summary}`, "storage");
-		}
+	for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) for (const index of table.indexes) {
+		if (index.type === void 0 && index.options !== void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] has options without a type`, "storage");
+		if (index.type === void 0) continue;
+		const entry = indexTypeRegistry.get(index.type);
+		if (entry === void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] uses unregistered index type "${index.type}"`, "storage");
+		const optionsValue = index.options ?? {};
+		const result = entry.options(optionsValue);
+		if (result instanceof type.errors) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] has invalid options for type "${index.type}": ${result.summary}`, "storage");
 	}
 }
 //#endregion

package/dist/index-type-validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index-type-validation.mjs","names":[],"sources":["../src/index-type-validation.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport type { Contract } from '@prisma-next/contract/types';\nimport { type } from 'arktype';\nimport type { IndexTypeRegistry } from './index-types';\nimport type { SqlStorage, StorageTable } from './types';\n\nexport function validateIndexTypes(\n  contract: Contract<SqlStorage>,\n  indexTypeRegistry: IndexTypeRegistry,\n): void {\n  for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) {\n    for (const [tableName, rawTable] of Object.entries(ns.entries.table)) {\n      const table = rawTable as StorageTable;\n      for (const index of table.indexes) {\n        if (index.type === undefined && index.options !== undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] has options without a type`,\n            'storage',\n          );\n        }\n        if (index.type === undefined) continue;\n        const entry = indexTypeRegistry.get(index.type);\n        if (entry === undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] uses unregistered index type \"${index.type}\"`,\n            'storage',\n          );\n        }\n        const optionsValue = index.options ?? {};\n        const result = entry.options(optionsValue);\n        if (result instanceof type.errors) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] has invalid options for type \"${index.type}\": ${result.summary}`,\n            'storage',\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,mBACd,UACA,mBACM;CACN,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,SAAS,QAAQ,UAAU,GACxE,KAAK,MAAM,CAAC,WAAW,aAAa,OAAO,QAAQ,GAAG,QAAQ,KAAK,GAAG;EACpE,MAAM,QAAQ;EACd,KAAK,MAAM,SAAS,MAAM,SAAS;GACjC,IAAI,MAAM,SAAS,KAAA,KAAa,MAAM,YAAY,KAAA,GAChD,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,+BAC9F,SACF;GAEF,IAAI,MAAM,SAAS,KAAA,GAAW;GAC9B,MAAM,QAAQ,kBAAkB,IAAI,MAAM,IAAI;GAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,kCAAkC,MAAM,KAAK,IAC3I,SACF;GAEF,MAAM,eAAe,MAAM,WAAW,CAAC;GACvC,MAAM,SAAS,MAAM,QAAQ,YAAY;GACzC,IAAI,kBAAkB,KAAK,QACzB,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,kCAAkC,MAAM,KAAK,KAAK,OAAO,WACvJ,SACF;EAEJ;CACF;AAEJ"}
+{"version":3,"file":"index-type-validation.mjs","names":[],"sources":["../src/index-type-validation.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport type { Contract } from '@prisma-next/contract/types';\nimport { type } from 'arktype';\nimport type { IndexTypeRegistry } from './index-types';\nimport type { SqlStorage } from './types';\n\nexport function validateIndexTypes(\n  contract: Contract<SqlStorage>,\n  indexTypeRegistry: IndexTypeRegistry,\n): void {\n  for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) {\n    for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) {\n      for (const index of table.indexes) {\n        if (index.type === undefined && index.options !== undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] has options without a type`,\n            'storage',\n          );\n        }\n        if (index.type === undefined) continue;\n        const entry = indexTypeRegistry.get(index.type);\n        if (entry === undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] uses unregistered index type \"${index.type}\"`,\n            'storage',\n          );\n        }\n        const optionsValue = index.options ?? {};\n        const result = entry.options(optionsValue);\n        if (result instanceof type.errors) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] has invalid options for type \"${index.type}\": ${result.summary}`,\n            'storage',\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,mBACd,UACA,mBACM;CACN,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,SAAS,QAAQ,UAAU,GACxE,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,QAAQ,SAAS,CAAC,CAAC,GACpE,KAAK,MAAM,SAAS,MAAM,SAAS;EACjC,IAAI,MAAM,SAAS,KAAA,KAAa,MAAM,YAAY,KAAA,GAChD,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,+BAC9F,SACF;EAEF,IAAI,MAAM,SAAS,KAAA,GAAW;EAC9B,MAAM,QAAQ,kBAAkB,IAAI,MAAM,IAAI;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,kCAAkC,MAAM,KAAK,IAC3I,SACF;EAEF,MAAM,eAAe,MAAM,WAAW,CAAC;EACvC,MAAM,SAAS,MAAM,QAAQ,YAAY;EACzC,IAAI,kBAAkB,KAAK,QACzB,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,kCAAkC,MAAM,KAAK,KAAK,OAAO,WACvJ,SACF;CAEJ;AAGN"}

package/dist/resolve-storage-table.d.mts

@@ -1,4 +1,5 @@
-import { m as StorageTable, r as SqlStorage } from "./sql-storage-CXf9xjAL.mjs";
+import { r as StorageTable } from "./storage-value-set-WnYsIFM8.mjs";
+import { i as SqlStorage } from "./sql-storage-Dga0jwP2.mjs";
 
 //#region src/resolve-storage-table.d.ts
 interface ResolvedStorageTable {

package/dist/resolve-storage-table.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-storage-table.d.mts","names":[],"sources":["../src/resolve-storage-table.ts"],"mappings":";;;UAGiB,oBAAA;EAAA,SACN,WAAA;EAAA,SACA,KAAA,EAAO,YAAY;AAAA;;;;;;AAAA;AA0B9B;;;iBAAgB,mBAAA,CACd,OAAA,EAAS,UAAA,EACT,SAAA,UACA,WAAA,YACC,oBAAoB"}
+{"version":3,"file":"resolve-storage-table.d.mts","names":[],"sources":["../src/resolve-storage-table.ts"],"mappings":";;;;UAIiB,oBAAA;EAAA,SACN,WAAA;EAAA,SACA,KAAA,EAAO,YAAY;AAAA;;;;;;;AAAA;AAY9B;;iBAAgB,mBAAA,CACd,OAAA,EAAS,UAAA,EACT,SAAA,UACA,WAAA,YACC,oBAAoB"}

package/dist/resolve-storage-table.mjs

@@ -1,10 +1,5 @@
+import { entityAt } from "@prisma-next/framework-components/ir";
 //#region src/resolve-storage-table.ts
-function tableInNamespace(namespace, tableName) {
-	if (namespace === void 0) return;
-	const tables = namespace.entries.table;
-	if (!Object.hasOwn(tables, tableName)) return;
-	return tables[tableName];
-}
 /**
 * Resolve a bare storage table name to its namespace coordinate and table IR.
 *
@@ -16,7 +11,11 @@ function tableInNamespace(namespace, tableName) {
 */
 function resolveStorageTable(storage, tableName, namespaceId) {
 	if (namespaceId !== void 0) {
-		const table = tableInNamespace(storage.namespaces[namespaceId], tableName);
+		const table = entityAt(storage, {
+			namespaceId,
+			entityKind: "table",
+			entityName: tableName
+		});
 		return table === void 0 ? void 0 : {
 			namespaceId,
 			table
@@ -24,7 +23,11 @@ function resolveStorageTable(storage, tableName, namespaceId) {
 	}
 	const matches = [];
 	for (const candidateNamespaceId of Object.keys(storage.namespaces)) {
-		const table = tableInNamespace(storage.namespaces[candidateNamespaceId], tableName);
+		const table = entityAt(storage, {
+			namespaceId: candidateNamespaceId,
+			entityKind: "table",
+			entityName: tableName
+		});
 		if (table !== void 0) matches.push({
 			namespaceId: candidateNamespaceId,
 			table

package/dist/resolve-storage-table.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-storage-table.mjs","names":[],"sources":["../src/resolve-storage-table.ts"],"sourcesContent":["import type { SqlNamespace, SqlStorage } from './ir/sql-storage';\nimport type { StorageTable } from './ir/storage-table';\n\nexport interface ResolvedStorageTable {\n  readonly namespaceId: string;\n  readonly table: StorageTable;\n}\n\nfunction tableInNamespace(\n  namespace: SqlNamespace | undefined,\n  tableName: string,\n): StorageTable | undefined {\n  if (namespace === undefined) {\n    return undefined;\n  }\n  const tables = namespace.entries.table;\n  if (!Object.hasOwn(tables, tableName)) {\n    return undefined;\n  }\n  return tables[tableName];\n}\n\n/**\n * Resolve a bare storage table name to its namespace coordinate and table IR.\n *\n * When `namespaceId` is supplied, the table is resolved strictly within that\n * namespace (no scan). When omitted, a bare name unique across namespaces\n * resolves to its sole namespace; a bare name declared in more than one\n * namespace throws a fail-fast diagnostic naming the candidate namespaces\n * rather than silently selecting the first match.\n */\nexport function resolveStorageTable(\n  storage: SqlStorage,\n  tableName: string,\n  namespaceId?: string,\n): ResolvedStorageTable | undefined {\n  if (namespaceId !== undefined) {\n    const table = tableInNamespace(storage.namespaces[namespaceId], tableName);\n    return table === undefined ? undefined : { namespaceId, table };\n  }\n\n  const matches: ResolvedStorageTable[] = [];\n  for (const candidateNamespaceId of Object.keys(storage.namespaces)) {\n    const table = tableInNamespace(storage.namespaces[candidateNamespaceId], tableName);\n    if (table !== undefined) {\n      matches.push({ namespaceId: candidateNamespaceId, table });\n    }\n  }\n\n  if (matches.length > 1) {\n    const candidates = matches\n      .map((match) => match.namespaceId)\n      .sort()\n      .join(', ');\n    throw new Error(\n      `Storage table \"${tableName}\" is ambiguous across namespaces [${candidates}]; qualify it with a namespace coordinate.`,\n    );\n  }\n\n  return matches[0];\n}\n"],"mappings":";AAQA,SAAS,iBACP,WACA,WAC0B;CAC1B,IAAI,cAAc,KAAA,GAChB;CAEF,MAAM,SAAS,UAAU,QAAQ;CACjC,IAAI,CAAC,OAAO,OAAO,QAAQ,SAAS,GAClC;CAEF,OAAO,OAAO;AAChB;;;;;;;;;;AAWA,SAAgB,oBACd,SACA,WACA,aACkC;CAClC,IAAI,gBAAgB,KAAA,GAAW;EAC7B,MAAM,QAAQ,iBAAiB,QAAQ,WAAW,cAAc,SAAS;EACzE,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY;GAAE;GAAa;EAAM;CAChE;CAEA,MAAM,UAAkC,CAAC;CACzC,KAAK,MAAM,wBAAwB,OAAO,KAAK,QAAQ,UAAU,GAAG;EAClE,MAAM,QAAQ,iBAAiB,QAAQ,WAAW,uBAAuB,SAAS;EAClF,IAAI,UAAU,KAAA,GACZ,QAAQ,KAAK;GAAE,aAAa;GAAsB;EAAM,CAAC;CAE7D;CAEA,IAAI,QAAQ,SAAS,GAAG;EACtB,MAAM,aAAa,QAChB,KAAK,UAAU,MAAM,WAAW,CAAC,CACjC,KAAK,CAAC,CACN,KAAK,IAAI;EACZ,MAAM,IAAI,MACR,kBAAkB,UAAU,oCAAoC,WAAW,2CAC7E;CACF;CAEA,OAAO,QAAQ;AACjB"}
+{"version":3,"file":"resolve-storage-table.mjs","names":[],"sources":["../src/resolve-storage-table.ts"],"sourcesContent":["import { entityAt } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from './ir/sql-storage';\nimport type { StorageTable } from './ir/storage-table';\n\nexport interface ResolvedStorageTable {\n  readonly namespaceId: string;\n  readonly table: StorageTable;\n}\n\n/**\n * Resolve a bare storage table name to its namespace coordinate and table IR.\n *\n * When `namespaceId` is supplied, the table is resolved strictly within that\n * namespace (no scan). When omitted, a bare name unique across namespaces\n * resolves to its sole namespace; a bare name declared in more than one\n * namespace throws a fail-fast diagnostic naming the candidate namespaces\n * rather than silently selecting the first match.\n */\nexport function resolveStorageTable(\n  storage: SqlStorage,\n  tableName: string,\n  namespaceId?: string,\n): ResolvedStorageTable | undefined {\n  if (namespaceId !== undefined) {\n    const table = entityAt<StorageTable>(storage, {\n      namespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    return table === undefined ? undefined : { namespaceId, table };\n  }\n\n  const matches: ResolvedStorageTable[] = [];\n  for (const candidateNamespaceId of Object.keys(storage.namespaces)) {\n    const table = entityAt<StorageTable>(storage, {\n      namespaceId: candidateNamespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    if (table !== undefined) {\n      matches.push({ namespaceId: candidateNamespaceId, table });\n    }\n  }\n\n  if (matches.length > 1) {\n    const candidates = matches\n      .map((match) => match.namespaceId)\n      .sort()\n      .join(', ');\n    throw new Error(\n      `Storage table \"${tableName}\" is ambiguous across namespaces [${candidates}]; qualify it with a namespace coordinate.`,\n    );\n  }\n\n  return matches[0];\n}\n"],"mappings":";;;;;;;;;;;AAkBA,SAAgB,oBACd,SACA,WACA,aACkC;CAClC,IAAI,gBAAgB,KAAA,GAAW;EAC7B,MAAM,QAAQ,SAAuB,SAAS;GAC5C;GACA,YAAY;GACZ,YAAY;EACd,CAAC;EACD,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY;GAAE;GAAa;EAAM;CAChE;CAEA,MAAM,UAAkC,CAAC;CACzC,KAAK,MAAM,wBAAwB,OAAO,KAAK,QAAQ,UAAU,GAAG;EAClE,MAAM,QAAQ,SAAuB,SAAS;GAC5C,aAAa;GACb,YAAY;GACZ,YAAY;EACd,CAAC;EACD,IAAI,UAAU,KAAA,GACZ,QAAQ,KAAK;GAAE,aAAa;GAAsB;EAAM,CAAC;CAE7D;CAEA,IAAI,QAAQ,SAAS,GAAG;EACtB,MAAM,aAAa,QAChB,KAAK,UAAU,MAAM,WAAW,CAAC,CACjC,KAAK,CAAC,CACN,KAAK,IAAI;EACZ,MAAM,IAAI,MACR,kBAAkB,UAAU,oCAAoC,WAAW,2CAC7E;CACF;CAEA,OAAO,QAAQ;AACjB"}