@prisma-next/sql-contract 0.12.0-dev.6 → 0.12.0-dev.60

package/dist/types-CZZASopP.d.mts

@@ -0,0 +1,207 @@
+import { E as ReferentialAction, m as StorageTable, n as SqlNamespaceTablesInput, t as SqlNamespace } from "./sql-storage-CaAh0nd3.mjs";
+import { Namespace, NamespaceBase, StorageType } from "@prisma-next/framework-components/ir";
+import { ControlPolicy } from "@prisma-next/contract/types";
+import { CodecTrait } from "@prisma-next/framework-components/codec";
+import { ControlDriverInstance } from "@prisma-next/framework-components/control";
+
+//#region src/ir/build-sql-namespace.d.ts
+declare function buildSqlNamespace(input: SqlNamespaceTablesInput): SqlNamespace;
+declare function buildSqlNamespaceMap(namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>): Readonly<Record<string, SqlNamespace>>;
+//#endregion
+//#region src/ir/postgres-enum-storage-entry.d.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.
+ */
+declare const POSTGRES_ENUM_KIND: "postgres-enum";
+/**
+ * Structural contract every Postgres-enum slot entry honours — both
+ * the live `PostgresEnumType` IR-class instance and the raw JSON
+ * envelope shape that survives `JSON.stringify` round-trips. SQL
+ * family-layer dispatch narrows polymorphic `StorageType` slot
+ * entries to this shape via `isPostgresEnumStorageEntry`.
+ *
+ * The `codecBinding` field is accessor-shaped (live class instance) on
+ * the IR class and undefined on the raw JSON envelope; consumers that
+ * need it must guard for its presence (the JSON path synthesises an
+ * equivalent shape from `codecId` + `values`).
+ */
+interface PostgresEnumStorageEntry extends StorageType {
+  readonly kind: typeof POSTGRES_ENUM_KIND;
+  readonly name: string;
+  readonly nativeType: string;
+  readonly values: readonly string[];
+  /**
+   * Enumerable own property on the persisted JSON envelope; the live
+   * IR-class instance carries it too. Family-shared dispatch sites
+   * read `codecId` directly rather than going through the IR-class
+   * `codecBinding` accessor (which lives on the prototype and isn't
+   * present on raw JSON envelopes).
+   */
+  readonly codecId: string;
+  readonly control?: ControlPolicy;
+}
+/**
+ * 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.
+ */
+declare function isPostgresEnumStorageEntry(value: unknown): value is PostgresEnumStorageEntry;
+//#endregion
+//#region src/ir/sql-unbound-namespace.d.ts
+/**
+ * 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.
+ */
+declare class SqlUnboundNamespace extends NamespaceBase {
+  static readonly instance: SqlUnboundNamespace;
+  readonly id: "__unbound__";
+  readonly entries: Readonly<{
+    readonly table: Readonly<Record<string, StorageTable>>;
+  }>;
+  readonly kind: string;
+  private constructor();
+  qualifyTable(tableName: string): string;
+}
+//#endregion
+//#region src/types.d.ts
+interface SqlControlDriverInstance<T extends string = string> extends ControlDriverInstance<'sql', T> {
+  query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<{
+    readonly rows: Row[];
+  }>;
+}
+type ForeignKeyOptions = {
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+};
+type SqlModelFieldStorage = {
+  readonly column: string;
+  readonly codecId?: string;
+  readonly nullable?: boolean;
+};
+type SqlModelStorage = {
+  readonly table: string;
+  readonly namespaceId: string;
+  readonly fields: Record<string, SqlModelFieldStorage>;
+};
+declare const DEFAULT_FK_CONSTRAINT = true;
+declare const DEFAULT_FK_INDEX = true;
+declare function applyFkDefaults(fk: {
+  constraint?: boolean | undefined;
+  index?: boolean | undefined;
+}, overrideDefaults?: {
+  constraint?: boolean | undefined;
+  index?: boolean | undefined;
+}): {
+  constraint: boolean;
+  index: boolean;
+};
+type TypeMaps<TCodecTypes extends Record<string, {
+  output: unknown;
+}> = Record<string, never>, TQueryOperationTypes extends Record<string, unknown> = Record<string, never>, TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>, TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>> = {
+  readonly codecTypes: TCodecTypes;
+  readonly queryOperationTypes: TQueryOperationTypes;
+  readonly fieldOutputTypes: TFieldOutputTypes;
+  readonly fieldInputTypes: TFieldInputTypes;
+};
+type CodecTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly codecTypes: infer C;
+} ? C extends Record<string, {
+  output: unknown;
+}> ? C : Record<string, never> : Record<string, never>;
+/**
+ * Dispatch hint identifying the first-argument target of an operation.
+ *
+ * Used by ORM column helpers to decide whether an operation is reachable on a
+ * field. Either names a concrete codec identity or a set of capability traits
+ * that the field's codec must carry.
+ */
+type QueryOperationSelfSpec = {
+  readonly codecId: string;
+  readonly traits?: never;
+} | {
+  readonly traits: readonly CodecTrait[];
+  readonly codecId?: never;
+};
+/**
+ * Structural shape an operation's impl must return: any value carrying a
+ * codec-exact `returnType` descriptor. `Expression<T>` (from
+ * `@prisma-next/sql-relational-core/expression`, with `T extends ScopeField`)
+ * extends this. Trait-targeted returns are deliberately excluded — predicate
+ * detection and result decoding both depend on knowing the concrete return
+ * codec.
+ */
+type QueryOperationReturn = {
+  readonly returnType: {
+    readonly codecId: string;
+    readonly nullable: boolean;
+  };
+};
+type QueryOperationTypeEntry = {
+  readonly self?: QueryOperationSelfSpec;
+  readonly impl: (...args: never[]) => QueryOperationReturn;
+};
+type SqlQueryOperationTypes<_CT extends Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>, T extends Record<string, QueryOperationTypeEntry>> = T;
+type QueryOperationTypesBase = Record<string, QueryOperationTypeEntry>;
+type QueryOperationTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly queryOperationTypes: infer Q;
+} ? Q extends Record<string, unknown> ? Q : Record<string, never> : Record<string, never>;
+type TypeMapsPhantomKey = '__@prisma-next/sql-contract/typeMaps@__';
+type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & { readonly [K in TypeMapsPhantomKey]?: TTypeMaps };
+type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T ? NonNullable<T[TypeMapsPhantomKey & keyof T]> : never;
+type FieldOutputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly fieldOutputTypes: infer F;
+} ? F extends Record<string, Record<string, unknown>> ? F : Record<string, never> : Record<string, never>;
+type FieldInputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly fieldInputTypes: infer F;
+} ? F extends Record<string, Record<string, unknown>> ? F : Record<string, never> : Record<string, never>;
+type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never] ? ExtractCodecTypes<TContract> : CodecTypesOf<TTypeMaps>;
+//#endregion
+export { buildSqlNamespace as A, TypeMaps as C, POSTGRES_ENUM_KIND as D, SqlUnboundNamespace as E, PostgresEnumStorageEntry as O, SqlQueryOperationTypes as S, applyFkDefaults as T, QueryOperationTypesOf as _, ExtractCodecTypes as a, SqlModelFieldStorage as b, ExtractQueryOperationTypes as c, FieldOutputTypesOf as d, ForeignKeyOptions as f, QueryOperationTypesBase as g, QueryOperationTypeEntry as h, DEFAULT_FK_INDEX as i, buildSqlNamespaceMap as j, isPostgresEnumStorageEntry as k, ExtractTypeMapsFromContract as l, QueryOperationSelfSpec as m, ContractWithTypeMaps as n, ExtractFieldInputTypes as o, QueryOperationReturn as p, DEFAULT_FK_CONSTRAINT as r, ExtractFieldOutputTypes as s, CodecTypesOf as t, FieldInputTypesOf as u, ResolveCodecTypes as v, TypeMapsPhantomKey as w, SqlModelStorage as x, SqlControlDriverInstance as y };
+//# sourceMappingURL=types-CZZASopP.d.mts.map

package/dist/types-CZZASopP.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CZZASopP.d.mts","names":[],"sources":["../src/ir/build-sql-namespace.ts","../src/ir/postgres-enum-storage-entry.ts","../src/ir/sql-unbound-namespace.ts","../src/types.ts"],"mappings":"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"}

package/dist/{types-YQrDHy-b.mjs → types-a657xjzo.mjs}

@@ -16,9 +16,10 @@ import { asNamespaceId } from "@prisma-next/contract/types";
 * 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__" }` — symmetric
-* with the family-level non-enumerable `kind` on `SqlNode` and bounded
-* to the minimum data the framework `Namespace` interface promises.
+* 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
@@ -35,7 +36,7 @@ import { asNamespaceId } from "@prisma-next/contract/types";
 var SqlUnboundNamespace = class SqlUnboundNamespace extends NamespaceBase {
 	static instance = new SqlUnboundNamespace();
 	id = UNBOUND_NAMESPACE_ID;
-	tables = Object.freeze({});
+	entries = Object.freeze({ table: Object.freeze({}) });
 	constructor() {
 		super();
 		Object.defineProperty(this, "kind", {
@@ -46,6 +47,9 @@ var SqlUnboundNamespace = class SqlUnboundNamespace extends NamespaceBase {
 		});
 		freezeNode(this);
 	}
+	qualifyTable(tableName) {
+		return `"${tableName}"`;
+	}
 };
 //#endregion
 //#region src/ir/sql-node.ts
@@ -99,6 +103,15 @@ var SqlNode = class extends IRNodeBase {
 * 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 `@prisma-next/framework-components/ir`
 * as the sentinel `namespaceId` for single-namespace (unbound) references.
 */
@@ -111,6 +124,7 @@ var ForeignKeyReference = class extends SqlNode {
 		this.namespaceId = asNamespaceId(input.namespaceId);
 		this.tableName = input.tableName;
 		this.columns = input.columns;
+		if (input.spaceId !== void 0) this.spaceId = input.spaceId;
 		freezeNode(this);
 	}
 };
@@ -208,6 +222,7 @@ var StorageColumn = class extends SqlNode {
 		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);
 	}
 };
@@ -256,6 +271,35 @@ var StorageTable = class extends SqlNode {
 	}
 };
 //#endregion
+//#region src/ir/storage-value-set.ts
+/**
+* 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 (`'value-set'`) 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.
+*/
+var StorageValueSet = class extends SqlNode {
+	kind = "value-set";
+	values;
+	constructor(input) {
+		super();
+		this.values = Object.freeze([...input.values]);
+		freezeNode(this);
+	}
+};
+//#endregion
 //#region src/ir/build-sql-namespace.ts
 const SQL_NAMESPACE_KIND = "sql-namespace";
 function isMaterializedSqlNamespace(ns) {
@@ -266,23 +310,24 @@ function isMaterializedSqlNamespace(ns) {
 }
 var SqlBoundNamespace = class SqlBoundNamespace extends NamespaceBase {
 	id;
-	tables;
+	entries;
 	static fromTablesInput(input) {
-		const tableCount = Object.keys(input.tables ?? {}).length;
-		const enumCount = Object.keys(input.enum ?? {}).length;
-		if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && enumCount === 0) return castAs(SqlUnboundNamespace.instance);
+		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;
-		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables ?? {}).map(([name, t]) => [name, t instanceof StorageTable ? t : new StorageTable(t)])));
-		if (input.enum !== void 0 && Object.keys(input.enum).length > 0) Object.defineProperty(this, "enum", {
-			value: Object.freeze({ ...input.enum }),
-			writable: false,
-			enumerable: true,
-			configurable: false
-		});
+		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,
@@ -291,12 +336,16 @@ var SqlBoundNamespace = class SqlBoundNamespace extends NamespaceBase {
 		});
 		freezeNode(this);
 	}
+	qualifyTable(tableName) {
+		if (this.id === UNBOUND_NAMESPACE_ID) return `"${tableName}"`;
+		return `"${this.id}"."${tableName}"`;
+	}
 };
 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(ns)]));
+	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
@@ -370,11 +419,13 @@ var SqlStorage = class extends SqlNode {
 		freezeNode(this);
 	}
 };
+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 recognised `kind` discriminator — either
-* `'codec-instance'` (codec triple, family-shared) or
-* `'postgres-enum'` (target-specific IR class). Untagged or
+* 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
@@ -388,14 +439,10 @@ var SqlStorage = class extends SqlNode {
 * only fires for in-memory authoring bugs.
 */
 function normaliseTypeEntry(name, entry) {
-	if (isPostgresEnumStorageEntry(entry)) {
-		if (entry instanceof SqlNode) return entry;
-		throw new Error(`Encountered raw postgres-enum JSON in storage.types[${JSON.stringify(name)}] without serializer hydration; use a target ContractSerializer that registers the matching entity-type factory.`);
-	}
 	if (isStorageTypeInstance(entry)) return entry;
 	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")} or ${JSON.stringify("postgres-enum")}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`);
+	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
@@ -408,6 +455,6 @@ function applyFkDefaults(fk, overrideDefaults) {
 	};
 }
 //#endregion
-export { ForeignKey as _, CODEC_INSTANCE_KIND as a, SqlUnboundNamespace as b, POSTGRES_ENUM_KIND as c, buildSqlNamespaceMap as d, StorageTable as f, PrimaryKey as g, Index as h, SqlStorage as i, isPostgresEnumStorageEntry as l, StorageColumn as m, DEFAULT_FK_INDEX as n, isStorageTypeInstance as o, UniqueConstraint as p, applyFkDefaults as r, toStorageTypeInstance as s, DEFAULT_FK_CONSTRAINT as t, buildSqlNamespace as u, ForeignKeyReference as v, SqlNode as y };
+export { SqlUnboundNamespace 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, SqlNode as x, ForeignKey as y };
 
-//# sourceMappingURL=types-YQrDHy-b.mjs.map
+//# sourceMappingURL=types-a657xjzo.mjs.map

package/dist/types-a657xjzo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-a657xjzo.mjs","names":[],"sources":["../src/ir/sql-unbound-namespace.ts","../src/ir/sql-node.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/ir/build-sql-namespace.ts","../src/ir/postgres-enum-storage-entry.ts","../src/ir/storage-type-instance.ts","../src/ir/sql-storage.ts","../src/types.ts"],"sourcesContent":["import {\n  freezeNode,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport type { StorageTable } from './storage-table';\n\n/**\n * Family-layer placeholder for the SQL unbound-namespace singleton —\n * the late-bound slot whose binding the target resolves at connection\n * time rather than at authoring time.\n *\n * SQL contracts honour the framework `Storage.namespaces` invariant from\n * the moment they appear in the IR. Today `SqlStorage` is family-shared\n * (Postgres + SQLite consume the same class); a per-target namespace\n * concretion (`PostgresSchema.unbound`, `SqliteUnboundDatabase.instance`)\n * earns its existence when each target's namespace shape lands. Until\n * then the family ships a single placeholder singleton so the JSON\n * envelope and runtime walk are honest at every layer.\n *\n * The `kind` discriminator is installed as a non-enumerable own property\n * so the JSON envelope reads `{ \"id\": \"__unbound__\", \"entries\": { … } }`\n * — symmetric with the family-level non-enumerable `kind` on `SqlNode`\n * and bounded to the minimum data the framework `Namespace` interface\n * promises.\n *\n * **Freeze-trap warning.** The leaf constructor calls\n * `freezeNode(this)` after installing `kind`. The leaf-class shape\n * works today only because `NamespaceBase` does NOT freeze in its\n * constructor — the `Object.defineProperty(this, 'kind', …)` call after\n * `super()` succeeds because the instance is still mutable at that\n * point. Subclasses that add instance fields will still hit the freeze\n * trap once leaf-class `freezeNode(this)` runs; and if a future\n * framework change lifts the freeze to `NamespaceBase`, even the\n * `defineProperty` here would silently fail. To add subclass instance\n * fields safely, lift `freezeNode` to a leaf-class `seal()` hook each\n * leaf calls explicitly at the end of its own constructor.\n */\nexport class SqlUnboundNamespace extends NamespaceBase {\n  static readonly instance: SqlUnboundNamespace = new SqlUnboundNamespace();\n\n  readonly id = UNBOUND_NAMESPACE_ID;\n  readonly entries: Readonly<{\n    readonly table: Readonly<Record<string, StorageTable>>;\n  }> = Object.freeze({ table: Object.freeze({}) });\n  declare readonly kind: string;\n\n  private constructor() {\n    super();\n    Object.defineProperty(this, 'kind', {\n      value: 'sql-namespace',\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\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. PostgresEnumType in\n      // target-postgres) 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 { 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 { 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}\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\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    freezeNode(this);\n  }\n}\n","import { 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: 'value-set';\n  /** Ordered permitted values, codec-encoded. Declaration order is preserved. */\n  readonly values: readonly string[];\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 (`'value-set'`) 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 = 'value-set' as const;\n  readonly values: readonly string[];\n\n  constructor(input: StorageValueSetInput) {\n    super();\n    this.values = Object.freeze([...input.values]);\n    freezeNode(this);\n  }\n}\n","import {\n  freezeNode,\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { blindCast, castAs } from '@prisma-next/utils/casts';\nimport type { SqlNamespace, SqlNamespaceTablesInput } from './sql-storage';\nimport { SqlUnboundNamespace } from './sql-unbound-namespace';\nimport { StorageTable } from './storage-table';\nimport { StorageValueSet } from './storage-value-set';\n\nconst SQL_NAMESPACE_KIND = 'sql-namespace' as const;\n\nfunction isMaterializedSqlNamespace(ns: Namespace | SqlNamespaceTablesInput): ns is SqlNamespace {\n  if (typeof ns !== 'object' || ns === null) {\n    return false;\n  }\n  const proto = Object.getPrototypeOf(ns);\n  if (proto === Object.prototype || proto === null) {\n    return false;\n  }\n  return (ns as Namespace).kind === SQL_NAMESPACE_KIND;\n}\n\nclass SqlBoundNamespace extends NamespaceBase {\n  declare readonly kind: string;\n\n  readonly id: string;\n  readonly entries: Readonly<{\n    readonly table: Readonly<Record<string, StorageTable>>;\n    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;\n  }>;\n\n  static fromTablesInput(input: SqlNamespaceTablesInput): SqlNamespace {\n    const tableCount = Object.keys(input.entries.table).length;\n    const hasValueSets =\n      input.entries.valueSet !== undefined && Object.keys(input.entries.valueSet).length > 0;\n    if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && !hasValueSets) {\n      return castAs<SqlNamespace>(SqlUnboundNamespace.instance);\n    }\n    return castAs<SqlNamespace>(new SqlBoundNamespace(input));\n  }\n\n  private constructor(input: SqlNamespaceTablesInput) {\n    super();\n    this.id = input.id;\n    const table = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.entries.table).map(([k, v]) => [k, new StorageTable(v)]),\n      ),\n    );\n    if (input.entries.valueSet !== undefined) {\n      const valueSet = Object.freeze(\n        Object.fromEntries(\n          Object.entries(input.entries.valueSet).map(([k, v]) => [k, new StorageValueSet(v)]),\n        ),\n      );\n      this.entries = Object.freeze({ table, valueSet });\n    } else {\n      this.entries = Object.freeze({ table });\n    }\n    Object.defineProperty(this, 'kind', {\n      value: SQL_NAMESPACE_KIND,\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  qualifyTable(tableName: string): string {\n    if (this.id === UNBOUND_NAMESPACE_ID) {\n      return `\"${tableName}\"`;\n    }\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n}\n\nexport function buildSqlNamespace(input: SqlNamespaceTablesInput): SqlNamespace {\n  return SqlBoundNamespace.fromTablesInput(input);\n}\n\nexport function buildSqlNamespaceMap(\n  namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>,\n): Readonly<Record<string, SqlNamespace>> {\n  return Object.fromEntries(\n    Object.entries(namespaces).map(([nsKey, ns]) => [\n      nsKey,\n      isMaterializedSqlNamespace(ns)\n        ? blindCast<\n            SqlNamespace,\n            'a materialised SQL-family namespace entry in a namespace map is a SqlNamespace'\n          >(ns)\n        : SqlBoundNamespace.fromTablesInput(\n            blindCast<\n              SqlNamespaceTablesInput,\n              'non-materialized SQL namespace map entry is a SqlNamespaceTablesInput'\n            >(ns),\n          ),\n    ]),\n  );\n}\n","import type { ControlPolicy } from '@prisma-next/contract/types';\nimport type { StorageType } from '@prisma-next/framework-components/ir';\n\n/**\n * Discriminator literal for the Postgres-enum variant on the polymorphic\n * `SqlStorage.types` slot.\n *\n * Enums are a target-level concept: Postgres ships native\n * `CREATE TYPE … AS ENUM` while other SQL targets approximate enums via\n * constraints. The literal lives at the SQL family layer because every\n * SQL-family consumer (verifier, planner, lowering, …) needs to\n * discriminate enum-typed slot entries from codec-typed ones. The\n * concrete IR class (`PostgresEnumType`) lives in the target-postgres\n * package and implements this structural contract; cross-domain\n * layering rules forbid the SQL family from importing the concrete\n * target class directly, so the discriminator and structural interface\n * carry the dispatch.\n */\nexport const POSTGRES_ENUM_KIND = 'postgres-enum' as const;\n\n/**\n * Structural contract every Postgres-enum slot entry honours — both\n * the live `PostgresEnumType` IR-class instance and the raw JSON\n * envelope shape that survives `JSON.stringify` round-trips. SQL\n * family-layer dispatch narrows polymorphic `StorageType` slot\n * entries to this shape via `isPostgresEnumStorageEntry`.\n *\n * The `codecBinding` field is accessor-shaped (live class instance) on\n * the IR class and undefined on the raw JSON envelope; consumers that\n * need it must guard for its presence (the JSON path synthesises an\n * equivalent shape from `codecId` + `values`).\n */\nexport interface PostgresEnumStorageEntry extends StorageType {\n  readonly kind: typeof POSTGRES_ENUM_KIND;\n  readonly name: string;\n  readonly nativeType: string;\n  readonly values: readonly string[];\n  /**\n   * Enumerable own property on the persisted JSON envelope; the live\n   * IR-class instance carries it too. Family-shared dispatch sites\n   * read `codecId` directly rather than going through the IR-class\n   * `codecBinding` accessor (which lives on the prototype and isn't\n   * present on raw JSON envelopes).\n   */\n  readonly codecId: string;\n  readonly control?: ControlPolicy;\n}\n\n/**\n * Narrow a polymorphic `StorageType` entry to the Postgres-enum shape\n * via its enumerable `kind` discriminator. Type guard returns true for\n * both live `PostgresEnumType` instances and raw JSON envelopes.\n */\nexport function isPostgresEnumStorageEntry(value: unknown): value is PostgresEnumStorageEntry {\n  if (typeof value !== 'object' || value === null) return false;\n  return (value as { kind?: unknown }).kind === POSTGRES_ENUM_KIND;\n}\n","import type { StorageType } from '@prisma-next/framework-components/ir';\n\n/**\n * Sentinel kind for the legacy codec-triple shape persisted under\n * `SqlStorage.types`. Plain JSON-clean object literals carry this\n * discriminator so the polymorphic slot dispatch can route them down\n * the codec path while target-specific IR class instances (e.g. the\n * Postgres enum class) keep their own narrower `kind` literal.\n */\nexport const CODEC_INSTANCE_KIND = 'codec-instance' as const;\n\n/**\n * Structural sub-interface of {@link StorageType} for codec-typed entries\n * in `SqlStorage.types`. These are plain object literals — there is no\n * runtime IR class, the JSON envelope round-trips through the slot\n * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch\n * key that distinguishes codec-typed entries from class-instance entries\n * (e.g. `PostgresEnumType`) sharing the polymorphic slot.\n */\nexport interface StorageTypeInstance extends StorageType {\n  readonly kind: typeof CODEC_INSTANCE_KIND;\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams: Record<string, unknown>;\n}\n\n/**\n * Construction-time input for a codec-triple entry. Symmetric with the\n * structural runtime shape minus the `kind` discriminator — callers may\n * omit `kind`; the helper {@link toStorageTypeInstance} stamps it on.\n */\nexport interface StorageTypeInstanceInput {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams: Record<string, unknown>;\n}\n\n/**\n * Stamp the codec-instance `kind` discriminator on a caller-supplied\n * codec triple. Idempotent: input that already carries the discriminator\n * passes through unchanged.\n */\nexport function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageTypeInstance {\n  return {\n    kind: CODEC_INSTANCE_KIND,\n    codecId: input.codecId,\n    nativeType: input.nativeType,\n    typeParams: input.typeParams,\n  };\n}\n\n/**\n * Type-guard for codec-typed entries on the polymorphic\n * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from\n * class-instance kinds (e.g. `PostgresEnumType`).\n */\nexport function isStorageTypeInstance(value: unknown): value is StorageTypeInstance {\n  if (typeof value !== 'object' || value === null) return false;\n  return (value as { kind?: unknown }).kind === CODEC_INSTANCE_KIND;\n}\n","import type { StorageHashBase } from '@prisma-next/contract/types';\nimport { freezeNode, type Namespace, type Storage } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\nimport type { StorageTable, StorageTableInput } from './storage-table';\nimport {\n  isStorageTypeInstance,\n  type StorageTypeInstance,\n  type StorageTypeInstanceInput,\n} from './storage-type-instance';\nimport type { StorageValueSet, StorageValueSetInput } from './storage-value-set';\n\n/**\n * Polymorphic value type for document-scoped `SqlStorage.types` entries\n * (codec aliases / parameterised native type registrations).\n *\n * Postgres native enum registrations live under the postgres-specific\n * `entries.type` slot on `PostgresSchema` (target layer), not here.\n */\nexport type SqlStorageTypeEntry = StorageTypeInstance | StorageTypeInstanceInput;\n\nexport interface SqlNamespaceTablesInput {\n  readonly id: string;\n  readonly entries: {\n    readonly table: Record<string, StorageTable | StorageTableInput>;\n    readonly valueSet?: Record<string, StorageValueSet | StorageValueSetInput>;\n  };\n}\n\nexport interface SqlStorageInput<THash extends string = string> {\n  readonly storageHash: StorageHashBase<THash>;\n  readonly types?: Record<string, SqlStorageTypeEntry>;\n  readonly namespaces: Readonly<Record<string, SqlNamespace>>;\n}\n\n/**\n * SQL Contract IR root node for the `storage` field.\n *\n * Single concrete family-shared class — both Postgres and SQLite\n * consume this class today. Per-target storage subclasses are\n * introduced when each target's namespace shape earns its\n * target-specific concretion (target-specific derived fields,\n * target-specific storage extensions).\n *\n * Honours the framework `Storage` interface: every SQL IR carries a\n * `namespaces` map keyed by namespace id. Callers must supply fully\n * constructed `Namespace` instances — construction discipline lives\n * in the authoring builders and deserializer hydration paths.\n *\n * The constructor normalises optional `types` into class instances.\n * `types` is polymorphic per Decision 18 Option B: codec-triple inputs\n * are stamped with `kind: 'codec-instance'`; hydration of raw JSON\n * class-instance entries (carrying their narrower `kind` literal) is\n * the per-target serializer's responsibility (so the family base does\n * not import target-specific subclasses).\n */\n// SQL concretions store `StorageTable` values under `entries.table`.\n// Mongo namespaces carry `entries.collection` instead. The wider\n// `Record<string, object>` on `StorageTable` is only there so emitted\n// `contract.d.ts` table literals (which lack the runtime `kind`\n// discriminator on `StorageTable`) structurally satisfy the slot without\n// a class-instance check.\nexport type SqlNamespace = Namespace & {\n  readonly entries: Readonly<{\n    readonly table: Readonly<Record<string, StorageTable>>;\n    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;\n  }>;\n  /**\n   * Render a dialect-qualified table reference for runtime SQL emission.\n   * Present on materialised target concretions (`PostgresSchema`,\n   * `SqliteDatabase`, …) and family placeholders; omitted on emitted\n   * contract structural namespace literals (methods are not serialised).\n   */\n  qualifyTable?(tableName: string): string;\n};\n\nexport class SqlStorage<THash extends string = string> extends SqlNode implements Storage {\n  readonly storageHash: StorageHashBase<THash>;\n  readonly namespaces: Readonly<Record<string, SqlNamespace>>;\n  declare readonly types?: Readonly<Record<string, StorageTypeInstance>>;\n\n  constructor(input: SqlStorageInput<THash>) {\n    super();\n    this.storageHash = input.storageHash;\n    this.namespaces = Object.freeze(input.namespaces);\n    if (input.types !== undefined) {\n      this.types = Object.freeze(\n        Object.fromEntries(\n          Object.entries(input.types).map(([name, ti]) => [name, normaliseTypeEntry(name, ti)]),\n        ),\n      );\n    }\n    freezeNode(this);\n  }\n}\n\nexport function storageTableAt(\n  storage: SqlStorage,\n  namespaceId: string,\n  tableName: string,\n): StorageTable | undefined {\n  return storage.namespaces[namespaceId]?.entries.table[tableName];\n}\n\n/**\n * Strict polymorphic-slot dispatch for `SqlStorage.types` entries.\n * Every entry must carry a `kind: 'codec-instance'` discriminator or\n * be an already-constructed `StorageTypeInstance`. Untagged or\n * unrecognised inputs throw a diagnostic naming the entry and its\n * `kind`, so format drift surfaces loudly at the deserializer\n * boundary instead of slipping past the seam and corrupting\n * downstream IR walks.\n *\n * Codec-triple authors that have an untagged shape on hand can call\n * `toStorageTypeInstance(...)` (which stamps the `'codec-instance'`\n * discriminator) before constructing `SqlStorage`. On-disk reads\n * cross `familyInstance.deserializeContract` first; the structural\n * arktype schema rejects untagged entries earlier, so this throw\n * only fires for in-memory authoring bugs.\n */\nfunction normaliseTypeEntry(name: string, entry: SqlStorageTypeEntry): StorageTypeInstance {\n  if (isStorageTypeInstance(entry)) {\n    return entry;\n  }\n  const rawKind = (entry as { kind?: unknown }).kind;\n  const kindDescription =\n    rawKind === undefined\n      ? 'missing `kind` discriminator'\n      : `unrecognised \\`kind\\` discriminator ${JSON.stringify(rawKind)}`;\n  throw new Error(\n    `storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify('codec-instance')}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`,\n  );\n}\n","import type { CodecTrait } from '@prisma-next/framework-components/codec';\nimport type { ControlDriverInstance } from '@prisma-next/framework-components/control';\nimport type { ReferentialAction } from './ir/foreign-key';\n\nexport interface SqlControlDriverInstance<T extends string = string>\n  extends ControlDriverInstance<'sql', T> {\n  query<Row = Record<string, unknown>>(\n    sql: string,\n    params?: readonly unknown[],\n  ): Promise<{ readonly rows: Row[] }>;\n}\n\nexport { buildSqlNamespace, buildSqlNamespaceMap } from './ir/build-sql-namespace';\nexport {\n  ForeignKey,\n  type ForeignKeyInput,\n  type ReferentialAction,\n} from './ir/foreign-key';\nexport {\n  ForeignKeyReference,\n  type ForeignKeyReferenceInput,\n} from './ir/foreign-key-reference';\nexport {\n  isPostgresEnumStorageEntry,\n  POSTGRES_ENUM_KIND,\n  type PostgresEnumStorageEntry,\n} from './ir/postgres-enum-storage-entry';\nexport { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';\nexport { Index, type IndexInput } from './ir/sql-index';\nexport { SqlNode } from './ir/sql-node';\nexport {\n  type SqlNamespaceTablesInput,\n  SqlStorage,\n  type SqlStorageInput,\n  type SqlStorageTypeEntry,\n  storageTableAt,\n} from './ir/sql-storage';\nexport { SqlUnboundNamespace } from './ir/sql-unbound-namespace';\nexport { StorageColumn, type StorageColumnInput } from './ir/storage-column';\nexport { StorageTable, type StorageTableInput } from './ir/storage-table';\nexport {\n  CODEC_INSTANCE_KIND,\n  isStorageTypeInstance,\n  type StorageTypeInstance,\n  type StorageTypeInstanceInput,\n  toStorageTypeInstance,\n} from './ir/storage-type-instance';\nexport { StorageValueSet, type StorageValueSetInput } from './ir/storage-value-set';\nexport {\n  UniqueConstraint,\n  type UniqueConstraintInput,\n} from './ir/unique-constraint';\n\nexport type ForeignKeyOptions = {\n  readonly name?: string;\n  readonly onDelete?: ReferentialAction;\n  readonly onUpdate?: ReferentialAction;\n};\n\nexport type SqlModelFieldStorage = {\n  readonly column: string;\n  readonly codecId?: string;\n  readonly nullable?: boolean;\n};\n\nexport type SqlModelStorage = {\n  readonly table: string;\n  readonly namespaceId: string;\n  readonly fields: Record<string, SqlModelFieldStorage>;\n};\n\nexport const DEFAULT_FK_CONSTRAINT = true;\nexport const DEFAULT_FK_INDEX = true;\n\nexport function applyFkDefaults(\n  fk: { constraint?: boolean | undefined; index?: boolean | undefined },\n  overrideDefaults?: { constraint?: boolean | undefined; index?: boolean | undefined },\n): { constraint: boolean; index: boolean } {\n  return {\n    constraint: fk.constraint ?? overrideDefaults?.constraint ?? DEFAULT_FK_CONSTRAINT,\n    index: fk.index ?? overrideDefaults?.index ?? DEFAULT_FK_INDEX,\n  };\n}\n\nexport type TypeMaps<\n  TCodecTypes extends Record<string, { output: unknown }> = Record<string, never>,\n  TQueryOperationTypes extends Record<string, unknown> = Record<string, never>,\n  TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,\n  TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,\n> = {\n  readonly codecTypes: TCodecTypes;\n  readonly queryOperationTypes: TQueryOperationTypes;\n  readonly fieldOutputTypes: TFieldOutputTypes;\n  readonly fieldInputTypes: TFieldInputTypes;\n};\n\nexport type CodecTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly codecTypes: infer C }\n    ? C extends Record<string, { output: unknown }>\n      ? C\n      : Record<string, never>\n    : Record<string, never>;\n\n/**\n * Dispatch hint identifying the first-argument target of an operation.\n *\n * Used by ORM column helpers to decide whether an operation is reachable on a\n * field. Either names a concrete codec identity or a set of capability traits\n * that the field's codec must carry.\n */\nexport type QueryOperationSelfSpec =\n  | { readonly codecId: string; readonly traits?: never }\n  | { readonly traits: readonly CodecTrait[]; readonly codecId?: never };\n\n/**\n * Structural shape an operation's impl must return: any value carrying a\n * codec-exact `returnType` descriptor. `Expression<T>` (from\n * `@prisma-next/sql-relational-core/expression`, with `T extends ScopeField`)\n * extends this. Trait-targeted returns are deliberately excluded — predicate\n * detection and result decoding both depend on knowing the concrete return\n * codec.\n */\nexport type QueryOperationReturn = {\n  readonly returnType: { readonly codecId: string; readonly nullable: boolean };\n};\n\nexport type QueryOperationTypeEntry = {\n  readonly self?: QueryOperationSelfSpec;\n  readonly impl: (...args: never[]) => QueryOperationReturn;\n};\n\nexport type SqlQueryOperationTypes<\n  _CT extends Record<string, { readonly input: unknown; readonly output: unknown }>,\n  T extends Record<string, QueryOperationTypeEntry>,\n> = T;\n\nexport type QueryOperationTypesBase = Record<string, QueryOperationTypeEntry>;\n\nexport type QueryOperationTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly queryOperationTypes: infer Q }\n    ? Q extends Record<string, unknown>\n      ? Q\n      : Record<string, never>\n    : Record<string, never>;\n\nexport type TypeMapsPhantomKey = '__@prisma-next/sql-contract/typeMaps@__';\n\nexport type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & {\n  readonly [K in TypeMapsPhantomKey]?: TTypeMaps;\n};\n\nexport type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T\n  ? NonNullable<T[TypeMapsPhantomKey & keyof T]>\n  : never;\n\nexport type FieldOutputTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly fieldOutputTypes: infer F }\n    ? F extends Record<string, Record<string, unknown>>\n      ? F\n      : Record<string, never>\n    : Record<string, never>;\n\nexport type FieldInputTypesOf<T> = [T] extends [never]\n  ? Record<string, never>\n  : T extends { readonly fieldInputTypes: infer F }\n    ? F extends Record<string, Record<string, unknown>>\n      ? F\n      : Record<string, never>\n    : Record<string, never>;\n\nexport type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;\nexport type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;\nexport type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;\nexport type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;\n\nexport type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never]\n  ? ExtractCodecTypes<TContract>\n  : CodecTypesOf<TTypeMaps>;\n"],"mappings":"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"}

package/dist/types.d.mts

@@ -1,2 +1,3 @@
-import { $ as ForeignKeyReference, A as SqlStorageInput, B as UniqueConstraintInput, C as TypeMapsPhantomKey, D as buildSqlNamespaceMap, E as buildSqlNamespace, F as isStorageTypeInstance, G as PrimaryKey, H as StorageColumnInput, I as toStorageTypeInstance, J as PostgresEnumStorageEntry, K as PrimaryKeyInput, L as StorageTable, M as CODEC_INSTANCE_KIND, N as StorageTypeInstance, O as SqlNamespaceTablesInput, P as StorageTypeInstanceInput, Q as ReferentialAction, R as StorageTableInput, S as TypeMaps, T as SqlUnboundNamespace, U as Index, V as StorageColumn, W as IndexInput, X as ForeignKey, Y as isPostgresEnumStorageEntry, Z as ForeignKeyInput, _ as QueryOperationTypesOf, a as ExtractCodecTypes, b as SqlModelStorage, c as ExtractQueryOperationTypes, d as FieldOutputTypesOf, et as ForeignKeyReferenceInput, f as ForeignKeyOptions, g as QueryOperationTypesBase, h as QueryOperationTypeEntry, i as DEFAULT_FK_INDEX, j as SqlStorageTypeEntry, k as SqlStorage, l as ExtractTypeMapsFromContract, m as QueryOperationSelfSpec, n as ContractWithTypeMaps, o as ExtractFieldInputTypes, p as QueryOperationReturn, q as POSTGRES_ENUM_KIND, r as DEFAULT_FK_CONSTRAINT, s as ExtractFieldOutputTypes, t as CodecTypesOf, tt as SqlNode, u as FieldInputTypesOf, v as ResolveCodecTypes, w as applyFkDefaults, x as SqlQueryOperationTypes, y as SqlModelFieldStorage, z as UniqueConstraint } from "./types-Cx_5A_L0.mjs";
-export { CODEC_INSTANCE_KIND, type CodecTypesOf, type ContractWithTypeMaps, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, type ExtractCodecTypes, type ExtractFieldInputTypes, type ExtractFieldOutputTypes, type ExtractQueryOperationTypes, type ExtractTypeMapsFromContract, type FieldInputTypesOf, type FieldOutputTypesOf, ForeignKey, type ForeignKeyInput, type ForeignKeyOptions, ForeignKeyReference, type ForeignKeyReferenceInput, Index, type IndexInput, POSTGRES_ENUM_KIND, type PostgresEnumStorageEntry, PrimaryKey, type PrimaryKeyInput, type QueryOperationReturn, type QueryOperationSelfSpec, type QueryOperationTypeEntry, type QueryOperationTypesBase, type QueryOperationTypesOf, type ReferentialAction, type ResolveCodecTypes, type SqlModelFieldStorage, type SqlModelStorage, type SqlNamespaceTablesInput, SqlNode, type SqlQueryOperationTypes, SqlStorage, type SqlStorageInput, type SqlStorageTypeEntry, SqlUnboundNamespace, StorageColumn, type StorageColumnInput, StorageTable, type StorageTableInput, type StorageTypeInstance, type StorageTypeInstanceInput, type TypeMaps, type TypeMapsPhantomKey, UniqueConstraint, type UniqueConstraintInput, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance };
+import { C as PrimaryKeyInput, D as ForeignKeyReference, E as ReferentialAction, O as ForeignKeyReferenceInput, S as PrimaryKey, T as ForeignKeyInput, _ as UniqueConstraintInput, a as SqlStorageTypeEntry, b as Index, c as StorageValueSetInput, d as StorageTypeInstanceInput, f as isStorageTypeInstance, g as UniqueConstraint, h as StorageTableInput, i as SqlStorageInput, k as SqlNode, l as CODEC_INSTANCE_KIND, m as StorageTable, n as SqlNamespaceTablesInput, o as storageTableAt, p as toStorageTypeInstance, r as SqlStorage, s as StorageValueSet, u as StorageTypeInstance, v as StorageColumn, w as ForeignKey, x as IndexInput, y as StorageColumnInput } from "./sql-storage-CaAh0nd3.mjs";
+import { A as buildSqlNamespace, C as TypeMaps, D as POSTGRES_ENUM_KIND, E as SqlUnboundNamespace, O as PostgresEnumStorageEntry, S as SqlQueryOperationTypes, T as applyFkDefaults, _ as QueryOperationTypesOf, a as ExtractCodecTypes, b as SqlModelFieldStorage, c as ExtractQueryOperationTypes, d as FieldOutputTypesOf, f as ForeignKeyOptions, g as QueryOperationTypesBase, h as QueryOperationTypeEntry, i as DEFAULT_FK_INDEX, j as buildSqlNamespaceMap, k as isPostgresEnumStorageEntry, l as ExtractTypeMapsFromContract, m as QueryOperationSelfSpec, n as ContractWithTypeMaps, o as ExtractFieldInputTypes, p as QueryOperationReturn, r as DEFAULT_FK_CONSTRAINT, s as ExtractFieldOutputTypes, t as CodecTypesOf, u as FieldInputTypesOf, v as ResolveCodecTypes, w as TypeMapsPhantomKey, x as SqlModelStorage, y as SqlControlDriverInstance } from "./types-CZZASopP.mjs";
+export { CODEC_INSTANCE_KIND, type CodecTypesOf, type ContractWithTypeMaps, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, type ExtractCodecTypes, type ExtractFieldInputTypes, type ExtractFieldOutputTypes, type ExtractQueryOperationTypes, type ExtractTypeMapsFromContract, type FieldInputTypesOf, type FieldOutputTypesOf, ForeignKey, type ForeignKeyInput, type ForeignKeyOptions, ForeignKeyReference, type ForeignKeyReferenceInput, Index, type IndexInput, POSTGRES_ENUM_KIND, type PostgresEnumStorageEntry, PrimaryKey, type PrimaryKeyInput, type QueryOperationReturn, type QueryOperationSelfSpec, type QueryOperationTypeEntry, type QueryOperationTypesBase, type QueryOperationTypesOf, type ReferentialAction, type ResolveCodecTypes, type SqlControlDriverInstance, type SqlModelFieldStorage, type SqlModelStorage, type SqlNamespaceTablesInput, SqlNode, type SqlQueryOperationTypes, SqlStorage, type SqlStorageInput, type SqlStorageTypeEntry, SqlUnboundNamespace, StorageColumn, type StorageColumnInput, StorageTable, type StorageTableInput, type StorageTypeInstance, type StorageTypeInstanceInput, StorageValueSet, type StorageValueSetInput, type TypeMaps, type TypeMapsPhantomKey, UniqueConstraint, type UniqueConstraintInput, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isPostgresEnumStorageEntry, isStorageTypeInstance, storageTableAt, toStorageTypeInstance };

package/dist/types.mjs

@@ -1,2 +1,2 @@
-import { _ as ForeignKey, a as CODEC_INSTANCE_KIND, b as SqlUnboundNamespace, c as POSTGRES_ENUM_KIND, d as buildSqlNamespaceMap, f as StorageTable, g as PrimaryKey, h as Index, i as SqlStorage, l as isPostgresEnumStorageEntry, m as StorageColumn, n as DEFAULT_FK_INDEX, o as isStorageTypeInstance, p as UniqueConstraint, r as applyFkDefaults, s as toStorageTypeInstance, t as DEFAULT_FK_CONSTRAINT, u as buildSqlNamespace, v as ForeignKeyReference, y as SqlNode } from "./types-YQrDHy-b.mjs";
-export { CODEC_INSTANCE_KIND, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, ForeignKey, ForeignKeyReference, Index, POSTGRES_ENUM_KIND, PrimaryKey, SqlNode, SqlStorage, SqlUnboundNamespace, StorageColumn, StorageTable, UniqueConstraint, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance };
+import { S as SqlUnboundNamespace, _ as Index, a as storageTableAt, b as ForeignKeyReference, c as toStorageTypeInstance, d as buildSqlNamespace, f as buildSqlNamespaceMap, g as StorageColumn, h as UniqueConstraint, i as SqlStorage, l as POSTGRES_ENUM_KIND, m as StorageTable, n as DEFAULT_FK_INDEX, o as CODEC_INSTANCE_KIND, p as StorageValueSet, r as applyFkDefaults, s as isStorageTypeInstance, t as DEFAULT_FK_CONSTRAINT, u as isPostgresEnumStorageEntry, v as PrimaryKey, x as SqlNode, y as ForeignKey } from "./types-a657xjzo.mjs";
+export { CODEC_INSTANCE_KIND, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, ForeignKey, ForeignKeyReference, Index, POSTGRES_ENUM_KIND, PrimaryKey, SqlNode, SqlStorage, SqlUnboundNamespace, StorageColumn, StorageTable, StorageValueSet, UniqueConstraint, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isPostgresEnumStorageEntry, isStorageTypeInstance, storageTableAt, toStorageTypeInstance };