@prisma/orm-family-sql 0.16.0-dev.36

package/dist/storage-table-BBaAmanc-BwR37LMA.d.mts

@@ -0,0 +1,130 @@
+import { t as SqlNode } from "./sql-node-kEz6YFZo-v2F7delx.mjs";
+import { n as ForeignKeyInput, t as ForeignKey } from "./foreign-key-BSy9u4O4-BnsOe5Nf.mjs";
+import { i as UniqueConstraintInput, n as PrimaryKeyInput, r as UniqueConstraint, t as PrimaryKey } from "./unique-constraint-jQWfH7dg-zLWtFp99.mjs";
+import { r as IndexInput, t as Index } from "./sql-index-DsI8HAeK-BJsn-jvD.mjs";
+import { ColumnDefault, ControlPolicy, ValueSetRef } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/1-core/contract/dist/storage-table-BBaAmanc.d.mts
+//#region src/ir/check-constraint.d.ts
+/**
+ * Hydration / construction input shape for {@link CheckConstraint}.
+ * Mirrors the on-disk storage JSON envelope so the serializer hydration
+ * walker can hand a validated literal straight to `new`.
+ */
+interface CheckConstraintInput {
+  readonly name: string;
+  readonly column: string;
+  readonly valueSet: ValueSetRef;
+}
+/**
+ * SQL Contract IR node for a table-level check constraint that restricts
+ * a column to the permitted values of a value-set.
+ *
+ * The constraint is **structured** (names a column and a value-set
+ * reference), not a raw SQL expression. Each target renders its own DDL
+ * from the structured form, keeping the contract target-agnostic.
+ *
+ * Construction is idempotent: passing an existing `CheckConstraint`
+ * instance as input produces a new instance with identical fields.
+ * The constructor does not use `instanceof` for input discrimination —
+ * it reads plain named properties, which is sufficient since
+ * `CheckConstraintInput` is a structural type.
+ */
+declare class CheckConstraint extends SqlNode {
+  readonly name: string;
+  readonly column: string;
+  readonly valueSet: ValueSetRef;
+  constructor(input: CheckConstraintInput);
+}
+//#endregion
+//#region src/ir/storage-column.d.ts
+/**
+ * Hydration / construction input shape for {@link StorageColumn}. Mirrors
+ * the on-disk storage JSON envelope exactly so the family-base
+ * serializer's hydration walker can hand an arktype-validated literal
+ * straight to `new`.
+ *
+ * `typeParams` and `typeRef` remain mutually exclusive (one or the
+ * other, not both); the constructor preserves whichever caller-side
+ * choice the input encodes.
+ */
+interface StorageColumnInput {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly many?: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+  readonly control?: ControlPolicy;
+  readonly valueSet?: ValueSetRef;
+}
+/**
+ * SQL Contract IR node for a single column entry in `StorageTable.columns`.
+ *
+ * Single concrete family-shared class — every SQL target reads the
+ * same column shape today, so there is no per-target subclass. The
+ * class type accepts any caller that constructs via
+ * `new StorageColumn(input)`; literal construction sites must pass
+ * through the constructor or the family-base hydration walker.
+ *
+ * The column's `name` is not on the class — columns are keyed by name
+ * in the parent `StorageTable.columns: Record<string, StorageColumn>`
+ * map, so a `name` field would be redundant with the key.
+ */
+declare class StorageColumn extends SqlNode {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly many?: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+  readonly control?: ControlPolicy;
+  readonly valueSet?: ValueSetRef;
+  constructor(input: StorageColumnInput);
+}
+//#endregion
+//#region src/ir/storage-table.d.ts
+interface StorageTableInput {
+  readonly columns: Record<string, StorageColumn | StorageColumnInput>;
+  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;
+  readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;
+  readonly indexes: ReadonlyArray<Index | IndexInput>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;
+  readonly control?: ControlPolicy;
+  readonly checks?: ReadonlyArray<CheckConstraint | CheckConstraintInput>;
+}
+/**
+ * SQL Contract IR node for a single table entry in a namespace's
+ * `tables` map.
+ *
+ * The constructor normalises nested IR-class fields (columns, primary
+ * key, uniques, indexes, foreign keys) into the appropriate class
+ * instances so downstream walks see a uniform AST regardless of whether
+ * the input was a JSON literal or an already-constructed class.
+ *
+ * The table's `name` is not on the class — tables are keyed by name in
+ * the parent namespace's `tables: Record<string, StorageTable>` map.
+ */
+declare class StorageTable extends SqlNode {
+  readonly columns: Readonly<Record<string, StorageColumn>>;
+  readonly uniques: ReadonlyArray<UniqueConstraint>;
+  readonly indexes: ReadonlyArray<Index>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey>;
+  readonly primaryKey?: PrimaryKey;
+  readonly control?: ControlPolicy;
+  readonly checks?: ReadonlyArray<CheckConstraint>;
+  constructor(input: StorageTableInput);
+  /**
+   * Runtime guard that a namespace `table` entry is really a `StorageTable`.
+   * The compiler already types the entry as `StorageTable`, but a
+   * freshly-deserialized contract may carry plain JSON at that slot until
+   * hydration; this duck-types the structural shape. Accepts `undefined` so
+   * optional-chained entry lookups pass straight through.
+   */
+  static is(value: StorageTable | undefined): value is StorageTable;
+  static assert(value: StorageTable | undefined, coordinate: string): asserts value is StorageTable;
+}
+//#endregion
+export { StorageTable as a, StorageColumnInput as i, CheckConstraintInput as n, StorageTableInput as o, StorageColumn as r, CheckConstraint as t };
+//# sourceMappingURL=storage-table-BBaAmanc-BwR37LMA.d.mts.map

package/dist/storage-table-BBaAmanc-BwR37LMA.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-table-BBaAmanc-BwR37LMA.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/storage-table-BBaAmanc.d.mts"],"mappings":";;;;;;;;;;;;UAWU;WACC;WACA;WACA,UAAU;;;;;;;;;;;;;;;;cAgBP,wBAAwB;WAC3B;WACA;WACA,UAAU;EACnB,YAAY,OAAO;;;;;;;;;;;;;;UAcX;WACC;WACA;WACA;WACA;WACA,aAAa;WACb;WACA,UAAU;WACV,UAAU;WACV,WAAW;;;;;;;;;;;;;;;cAeR,sBAAsB;WACzB;WACA;WACA;WACA;WACA,aAAa;WACb;WACA,UAAU;WACV,UAAU;WACV,WAAW;EACpB,YAAY,OAAO;;;;UAIX;WACC,SAAS,eAAe,gBAAgB;WACxC,aAAa,aAAa;WAC1B,SAAS,cAAc,mBAAmB;WAC1C,SAAS,cAAc,QAAQ;WAC/B,aAAa,cAAc,aAAa;WACxC,UAAU;WACV,SAAS,cAAc,kBAAkB;;;;;;;;;;;;;;cActC,qBAAqB;WACxB,SAAS,SAAS,eAAe;WACjC,SAAS,cAAc;WACvB,SAAS,cAAc;WACvB,aAAa,cAAc;WAC3B,aAAa;WACb,UAAU;WACV,SAAS,cAAc;EAChC,YAAY,OAAO;;;;;;;;SAQZ,GAAG,OAAO,2BAA2B,SAAS;SAC9C,OAAO,OAAO,0BAA0B,6BAA6B,SAAS"}

package/dist/storage-table-_LWDmPfv-DFhU2dML.mjs

@@ -0,0 +1,277 @@
+import { o as nameOf } from "./naming-BwqqVcZy-BgTObIQw.mjs";
+import { IRNodeBase, freezeNode } from "@prisma/orm-framework/components/ir";
+import { ContractValidationError } from "@prisma/orm-framework/contract/contract-validation-error";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { asNamespaceId } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/1-core/contract/dist/storage-table-_LWDmPfv.mjs
+/**
+* SQL family IR node base. Carries the family-level `kind` discriminator
+* `'sql'` and inherits the framework's `freezeNode` affordance.
+*
+* Single family-level discriminator (not per-leaf) reflects the fact that
+* SQL IR has no polymorphic dispatch today — verifiers and serializers
+* walk by structural position (`storage.tables[name].columns[name]`),
+* not by inspecting `kind`. The abstract bar for per-leaf discriminators
+* isn't earned until a future polymorphic consumer arrives.
+*
+* `kind` is installed as a non-enumerable own property on every instance,
+* which keeps three things clean simultaneously:
+*
+* - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+*   shape (no `kind` field), so emitted contract.json files and the
+*   `validateSqlContractFully` arktype schemas stay unchanged.
+* - Test assertions that use `toEqual({...})` against the pre-lift flat
+*   shape continue to pass — only enumerable own properties are
+*   compared.
+* - Direct access (`node.kind`) and runtime narrowing
+*   (`if (node.kind === 'sql')`) still work, so future polymorphic
+*   dispatch can begin reading `kind` without a runtime change.
+*
+* Future per-leaf overrides land cleanly: a class that gains a
+* polymorphic-dispatch consumer (e.g. an enum type instance walked
+* alongside other types) overrides `kind` with its narrower literal
+* at that leaf level. Per-leaf overrides will use enumerable kind
+* (matching the Mongo per-class-discriminator precedent) because they
+* encode dispatch-relevant information that callers need to see in
+* JSON envelopes; the family-level `'sql'` is uniform across all SQL
+* IR and carries no dispatch-relevant information.
+*/
+var SqlNode = class extends IRNodeBase {
+	kind;
+	constructor() {
+		super();
+		Object.defineProperty(this, "kind", {
+			value: "sql",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+	}
+};
+/**
+* SQL Contract IR node for a table-level secondary index, name-identified:
+* `name` is the full physical name; a present `prefix` marks the index as
+* wire-named (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`
+* marks it exact (the name is adopted verbatim).
+*
+* `expression`, `where`, and `unique` are genuine SQL-family attributes —
+* functional and partial indexes are standard SQL supported natively by
+* Postgres and SQLite alike, and the family IR must be able to represent
+* anything any SQL target can introspect. A target declining to AUTHOR them
+* (SQLite's rejection at namespace construction) is a capability decision,
+* not evidence of target-specificity.
+*
+* Note that this class shadows the global TypeScript `Index` lib type
+* at the family-shared name; consumer files that need both should
+* alias one (e.g.
+* `import { Index as SqlIndexNode } from '@internal/sql-contract/types'`).
+*/
+var Index = class extends SqlNode {
+	name;
+	unique;
+	constructor(input) {
+		super();
+		const name = nameOf(input.naming);
+		if (name.length === 0) throw new ContractValidationError("Index: every index carries a full physical name; an expression index must be explicitly named (a default name cannot be derived from an expression).", "storage");
+		if (input.columns === void 0 === (input.expression === void 0)) throw new ContractValidationError(`Index "${name}": exactly one of columns or expression must be set.`, "storage");
+		this.name = name;
+		this.unique = input.unique;
+		if (input.naming.kind === "wire") this.prefix = input.naming.prefix;
+		if (input.columns !== void 0) this.columns = input.columns;
+		if (input.expression !== void 0) this.expression = input.expression;
+		if (input.where !== void 0) this.where = input.where;
+		if (input.type !== void 0) this.type = input.type;
+		if (input.options !== void 0) this.options = input.options;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for a table-level check constraint that restricts
+* a column to the permitted values of a value-set.
+*
+* The constraint is **structured** (names a column and a value-set
+* reference), not a raw SQL expression. Each target renders its own DDL
+* from the structured form, keeping the contract target-agnostic.
+*
+* Construction is idempotent: passing an existing `CheckConstraint`
+* instance as input produces a new instance with identical fields.
+* The constructor does not use `instanceof` for input discrimination —
+* it reads plain named properties, which is sufficient since
+* `CheckConstraintInput` is a structural type.
+*/
+var CheckConstraint = class extends SqlNode {
+	name;
+	column;
+	valueSet;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.column = input.column;
+		this.valueSet = input.valueSet;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for one side (source or target) of a foreign-key
+* declaration. Carries the full coordinate: namespace, table, and columns.
+*
+* Cross-space discrimination is based on `spaceId` presence: absent means
+* local (same contract-space); present means cross-space (the referenced
+* table lives in the contract-space identified by `spaceId`).
+*
+* For local references `spaceId` is absent from JSON, keeping the serialized
+* shape byte-identical to contracts authored before cross-space support was
+* added. For cross-space references `spaceId` appears in JSON so round-trips
+* are lossless.
+*
+* Use `UNBOUND_NAMESPACE_ID` from `@internal/framework-components/ir`
+* as the sentinel `namespaceId` for single-namespace (unbound) references.
+*/
+var ForeignKeyReference = class extends SqlNode {
+	namespaceId;
+	tableName;
+	columns;
+	constructor(input) {
+		super();
+		this.namespaceId = asNamespaceId(input.namespaceId);
+		this.tableName = input.tableName;
+		this.columns = input.columns;
+		if (input.spaceId !== void 0) this.spaceId = input.spaceId;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for a table-level foreign-key declaration — the
+* referential constraint only (source, target, `onDelete`/`onUpdate`).
+*
+* A persisted `foreignKeys[]` entry always denotes a real constraint: whether
+* to emit the constraint at all, and whether to back it with an index, are
+* authoring-time decisions (PSL `@relation(index:)`, TS `fk({ constraint,
+* index })`) resolved once at `contract emit` — a `constraint: false` FK
+* simply has no entry here, and a backing index (if any) is its own discrete,
+* named entry in the table's `indexes[]`.
+*
+* Each FK carries explicit `source` and `target` {@link ForeignKeyReference}
+* coordinates (namespace, table, columns). For single-namespace contracts the
+* sentinel `UNBOUND_NAMESPACE_ID` appears on both sides.
+*
+* The nested references are normalised to {@link ForeignKeyReference}
+* instances inside the constructor so downstream walks see a uniform AST
+* regardless of whether the input was a JSON literal or an already-constructed
+* class instance.
+*/
+var ForeignKey = class extends SqlNode {
+	source;
+	target;
+	constructor(input) {
+		super();
+		this.source = input.source instanceof ForeignKeyReference ? input.source : new ForeignKeyReference(input.source);
+		this.target = input.target instanceof ForeignKeyReference ? input.target : new ForeignKeyReference(input.target);
+		if (input.name !== void 0) this.name = input.name;
+		if (input.onDelete !== void 0) this.onDelete = input.onDelete;
+		if (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for a table's primary-key constraint.
+*/
+var PrimaryKey = class extends SqlNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		if (input.name !== void 0) this.name = input.name;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for a single column entry in `StorageTable.columns`.
+*
+* Single concrete family-shared class — every SQL target reads the
+* same column shape today, so there is no per-target subclass. The
+* class type accepts any caller that constructs via
+* `new StorageColumn(input)`; literal construction sites must pass
+* through the constructor or the family-base hydration walker.
+*
+* The column's `name` is not on the class — columns are keyed by name
+* in the parent `StorageTable.columns: Record<string, StorageColumn>`
+* map, so a `name` field would be redundant with the key.
+*/
+var StorageColumn = class extends SqlNode {
+	nativeType;
+	codecId;
+	nullable;
+	constructor(input) {
+		super();
+		this.nativeType = input.nativeType;
+		this.codecId = input.codecId;
+		this.nullable = input.nullable;
+		if (input.many !== void 0) this.many = input.many;
+		if (input.typeParams !== void 0) this.typeParams = input.typeParams;
+		if (input.typeRef !== void 0) this.typeRef = input.typeRef;
+		if (input.default !== void 0) this.default = input.default;
+		if (input.control !== void 0) this.control = input.control;
+		if (input.valueSet !== void 0) this.valueSet = input.valueSet;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for a table-level unique constraint.
+*/
+var UniqueConstraint = class extends SqlNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		if (input.name !== void 0) this.name = input.name;
+		freezeNode(this);
+	}
+};
+/**
+* SQL Contract IR node for a single table entry in a namespace's
+* `tables` map.
+*
+* The constructor normalises nested IR-class fields (columns, primary
+* key, uniques, indexes, foreign keys) into the appropriate class
+* instances so downstream walks see a uniform AST regardless of whether
+* the input was a JSON literal or an already-constructed class.
+*
+* The table's `name` is not on the class — tables are keyed by name in
+* the parent namespace's `tables: Record<string, StorageTable>` map.
+*/
+var StorageTable = class StorageTable extends SqlNode {
+	columns;
+	uniques;
+	indexes;
+	foreignKeys;
+	constructor(input) {
+		super();
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([name, col]) => [name, col instanceof StorageColumn ? col : new StorageColumn(col)])));
+		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof UniqueConstraint ? u : new UniqueConstraint(u)));
+		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof Index ? i : new Index(i)));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof ForeignKey ? fk : new ForeignKey(fk)));
+		if (input.control !== void 0) this.control = input.control;
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));
+		freezeNode(this);
+	}
+	/**
+	* Runtime guard that a namespace `table` entry is really a `StorageTable`.
+	* The compiler already types the entry as `StorageTable`, but a
+	* freshly-deserialized contract may carry plain JSON at that slot until
+	* hydration; this duck-types the structural shape. Accepts `undefined` so
+	* optional-chained entry lookups pass straight through.
+	*/
+	static is(value) {
+		if (typeof value !== "object" || value === null) return false;
+		return "columns" in value && "uniques" in value && "indexes" in value && "foreignKeys" in value;
+	}
+	static assert(value, coordinate) {
+		if (!StorageTable.is(value)) throw new InternalError(`Expected a StorageTable at ${coordinate}`);
+	}
+};
+//#endregion
+export { PrimaryKey as a, StorageTable as c, Index as i, UniqueConstraint as l, ForeignKey as n, SqlNode as o, ForeignKeyReference as r, StorageColumn as s, CheckConstraint as t };
+
+//# sourceMappingURL=storage-table-_LWDmPfv-DFhU2dML.mjs.map

package/dist/storage-table-_LWDmPfv-DFhU2dML.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-table-_LWDmPfv-DFhU2dML.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/storage-table-_LWDmPfv.mjs"],"sourcesContent":["import { IRNodeBase, freezeNode } from \"@internal/framework-components/ir\";\nimport { ContractValidationError } from \"@internal/contract/contract-validation-error\";\nimport { nameOf } from \"@internal/sql-schema-ir/naming\";\nimport { InternalError } from \"@internal/utils/internal-error\";\nimport { asNamespaceId } from \"@internal/contract/types\";\n//#region src/ir/sql-node.ts\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*/\nvar SqlNode = class extends IRNodeBase {\n\tkind;\n\tconstructor() {\n\t\tsuper();\n\t\tObject.defineProperty(this, \"kind\", {\n\t\t\tvalue: \"sql\",\n\t\t\twritable: false,\n\t\t\tenumerable: false,\n\t\t\tconfigurable: true\n\t\t});\n\t}\n};\n//#endregion\n//#region src/ir/sql-index.ts\n/**\n* SQL Contract IR node for a table-level secondary index, name-identified:\n* `name` is the full physical name; a present `prefix` marks the index as\n* wire-named (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`\n* marks it exact (the name is adopted verbatim).\n*\n* `expression`, `where`, and `unique` are genuine SQL-family attributes —\n* functional and partial indexes are standard SQL supported natively by\n* Postgres and SQLite alike, and the family IR must be able to represent\n* anything any SQL target can introspect. A target declining to AUTHOR them\n* (SQLite's rejection at namespace construction) is a capability decision,\n* not evidence of target-specificity.\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 '@internal/sql-contract/types'`).\n*/\nvar Index = class extends SqlNode {\n\tname;\n\tunique;\n\tconstructor(input) {\n\t\tsuper();\n\t\tconst name = nameOf(input.naming);\n\t\tif (name.length === 0) throw new ContractValidationError(\"Index: every index carries a full physical name; an expression index must be explicitly named (a default name cannot be derived from an expression).\", \"storage\");\n\t\tif (input.columns === void 0 === (input.expression === void 0)) throw new ContractValidationError(`Index \"${name}\": exactly one of columns or expression must be set.`, \"storage\");\n\t\tthis.name = name;\n\t\tthis.unique = input.unique;\n\t\tif (input.naming.kind === \"wire\") this.prefix = input.naming.prefix;\n\t\tif (input.columns !== void 0) this.columns = input.columns;\n\t\tif (input.expression !== void 0) this.expression = input.expression;\n\t\tif (input.where !== void 0) this.where = input.where;\n\t\tif (input.type !== void 0) this.type = input.type;\n\t\tif (input.options !== void 0) this.options = input.options;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/check-constraint.ts\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*/\nvar CheckConstraint = class extends SqlNode {\n\tname;\n\tcolumn;\n\tvalueSet;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.name = input.name;\n\t\tthis.column = input.column;\n\t\tthis.valueSet = input.valueSet;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/foreign-key-reference.ts\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 `@internal/framework-components/ir`\n* as the sentinel `namespaceId` for single-namespace (unbound) references.\n*/\nvar ForeignKeyReference = class extends SqlNode {\n\tnamespaceId;\n\ttableName;\n\tcolumns;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.namespaceId = asNamespaceId(input.namespaceId);\n\t\tthis.tableName = input.tableName;\n\t\tthis.columns = input.columns;\n\t\tif (input.spaceId !== void 0) this.spaceId = input.spaceId;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/foreign-key.ts\n/**\n* SQL Contract IR node for a table-level foreign-key declaration — the\n* referential constraint only (source, target, `onDelete`/`onUpdate`).\n*\n* A persisted `foreignKeys[]` entry always denotes a real constraint: whether\n* to emit the constraint at all, and whether to back it with an index, are\n* authoring-time decisions (PSL `@relation(index:)`, TS `fk({ constraint,\n* index })`) resolved once at `contract emit` — a `constraint: false` FK\n* simply has no entry here, and a backing index (if any) is its own discrete,\n* named entry in the table's `indexes[]`.\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*/\nvar ForeignKey = class extends SqlNode {\n\tsource;\n\ttarget;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.source = input.source instanceof ForeignKeyReference ? input.source : new ForeignKeyReference(input.source);\n\t\tthis.target = input.target instanceof ForeignKeyReference ? input.target : new ForeignKeyReference(input.target);\n\t\tif (input.name !== void 0) this.name = input.name;\n\t\tif (input.onDelete !== void 0) this.onDelete = input.onDelete;\n\t\tif (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/primary-key.ts\n/**\n* SQL Contract IR node for a table's primary-key constraint.\n*/\nvar PrimaryKey = class extends SqlNode {\n\tcolumns;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.columns = input.columns;\n\t\tif (input.name !== void 0) this.name = input.name;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/storage-column.ts\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*/\nvar StorageColumn = class extends SqlNode {\n\tnativeType;\n\tcodecId;\n\tnullable;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.nativeType = input.nativeType;\n\t\tthis.codecId = input.codecId;\n\t\tthis.nullable = input.nullable;\n\t\tif (input.many !== void 0) this.many = input.many;\n\t\tif (input.typeParams !== void 0) this.typeParams = input.typeParams;\n\t\tif (input.typeRef !== void 0) this.typeRef = input.typeRef;\n\t\tif (input.default !== void 0) this.default = input.default;\n\t\tif (input.control !== void 0) this.control = input.control;\n\t\tif (input.valueSet !== void 0) this.valueSet = input.valueSet;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/unique-constraint.ts\n/**\n* SQL Contract IR node for a table-level unique constraint.\n*/\nvar UniqueConstraint = class extends SqlNode {\n\tcolumns;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.columns = input.columns;\n\t\tif (input.name !== void 0) this.name = input.name;\n\t\tfreezeNode(this);\n\t}\n};\n//#endregion\n//#region src/ir/storage-table.ts\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*/\nvar StorageTable = class StorageTable extends SqlNode {\n\tcolumns;\n\tuniques;\n\tindexes;\n\tforeignKeys;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([name, col]) => [name, col instanceof StorageColumn ? col : new StorageColumn(col)])));\n\t\tif (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);\n\t\tthis.uniques = Object.freeze(input.uniques.map((u) => u instanceof UniqueConstraint ? u : new UniqueConstraint(u)));\n\t\tthis.indexes = Object.freeze(input.indexes.map((i) => i instanceof Index ? i : new Index(i)));\n\t\tthis.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof ForeignKey ? fk : new ForeignKey(fk)));\n\t\tif (input.control !== void 0) this.control = input.control;\n\t\tif (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));\n\t\tfreezeNode(this);\n\t}\n\t/**\n\t* Runtime guard that a namespace `table` entry is really a `StorageTable`.\n\t* The compiler already types the entry as `StorageTable`, but a\n\t* freshly-deserialized contract may carry plain JSON at that slot until\n\t* hydration; this duck-types the structural shape. Accepts `undefined` so\n\t* optional-chained entry lookups pass straight through.\n\t*/\n\tstatic is(value) {\n\t\tif (typeof value !== \"object\" || value === null) return false;\n\t\treturn \"columns\" in value && \"uniques\" in value && \"indexes\" in value && \"foreignKeys\" in value;\n\t}\n\tstatic assert(value, coordinate) {\n\t\tif (!StorageTable.is(value)) throw new InternalError(`Expected a StorageTable at ${coordinate}`);\n\t}\n};\n//#endregion\nexport { ForeignKey as a, Index as c, PrimaryKey as i, SqlNode as l, UniqueConstraint as n, ForeignKeyReference as o, StorageColumn as r, CheckConstraint as s, StorageTable as t };\n\n//# sourceMappingURL=storage-table-_LWDmPfv.mjs.map"],"mappings":"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"}

package/dist/storage-value-set-BGlj5Uus-CvZD--GG.d.mts

@@ -0,0 +1,41 @@
+import { t as SqlNode } from "./sql-node-kEz6YFZo-v2F7delx.mjs";
+import { JsonValue } from "@prisma/orm-framework/contract/types";
+//#region ../../../2-sql/1-core/contract/dist/storage-value-set-BGlj5Uus.d.mts
+//#region src/ir/storage-value-set.d.ts
+/**
+ * Hydration / construction input shape for {@link StorageValueSet}.
+ * Mirrors the on-disk storage JSON envelope so the serializer hydration
+ * walker can hand a validated literal straight to `new`.
+ */
+interface StorageValueSetInput {
+  readonly kind: 'valueSet';
+  /** Ordered permitted values, codec-encoded. Declaration order is preserved. */
+  readonly values: readonly JsonValue[];
+}
+/**
+ * SQL Contract IR node for a value-set entry in a namespace's `valueSet`
+ * map (`SqlNamespace.entries.valueSet`).
+ *
+ * A value-set records the ordered set of permitted codec-encoded values for
+ * an enum-like column restriction. It does not carry a `codecId` — the
+ * column that references it already holds the codec; the value-set holds
+ * only the permitted values.
+ *
+ * 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
+ * namespace entries needs the discriminator in JSON).
+ *
+ * The entry's name is not on the class — value-sets are keyed by name in
+ * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.
+ */
+declare class StorageValueSet extends SqlNode {
+  readonly kind: "valueSet";
+  readonly values: readonly JsonValue[];
+  constructor(input: StorageValueSetInput);
+}
+declare function isStorageValueSet(value: unknown): value is StorageValueSet;
+//#endregion
+export { StorageValueSetInput as n, isStorageValueSet as r, StorageValueSet as t };
+//# sourceMappingURL=storage-value-set-BGlj5Uus-CvZD--GG.d.mts.map

package/dist/storage-value-set-BGlj5Uus-CvZD--GG.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-value-set-BGlj5Uus-CvZD--GG.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/storage-value-set-BGlj5Uus.d.mts"],"mappings":";;;;;;;;;UAQU;WACC;;WAEA,iBAAiB;;;;;;;;;;;;;;;;;;;;cAoBd,wBAAwB;WAC3B;WACA,iBAAiB;EAC1B,YAAY,OAAO;;iBAEJ,kBAAkB,iBAAiB,SAAS"}

package/dist/timestamp-now-generator-DRXygu32-DN9Qb1uI.mjs

@@ -0,0 +1,173 @@
+//#region ../../../2-sql/9-family/dist/timestamp-now-generator-DRXygu32.mjs
+/**
+* Canonical id for the wall-clock-now mutation default generator.
+*
+* Owned by `family-sql` because that's where the generator lives. The
+* id flows out from here to (1) the control-plane descriptor and the
+* temporal field-preset pair below, (2) the runtime-plane sibling
+* `timestamp-now-runtime-generator.ts`, and (3) authoring surfaces
+* (PSL `temporal.updatedAt()`, TS `field.temporal.updatedAt()`) via
+* the descriptor flow. Co-locating the constant with its only owner
+* keeps the framework layer free of concrete generator ids.
+*/
+const TIMESTAMP_NOW_GENERATOR_ID = "timestampNow";
+/**
+* Builds the canonical control-plane descriptor for the wall-clock-now
+* mutation default generator. The descriptor's `id` and `buildPhases`
+* are target-agnostic so PSL `temporal.updatedAt()` and TS
+* `field.temporal.updatedAt()` lower to byte-identical contracts.
+*
+* `applicableCodecIds` is omitted: `timestampNow` is preset-only (not
+* reachable via `@default(timestampNow())` lowering), and the codec is
+* co-registered by the preset descriptor itself, so the
+* `@default(...)` compatibility check has no role to play here.
+*/
+function timestampNowControlDescriptor() {
+	return {
+		id: TIMESTAMP_NOW_GENERATOR_ID,
+		buildPhases: () => ({
+			onCreate: {
+				kind: "generator",
+				id: TIMESTAMP_NOW_GENERATOR_ID
+			},
+			onUpdate: {
+				kind: "generator",
+				id: TIMESTAMP_NOW_GENERATOR_ID
+			}
+		})
+	};
+}
+/**
+* Builds the canonical `temporal.{createdAt,updatedAt}` field-preset pair
+* for a SQL target. `createdAt` lowers to a `now()` storage default;
+* `updatedAt` lowers to the `timestampNow` execution generator on both
+* `onCreate` and `onUpdate` (RD: "last modified time", non-null). Targets
+* supply the codec/native-type pair that matches their timestamp column;
+* everything else is shared so PSL `temporal.updatedAt()` and TS
+* `field.temporal.updatedAt()` lower to byte-identical contracts across
+* targets by construction.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function temporalAuthoringPresets(input) {
+	const { codecId, nativeType } = input;
+	return {
+		createdAt: {
+			kind: "fieldPreset",
+			output: {
+				codecId,
+				nativeType,
+				default: {
+					kind: "function",
+					expression: "now()"
+				}
+			}
+		},
+		updatedAt: {
+			kind: "fieldPreset",
+			output: {
+				codecId,
+				nativeType,
+				executionDefaults: {
+					onCreate: {
+						kind: "generator",
+						id: TIMESTAMP_NOW_GENERATOR_ID
+					},
+					onUpdate: {
+						kind: "generator",
+						id: TIMESTAMP_NOW_GENERATOR_ID
+					}
+				}
+			}
+		}
+	};
+}
+const TEMPORAL_PRECISION_ARG = {
+	name: "precision",
+	kind: "number",
+	optional: true,
+	integer: true,
+	minimum: 0
+};
+const TEMPORAL_ON_CREATE_ARG = {
+	name: "onCreate",
+	kind: "option",
+	values: ["now"],
+	optional: true
+};
+const TEMPORAL_ON_UPDATE_ARG = {
+	name: "onUpdate",
+	kind: "option",
+	values: ["now"],
+	optional: true
+};
+/**
+* Selects the `timestampNow` generator descriptor for the preset's `now`
+* token. The token is preset vocabulary; the generator id never appears in a
+* user's spelling (ADR 169 — `timestampNow` is preset-only).
+*/
+function temporalPhaseTemplate(index) {
+	return {
+		kind: "select",
+		index,
+		cases: { now: {
+			kind: "generator",
+			id: TIMESTAMP_NOW_GENERATOR_ID
+		} }
+	};
+}
+/**
+* Builds a `temporal.<codec>` field preset for a codec that takes a precision
+* parameter (`pg/timestamp@1`, `pg/timestamptz@1`). Arguments change field
+* properties only — never the codec, which the caller fixes here.
+*
+* All three arguments are optional: omitting `precision` omits `typeParams`
+* entirely, and omitting a phase omits that phase (both omitted omits
+* `executionDefaults`).
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function temporalCodecPresetWithPrecision(input) {
+	return {
+		kind: "fieldPreset",
+		args: [
+			TEMPORAL_PRECISION_ARG,
+			TEMPORAL_ON_CREATE_ARG,
+			TEMPORAL_ON_UPDATE_ARG
+		],
+		output: {
+			codecId: input.codecId,
+			nativeType: input.nativeType,
+			typeParams: { precision: {
+				kind: "arg",
+				index: 0
+			} },
+			executionDefaults: {
+				onCreate: temporalPhaseTemplate(1),
+				onUpdate: temporalPhaseTemplate(2)
+			}
+		}
+	};
+}
+/**
+* Builds a `temporal.<codec>` field preset for a codec with no type
+* parameters (`sqlite/datetime@1`). As with the precision-bearing variant,
+* both phase arguments are optional and omitting one omits that phase.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function temporalCodecPreset(input) {
+	return {
+		kind: "fieldPreset",
+		args: [TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG],
+		output: {
+			codecId: input.codecId,
+			nativeType: input.nativeType,
+			executionDefaults: {
+				onCreate: temporalPhaseTemplate(0),
+				onUpdate: temporalPhaseTemplate(1)
+			}
+		}
+	};
+}
+//#endregion
+export { timestampNowControlDescriptor as a, temporalCodecPresetWithPrecision as i, temporalAuthoringPresets as n, temporalCodecPreset as r, TIMESTAMP_NOW_GENERATOR_ID as t };
+
+//# sourceMappingURL=timestamp-now-generator-DRXygu32-DN9Qb1uI.mjs.map