@prisma-next/sql-contract 0.14.0-dev.4 → 0.14.0-dev.40

package/src/validators.ts

@@ -10,13 +10,11 @@ import {
   type AnyEntityKindDescriptor,
   isPlainRecord,
   type Namespace,
-  UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { type Type, type } from 'arktype';
 import { composeSqlEntityKinds } from './entity-kinds';
-import { buildSqlNamespaceMap } from './ir/build-sql-namespace';
 
 export {
   CheckConstraintSchema,
@@ -32,13 +30,12 @@ export {
   StorageValueSetSchema,
 } from './ir/storage-entry-schemas';
 
-import { SqlUnboundNamespace } from './ir/sql-unbound-namespace';
-import {
-  type SqlModelStorage,
+import type {
+  SqlModelStorage,
   SqlStorage,
-  type SqlStorageInput,
-  type StorageTable,
-  type StorageTypeInstanceInput,
+  StorageColumn,
+  StorageTable,
+  StorageTypeInstanceInput,
 } from './types';
 
 const generatorKindSchema = type("'generator'");
@@ -192,9 +189,8 @@ export function createSqlStorageSchema(
     'types?': type({ '[string]': DocumentScopedStorageTypeSchema }),
     // `__unbound__` is NOT required here: cross-namespace contracts can
     // declare only named namespaces (see cross-namespace FK fixtures). The
-    // `__unbound__` brand on `SqlStorageInput['namespaces']` is kept sound at
-    // construction time by injecting the unbound singleton when absent
-    // (see `validateStorage` / `hydrateSqlStorage`), not by structural require.
+    // unbound slot is injected when absent by `ensureUnboundNamespaceSlot`
+    // in `build-contract.ts`, not enforced here structurally.
     'namespaces?': type({ '[string]': namespaceEntry }),
   }) as Type<unknown>;
 }
@@ -368,45 +364,21 @@ export function createSqlContractSchema(
 
 const SqlContractSchema = createSqlContractSchema(DEFAULT_SQL_KINDS);
 
-// NOTE: StorageColumnSchema, StorageTableSchema, and StorageSchema use bare type()
-// instead of type.declare<T>().type() because the ColumnDefault union's value field
-// includes bigint | Date (runtime-only types after decoding) which cannot be expressed
-// in Arktype's JSON validation DSL. The `as SqlStorage` cast in validateStorage() bridges
-// the gap between the JSON-safe Arktype output and the runtime TypeScript type.
-
 /**
- * Validates the structural shape of SqlStorage using Arktype.
+ * Validates the structural shape of SqlStorage using Arktype. Pure
+ * structural check: namespace IR is never materialized here (that needs
+ * a target concretion via the serializer hydration path), so this throws
+ * on invalid input and constructs nothing.
  *
  * @param value - The storage value to validate
- * @returns The validated storage if structure is valid
  * @throws Error if the storage structure is invalid
  */
-export function validateStorage(value: unknown): SqlStorage {
+export function validateStorage(value: unknown): void {
   const result = StorageSchema(value);
   if (result instanceof type.errors) {
     const messages = result.map((p: { message: string }) => p.message).join('; ');
     throw new Error(`Storage validation failed: ${messages}`);
   }
-  // Arktype validates the JSON-safe envelope, but the `ColumnDefault`
-  // union carries runtime-only `bigint | Date` that the validation DSL
-  // can't express (see NOTE above), so bridge the validated shape to the
-  // input type. Construction below re-materialises nested IR fields.
-  const validated = blindCast<
-    SqlStorageInput & { readonly namespaces?: SqlStorageInput['namespaces'] },
-    'arktype validated the JSON envelope but its output type is unknown (ColumnDefault carries runtime-only bigint|Date); bridge to the input shape'
-  >(result);
-  const namespaces = buildSqlNamespaceMap(validated.namespaces ?? {});
-  // Compatibility shim: inject the empty unbound singleton when absent so that
-  // production code paths which address __unbound__ for table metadata have a
-  // slot to read or write into. The `SqlStorageInput['namespaces']` type no
-  // longer requires __unbound__, so this is a runtime convenience, not a type
-  // invariant.
-  const unbound = namespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance;
-  return new SqlStorage({
-    storageHash: validated.storageHash,
-    ...ifDefined('types', validated.types),
-    namespaces: { ...namespaces, [UNBOUND_NAMESPACE_ID]: unbound },
-  });
 }
 
 export function validateModel(value: unknown): unknown {
@@ -846,5 +818,208 @@ export function validateSqlContractFully<T extends Contract<SqlStorage>>(
     );
   }
   validateModelStorageReferences(validated);
+  validateRelationThroughConsistency(validated);
   return validated;
 }
+
+/** Storage column lookup for through-consistency validation. */
+function lookupStorageColumn(
+  contract: Contract<SqlStorage>,
+  namespaceId: string,
+  tableName: string,
+  columnName: string,
+): StorageColumn | undefined {
+  const rawTable = contract.storage.namespaces[namespaceId]?.entries.table?.[tableName];
+  if (rawTable === undefined) {
+    return undefined;
+  }
+  const table = blindCast<StorageTable, 'structurally validated storage table'>(rawTable);
+  return table.columns[columnName];
+}
+
+/**
+ * Two storage columns share a type when their `nativeType` and `typeParams`
+ * match. The contract is canonicalized, so `typeParams` key order is stable and
+ * a JSON comparison is exact. `codecId` and `nullable` are intentionally not
+ * compared: they do not change the database-level type that governs a join.
+ */
+function sameStorageType(a: StorageColumn, b: StorageColumn): boolean {
+  return (
+    a.nativeType === b.nativeType &&
+    JSON.stringify(a.typeParams ?? null) === JSON.stringify(b.typeParams ?? null)
+  );
+}
+
+function describeColumnType(column: StorageColumn): string {
+  return column.typeParams === undefined
+    ? column.nativeType
+    : `${column.nativeType} ${JSON.stringify(column.typeParams)}`;
+}
+
+/**
+ * Validates one side of an N:M join: the junction columns and the model
+ * columns they pair against positionally must be equal in number, exist in
+ * their tables, and share the same storage type (`nativeType` + `typeParams`).
+ * The junction's storage foreign keys already guarantee this for user-declared
+ * FK constraints, but `through` is a logical descriptor never tied to them by
+ * the rest of validation — and the TS builder accepts explicit join columns
+ * without requiring a junction FK at all — so this checks the columns directly
+ * against storage, one path regardless of how the junction was authored.
+ *
+ * Joined columns must be the *same* storage type, not merely compatible:
+ * relying on implicit conversion (e.g. `text`↔`character`) is unsafe on writes
+ * — `character(n)` space-padding makes such coercions non-associative — and no
+ * ADR sanctions heterogeneous junction columns. Equality is the conservative
+ * default; it can be relaxed deliberately if a real use case ever appears.
+ */
+function validateThroughJoinSide(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly qualifiedName: string;
+  readonly modelColumns: readonly string[];
+  readonly modelColumnsLabel: string;
+  /**
+   * The model side of the join, when resolvable. Absent for a cross-space
+   * target whose storage lives in another contract: the length and
+   * junction-column-existence checks still run, but the target-column
+   * existence and type checks are skipped because the target table is not
+   * available here. `fieldToColumn` is present when `modelColumns` are domain
+   * field names (the `on.*Fields` arrays), absent when they are already storage
+   * column names (the `through.*Columns` arrays).
+   */
+  readonly model?: {
+    readonly namespaceId: string;
+    readonly table: string;
+    readonly fieldToColumn?: Readonly<Record<string, { readonly column: string }>>;
+  };
+  readonly junctionColumns: readonly string[];
+  readonly junctionColumnsLabel: string;
+  readonly junctionNamespaceId: string;
+  readonly junctionTable: string;
+}): void {
+  const fail = (detail: string): ContractValidationError =>
+    new ContractValidationError(
+      `Many-to-many relation "${input.qualifiedName}" ${detail}`,
+      'storage',
+    );
+  if (input.junctionColumns.length !== input.modelColumns.length) {
+    throw fail(
+      `pairs ${input.junctionColumnsLabel} (${input.junctionColumns.length}) with ${input.modelColumnsLabel} (${input.modelColumns.length}) of differing length; they join positionally and must match.`,
+    );
+  }
+  for (const [index, junctionColumnName] of input.junctionColumns.entries()) {
+    const modelColumnRef = input.modelColumns[index];
+    if (modelColumnRef === undefined) {
+      continue;
+    }
+    const junctionColumn = lookupStorageColumn(
+      input.contract,
+      input.junctionNamespaceId,
+      input.junctionTable,
+      junctionColumnName,
+    );
+    if (junctionColumn === undefined) {
+      throw fail(
+        `${input.junctionColumnsLabel} references column "${junctionColumnName}" absent from junction table "${input.junctionNamespaceId}.${input.junctionTable}".`,
+      );
+    }
+    // Cross-space target: its storage lives in another contract, so the target
+    // column's existence and type cannot be checked here. Length and
+    // junction-column existence have already been validated above.
+    const model = input.model;
+    if (model === undefined) {
+      continue;
+    }
+    let modelColumnName = modelColumnRef;
+    if (model.fieldToColumn !== undefined) {
+      const mapped = model.fieldToColumn[modelColumnRef];
+      if (mapped === undefined) {
+        throw fail(
+          `${input.modelColumnsLabel} references field "${modelColumnRef}" absent from model on table "${model.namespaceId}.${model.table}".`,
+        );
+      }
+      modelColumnName = mapped.column;
+    }
+    const modelColumn = lookupStorageColumn(
+      input.contract,
+      model.namespaceId,
+      model.table,
+      modelColumnName,
+    );
+    if (modelColumn === undefined) {
+      throw fail(
+        `${input.modelColumnsLabel} references column "${modelColumnName}" absent from table "${model.namespaceId}.${model.table}".`,
+      );
+    }
+    if (!sameStorageType(junctionColumn, modelColumn)) {
+      throw fail(
+        `joins "${input.junctionTable}.${junctionColumnName}" (${describeColumnType(junctionColumn)}) with "${model.table}.${modelColumnName}" (${describeColumnType(modelColumn)}) of differing storage type; junction columns must match the type of the column they reference.`,
+      );
+    }
+  }
+}
+
+/**
+ * Validates that every N:M relation's `through` descriptor is consistent with
+ * the storage columns it joins: both join sides match in column count,
+ * reference columns that exist in their tables, and pair columns of the same
+ * storage type. Without this, a `through` that disagrees with storage surfaces
+ * as a silently wrong JOIN at query time rather than a validation error here.
+ */
+function validateRelationThroughConsistency(contract: Contract<SqlStorage>): void {
+  for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) {
+    for (const [modelName, model] of Object.entries(namespace.models)) {
+      for (const [relationName, relation] of Object.entries(model.relations)) {
+        if (relation.cardinality !== 'N:M') continue;
+        const qualifiedName = `${namespaceId}.${modelName}.${relationName}`;
+        const { on, through } = relation;
+        const modelStorage = blindCast<SqlModelStorage, 'SQL contract model storage'>(
+          model.storage,
+        );
+        // Parent side: the owning model's localFields (domain field names) join
+        // the junction's parentColumns (storage columns).
+        validateThroughJoinSide({
+          contract,
+          qualifiedName,
+          modelColumns: on.localFields,
+          modelColumnsLabel: 'on.localFields',
+          model: {
+            namespaceId,
+            table: modelStorage.table,
+            fieldToColumn: modelStorage.fields,
+          },
+          junctionColumns: through.parentColumns,
+          junctionColumnsLabel: 'through.parentColumns',
+          junctionNamespaceId: through.namespaceId,
+          junctionTable: through.table,
+        });
+        // Child side: the junction's childColumns join the target model's
+        // targetColumns. Length and junction-column existence are checked
+        // regardless; a cross-space target lives in another contract, so its
+        // column existence and type are checked only when it is resolvable here.
+        const targetModel =
+          relation.to.space === undefined
+            ? contract.domain.namespaces[relation.to.namespace]?.models[relation.to.model]
+            : undefined;
+        const targetModelSide =
+          targetModel === undefined
+            ? undefined
+            : {
+                namespaceId: relation.to.namespace,
+                table: blindCast<SqlModelStorage, 'SQL contract model storage'>(targetModel.storage)
+                  .table,
+              };
+        validateThroughJoinSide({
+          contract,
+          qualifiedName,
+          modelColumns: through.targetColumns,
+          modelColumnsLabel: 'through.targetColumns',
+          ...ifDefined('model', targetModelSide),
+          junctionColumns: through.childColumns,
+          junctionColumnsLabel: 'through.childColumns',
+          junctionNamespaceId: through.namespaceId,
+          junctionTable: through.table,
+        });
+      }
+    }
+  }
+}

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

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

package/dist/sql-storage-Dga0jwP2.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql-storage-Dga0jwP2.d.mts","names":[],"sources":["../src/ir/storage-type-instance.ts","../src/ir/sql-storage.ts"],"mappings":";;;;;;;;;;;AASA;;cAAa,mBAAA;;AAA+C;AAU5D;;;;;;UAAiB,mBAAA,SAA4B,WAAA;EAAA,SAClC,IAAA,SAAa,mBAAA;EAAA,SACb,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,EAAY,MAAA;AAAA;;;;;AAAM;AAU7B;;UAAiB,wBAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;AAAA;AAQ9B;;iBAAgB,qBAAA,CAAsB,KAAA,EAAO,wBAAA,GAA2B,mBAAmB;;;;;;iBAc3E,qBAAA,CAAsB,KAAA,YAAiB,KAAA,IAAS,mBAAmB;;;AAjDnF;;;;AAA4D;AAU5D;;AAVA,KCUY,mBAAA,GAAsB,mBAAA,GAAsB,wBAAwB;AAAA,UAE/D,uBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;AAAA,UAGpC,eAAA;EAAA,SACN,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,KAAA,GAAQ,MAAA,SAAe,mBAAA;EAAA,SACvB,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,YAAA;AAAA;;;;;ADNlB;AAU7B;;;;;;;;;AAG8B;AAQ9B;;;;;;;;AAA2F;AAc3F;;;KCCY,mBAAA,GAAsB,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;EAAA,SACxD,KAAA,GAAQ,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAChC,QAAA,GAAW,QAAA,CAAS,MAAA,SAAe,eAAA;AAAA;;ADHqC;;;;ACvCnF;;KAoDY,YAAA,GAAe,SAAA;EAAA,SAChB,OAAA,EAAS,mBAAmB;EArDyC;AAEhF;;;;;EA0DE,YAAA,EAAc,SAAA;AAAA;AAAA,cAGH,UAAA,wCAAkD,OAAA,YAAmB,OAAA;EAAA,SACvE,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAC5B,KAAA,GAAQ,QAAA,CAAS,MAAA,SAAe,mBAAA;cAErC,KAAA,EAAO,eAAA,CAAgB,KAAA;AAAA"}

package/dist/storage-value-set-WnYsIFM8.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage-value-set-WnYsIFM8.d.mts","names":[],"sources":["../src/ir/check-constraint.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"],"mappings":";;;;;;AASA;;;UAAiB,oBAAA;EAAA,SACN,IAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,EAAU,WAAW;AAAA;;AAAA;AAiBhC;;;;;;;;;;;;cAAa,eAAA,SAAwB,OAAA;EAAA,SAC1B,IAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,EAAU,WAAA;cAEP,KAAA,EAAO,oBAAA;AAAA;;;UC/BJ,eAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAI;AAAA;;;;cAMF,UAAA,SAAmB,OAAO;EAAA,SAC5B,OAAA;EAAA,SACQ,IAAA;cAEL,KAAA,EAAO,eAAA;AAAA;;;UCZJ,UAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,GAAU,MAAM;AAAA;;;;;;;AFKK;AAiBhC;cEXa,KAAA,SAAc,OAAA;EAAA,SAChB,OAAA;EAAA,SACQ,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,GAAU,MAAA;cAEf,KAAA,EAAO,UAAA;AAAA;;;;;AFfrB;;;;;;;;UGKiB,kBAAA;EAAA,SACN,UAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,SACA,UAAA,GAAa,MAAA;EAAA,SACb,OAAA;EAAA,SACA,OAAA,GAAU,aAAA;EAAA,SACV,OAAA,GAAU,aAAA;EAAA,SACV,QAAA,GAAW,WAAA;AAAA;;;;;;;;;;AHYmB;;;;cGI5B,aAAA,SAAsB,OAAA;EAAA,SACxB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,SACQ,UAAA,GAAa,MAAA;EAAA,SACb,OAAA;EAAA,SACA,OAAA,GAAU,aAAA;EAAA,SACV,OAAA,GAAU,aAAA;EAAA,SACV,QAAA,GAAW,WAAA;cAEhB,KAAA,EAAO,kBAAA;AAAA;;;UC7CJ,qBAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAI;AAAA;;;;cAMF,gBAAA,SAAyB,OAAO;EAAA,SAClC,OAAA;EAAA,SACQ,IAAA;cAEL,KAAA,EAAO,qBAAA;AAAA;;;UCLJ,iBAAA;EAAA,SACN,OAAA,EAAS,MAAA,SAAe,aAAA,GAAgB,kBAAA;EAAA,SACxC,UAAA,GAAa,UAAA,GAAa,eAAA;EAAA,SAC1B,OAAA,EAAS,aAAA,CAAc,gBAAA,GAAmB,qBAAA;EAAA,SAC1C,OAAA,EAAS,aAAA,CAAc,KAAA,GAAQ,UAAA;EAAA,SAC/B,WAAA,EAAa,aAAA,CAAc,UAAA,GAAa,eAAA;EAAA,SACxC,OAAA,GAAU,aAAA;EAAA,SACV,MAAA,GAAS,aAAA,CAAc,eAAA,GAAkB,oBAAA;AAAA;;;;;;;;;;;;;cAevC,YAAA,SAAqB,OAAA;EAAA,SACvB,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,aAAA;EAAA,SACjC,OAAA,EAAS,aAAA,CAAc,gBAAA;EAAA,SACvB,OAAA,EAAS,aAAA,CAAc,KAAA;EAAA,SACvB,WAAA,EAAa,aAAA,CAAc,UAAA;EAAA,SACnB,UAAA,GAAa,UAAA;EAAA,SACb,OAAA,GAAU,aAAA;EAAA,SACV,MAAA,GAAS,aAAA,CAAc,eAAA;cAE5B,KAAA,EAAO,iBAAA;AAAA;;;;;ALhCrB;;;UMAiB,oBAAA;EAAA,SACN,IAAA;ENCA;EAAA,SMCA,MAAA,WAAiB,SAAS;AAAA;;ANAL;AAiBhC;;;;;;;;;;;;;;;;cMIa,eAAA,SAAwB,OAAA;EAAA,SACjB,IAAA;EAAA,SACT,MAAA,WAAiB,SAAA;cAEd,KAAA,EAAO,oBAAA;AAAA"}

package/dist/types-B-eiQXff.mjs

@@ -1,191 +0,0 @@
-import { p as SqlNode, t as composeSqlEntityKinds } from "./entity-kinds-Cl36zL5j.mjs";
-import { NamespaceBase, UNBOUND_NAMESPACE_ID, freezeNode, hydrateNamespaceEntities } from "@prisma-next/framework-components/ir";
-import { blindCast } from "@prisma-next/utils/casts";
-//#region src/ir/sql-unbound-namespace.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.
-*/
-var SqlUnboundNamespace = class SqlUnboundNamespace extends NamespaceBase {
-	static instance = new SqlUnboundNamespace();
-	id = UNBOUND_NAMESPACE_ID;
-	entries = Object.freeze({ table: blindCast(Object.freeze({})) });
-	constructor() {
-		super();
-		Object.defineProperty(this, "kind", {
-			value: "sql-namespace",
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		freezeNode(this);
-	}
-	get table() {
-		return blindCast(this.entries["table"]);
-	}
-	qualifyTable(tableName) {
-		return `"${tableName}"`;
-	}
-};
-//#endregion
-//#region src/ir/build-sql-namespace.ts
-const SQL_NAMESPACE_KIND = "sql-namespace";
-function isMaterializedSqlNamespace(ns) {
-	if (typeof ns !== "object" || ns === null) return false;
-	const proto = Object.getPrototypeOf(ns);
-	if (proto === Object.prototype || proto === null) return false;
-	return ns.kind === SQL_NAMESPACE_KIND;
-}
-var SqlBoundNamespace = class SqlBoundNamespace extends NamespaceBase {
-	id;
-	entries;
-	static fromTablesInput(input) {
-		const tableKind = input.entries["table"];
-		const tableCount = tableKind !== void 0 ? Object.keys(tableKind).length : 0;
-		const valueSetKind = input.entries["valueSet"];
-		const hasValueSets = valueSetKind !== void 0 && Object.keys(valueSetKind).length > 0;
-		const hasUnknownKinds = Object.keys(input.entries).some((kind) => kind !== "table" && kind !== "valueSet");
-		if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && !hasValueSets && !hasUnknownKinds) return SqlUnboundNamespace.instance;
-		return new SqlBoundNamespace(input);
-	}
-	constructor(input) {
-		super();
-		this.id = input.id;
-		const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), "carry");
-		this.entries = Object.freeze(blindCast(dispatched));
-		Object.defineProperty(this, "kind", {
-			value: SQL_NAMESPACE_KIND,
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		freezeNode(this);
-	}
-	get table() {
-		return this.entries.table ?? Object.freeze({});
-	}
-	get valueSet() {
-		return this.entries.valueSet;
-	}
-	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) ? ns : SqlBoundNamespace.fromTablesInput(blindCast(ns))]));
-}
-//#endregion
-//#region src/ir/storage-type-instance.ts
-/**
-* Sentinel kind for the legacy codec-triple shape persisted under
-* `SqlStorage.types`. Plain JSON-clean object literals carry this
-* discriminator so the polymorphic slot dispatch can route them down
-* the codec path while target-specific IR class instances (e.g. the
-* Postgres enum class) keep their own narrower `kind` literal.
-*/
-const CODEC_INSTANCE_KIND = "codec-instance";
-/**
-* Stamp the codec-instance `kind` discriminator on a caller-supplied
-* codec triple. Idempotent: input that already carries the discriminator
-* passes through unchanged. Missing `typeParams` is normalised to `{}`.
-*/
-function toStorageTypeInstance(input) {
-	return {
-		kind: CODEC_INSTANCE_KIND,
-		codecId: input.codecId,
-		nativeType: input.nativeType,
-		typeParams: input.typeParams ?? {}
-	};
-}
-/**
-* Type-guard for codec-typed entries on the polymorphic
-* `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
-* any class-instance kinds a target pack contributes.
-*/
-function isStorageTypeInstance(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return value.kind === CODEC_INSTANCE_KIND;
-}
-//#endregion
-//#region src/ir/sql-storage.ts
-var SqlStorage = class extends SqlNode {
-	storageHash;
-	namespaces;
-	constructor(input) {
-		super();
-		this.storageHash = input.storageHash;
-		this.namespaces = Object.freeze(input.namespaces);
-		if (input.types !== void 0) this.types = Object.freeze(Object.fromEntries(Object.entries(input.types).map(([name, ti]) => [name, normaliseTypeEntry(name, ti)])));
-		freezeNode(this);
-	}
-};
-/**
-* Strict polymorphic-slot dispatch for `SqlStorage.types` entries.
-* Every entry must carry a `kind: 'codec-instance'` discriminator or
-* be an already-constructed `StorageTypeInstance`. Untagged or
-* unrecognised inputs throw a diagnostic naming the entry and its
-* `kind`, so format drift surfaces loudly at the deserializer
-* boundary instead of slipping past the seam and corrupting
-* downstream IR walks.
-*
-* Codec-triple authors that have an untagged shape on hand can call
-* `toStorageTypeInstance(...)` (which stamps the `'codec-instance'`
-* discriminator) before constructing `SqlStorage`. On-disk reads
-* cross `familyInstance.deserializeContract` first; the structural
-* arktype schema rejects untagged entries earlier, so this throw
-* only fires for in-memory authoring bugs.
-*/
-function normaliseTypeEntry(name, entry) {
-	if (isStorageTypeInstance(entry)) {
-		if ("typeParams" in entry) return entry;
-		return toStorageTypeInstance(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")}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`);
-}
-//#endregion
-//#region src/types.ts
-const DEFAULT_FK_CONSTRAINT = true;
-const DEFAULT_FK_INDEX = true;
-function applyFkDefaults(fk, overrideDefaults) {
-	return {
-		constraint: fk.constraint ?? overrideDefaults?.constraint ?? true,
-		index: fk.index ?? overrideDefaults?.index ?? true
-	};
-}
-//#endregion
-export { CODEC_INSTANCE_KIND as a, buildSqlNamespace as c, SqlStorage as i, buildSqlNamespaceMap as l, DEFAULT_FK_INDEX as n, isStorageTypeInstance as o, applyFkDefaults as r, toStorageTypeInstance as s, DEFAULT_FK_CONSTRAINT as t, SqlUnboundNamespace as u };
-
-//# sourceMappingURL=types-B-eiQXff.mjs.map

package/dist/types-B-eiQXff.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-B-eiQXff.mjs","names":[],"sources":["../src/ir/sql-unbound-namespace.ts","../src/ir/build-sql-namespace.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 { blindCast } from '@prisma-next/utils/casts';\nimport type { SqlNamespaceEntries } from './sql-storage';\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: SqlNamespaceEntries = Object.freeze({\n    table: blindCast<\n      Readonly<Record<string, StorageTable>>,\n      'empty frozen map is a valid Readonly<Record<string, StorageTable>>'\n    >(Object.freeze({})),\n  });\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  get table(): Readonly<Record<string, StorageTable>> {\n    return blindCast<\n      Readonly<Record<string, StorageTable>>,\n      'entries[table] holds only StorageTable by construction'\n    >(this.entries['table']);\n  }\n\n  qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n}\n","import {\n  freezeNode,\n  hydrateNamespaceEntities,\n  type Namespace,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { composeSqlEntityKinds } from '../entity-kinds';\nimport type { SqlNamespace, SqlNamespaceEntries, SqlNamespaceTablesInput } from './sql-storage';\nimport { SqlUnboundNamespace } from './sql-unbound-namespace';\nimport type { StorageTable } from './storage-table';\nimport type { 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: SqlNamespaceEntries;\n\n  static fromTablesInput(input: SqlNamespaceTablesInput): SqlNamespace {\n    const tableKind = input.entries['table'];\n    const tableCount = tableKind !== undefined ? Object.keys(tableKind).length : 0;\n    const valueSetKind = input.entries['valueSet'];\n    const hasValueSets = valueSetKind !== undefined && Object.keys(valueSetKind).length > 0;\n    const hasUnknownKinds = Object.keys(input.entries).some(\n      (kind) => kind !== 'table' && kind !== 'valueSet',\n    );\n    if (\n      input.id === UNBOUND_NAMESPACE_ID &&\n      tableCount === 0 &&\n      !hasValueSets &&\n      !hasUnknownKinds\n    ) {\n      return SqlUnboundNamespace.instance;\n    }\n    return new SqlBoundNamespace(input);\n  }\n\n  private constructor(input: SqlNamespaceTablesInput) {\n    super();\n    this.id = input.id;\n\n    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');\n\n    this.entries = Object.freeze(\n      blindCast<\n        SqlNamespaceEntries,\n        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'\n      >(dispatched),\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  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\n  }\n\n  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {\n    return this.entries.valueSet;\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        ? 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 { 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 any class-instance\n * kinds a target pack contributes to 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 * `typeParams` may be omitted on input; the constructor normalises a\n * missing value to `{}` so the in-memory shape is always present.\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. Missing `typeParams` is normalised to `{}`.\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 * any class-instance kinds a target pack contributes.\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 } from './storage-table';\nimport {\n  isStorageTypeInstance,\n  type StorageTypeInstance,\n  type StorageTypeInstanceInput,\n  toStorageTypeInstance,\n} from './storage-type-instance';\nimport type { StorageValueSet } 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: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\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/**\n * The typed `entries` shape for SQL family namespaces. The open dictionary\n * is intersected with optional known-kind maps so that `ns.entries.table`\n * and `ns.entries.valueSet` resolve without a cast, while unknown pack-\n * contributed kinds remain valid (the `Record` part allows any string key).\n */\nexport type SqlNamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>> & {\n  readonly table?: Readonly<Record<string, StorageTable>>;\n  readonly valueSet?: Readonly<Record<string, StorageValueSet>>;\n};\n\n/**\n * SQL family namespace. `entries` is the open ADR 224 dictionary —\n * `entries[entityKind][entityName]` addresses any entity. Emitted\n * contract literals satisfy this structurally (no prototype getters\n * needed). For typed access to specific kinds, use the class getters\n * on the concretion or `ns.entries.table` / `ns.entries.valueSet` directly.\n */\nexport type SqlNamespace = Namespace & {\n  readonly entries: SqlNamespaceEntries;\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\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    // Normalise on-disk objects that omit `typeParams` (the canonical on-disk\n    // form strips empty typeParams to keep JSON compact). The in-memory invariant\n    // is always `typeParams: {}` when empty — never `undefined`. Only create a\n    // new object when necessary to preserve identity-equality for callers that\n    // hold a reference to an already-correct in-memory entry.\n    if ('typeParams' in entry) {\n      return entry;\n    }\n    return toStorageTypeInstance(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 { CheckConstraint, type CheckConstraintInput } from './ir/check-constraint';\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 { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';\nexport { Index, type IndexInput } from './ir/sql-index';\nexport { SqlNode } from './ir/sql-node';\nexport {\n  type SqlNamespace,\n  type SqlNamespaceEntries,\n  type SqlNamespaceTablesInput,\n  SqlStorage,\n  type SqlStorageInput,\n  type SqlStorageTypeEntry,\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\n// Field-type maps nested by namespace coordinate: `[namespaceId][model][field]`.\n// Shared by the output and input field-type maps and their extractors.\nexport type NamespacedFieldTypeMap = Record<string, Record<string, Record<string, unknown>>>;\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 NamespacedFieldTypeMap = Record<string, never>,\n  TFieldInputTypes extends NamespacedFieldTypeMap = 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 NamespacedFieldTypeMap\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 NamespacedFieldTypeMap\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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"}