@prisma-next/sql-contract 0.16.0-dev.3 → 0.16.0-dev.30

package/src/index-types.ts

@@ -1,4 +1,5 @@
 import type { Type } from 'arktype';
+import { contractError } from './contract-errors';
 
 export interface IndexTypeEntry<TOptions = unknown> {
   readonly type: string;
@@ -34,7 +35,11 @@ class IndexTypeBuilderImpl<TMap extends IndexTypeMap> implements IndexTypeBuilde
     entry: { readonly options: Type<TOpts> },
   ): IndexTypeBuilder<TMap & Record<TLit, { readonly options: TOpts }>> {
     if (this.entries.some((e) => e.type === typeLiteral)) {
-      throw new Error(`Index type "${typeLiteral}" is already declared in this builder`);
+      throw contractError(
+        'CONTRACT.PACK_CONTRIBUTION_INVALID',
+        `Index type "${typeLiteral}" is already declared in this builder`,
+        { meta: { indexType: typeLiteral } },
+      );
     }
     return new IndexTypeBuilderImpl<TMap & Record<TLit, { readonly options: TOpts }>>([
       ...this.entries,
@@ -58,7 +63,11 @@ class IndexTypeRegistryImpl implements IndexTypeRegistry {
 
   register(entry: IndexTypeEntry): void {
     if (this.entries.has(entry.type)) {
-      throw new Error(`Index type "${entry.type}" is already registered`);
+      throw contractError(
+        'CONTRACT.PACK_CONTRIBUTION_INVALID',
+        `Index type "${entry.type}" is already registered`,
+        { meta: { indexType: entry.type } },
+      );
     }
     this.entries.set(entry.type, entry);
   }

package/src/ir/sql-index.ts

@@ -1,15 +1,68 @@
+import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';
 import { freezeNode } from '@prisma-next/framework-components/ir';
+import { formatWireName, parseWireName } from '@prisma-next/sql-schema-ir/naming';
 import { SqlNode } from './sql-node';
 
-export interface IndexInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-}
+/**
+ * An index's element structure — exactly one of a column tuple or an opaque
+ * expression, made unrepresentable-otherwise at the type level. No
+ * discriminant is stored: the JSON shape stays flat (`columns` or
+ * `expression`, never both), and the runtime xor guard in the constructor
+ * remains as the backstop for JSON loads that bypass this input type.
+ */
+export type IndexElements =
+  | {
+      /** Column-tuple elements. */
+      readonly columns: readonly string[];
+      readonly expression?: never;
+    }
+  | {
+      readonly columns?: never;
+      /**
+       * Opaque SQL: the entire element list between the parens of CREATE
+       * INDEX — one string, never parsed.
+       */
+      readonly expression: string;
+    };
 
 /**
- * SQL Contract IR node for a table-level secondary index.
+ * Construction input for {@link Index}. Internal seam (built by lowering and
+ * FK materialization, not by end users), so every non-element key is
+ * required and absence is stated explicitly as `undefined` — matching the
+ * `SqlIndexIRInput` convention.
+ */
+export type IndexInput = IndexElements & {
+  /** Full wire name (managed) or verbatim physical name (exact). Always present. */
+  readonly name: string;
+  /**
+   * The managed-mode name prefix — its PRESENCE is the naming-mode
+   * discriminator (there is no stored enum). Present ⇔ managed: the
+   * toolchain owns the physical name and `name === formatWireName(prefix,
+   * <8hex content hash>)`, so the author chooses the prefix but never the
+   * whole name. Absent ⇔ exact: `name` is an adopted verbatim physical name
+   * (PSL `map:`) whose identity the author owns entirely.
+   */
+  readonly prefix: string | undefined;
+  /** Opaque SQL: partial-index predicate (WHERE body, without the keyword). */
+  readonly where: string | undefined;
+  /** Rendered as CREATE UNIQUE INDEX. */
+  readonly unique: boolean;
+  readonly type: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
+};
+
+/**
+ * SQL Contract IR node for a table-level secondary index, name-identified:
+ * `name` is the full physical name; a present `prefix` marks the index as
+ * managed (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`
+ * marks it exact (the name is adopted verbatim).
+ *
+ * `expression`, `where`, and `unique` are genuine SQL-family attributes —
+ * functional and partial indexes are standard SQL supported natively by
+ * Postgres and SQLite alike, and the family IR must be able to represent
+ * anything any SQL target can introspect. A target declining to AUTHOR them
+ * (SQLite's rejection at namespace construction) is a capability decision,
+ * not evidence of target-specificity.
  *
  * Note that this class shadows the global TypeScript `Index` lib type
  * at the family-shared name; consumer files that need both should
@@ -17,15 +70,45 @@ export interface IndexInput {
  * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
  */
 export class Index extends SqlNode {
-  readonly columns: readonly string[];
-  declare readonly name?: string;
+  readonly name: string;
+  readonly unique: boolean;
+  /** See {@link IndexInput.prefix} — presence is the naming-mode discriminator. */
+  declare readonly prefix?: string;
+  declare readonly columns?: readonly string[];
+  declare readonly expression?: string;
+  declare readonly where?: string;
   declare readonly type?: string;
   declare readonly options?: Record<string, unknown>;
 
   constructor(input: IndexInput) {
     super();
-    this.columns = input.columns;
-    if (input.name !== undefined) this.name = input.name;
+    if (input.name === undefined || input.name.length === 0) {
+      throw new ContractValidationError(
+        'Index: every index carries a full physical name; an expression index must be explicitly named (a default name cannot be derived from an expression).',
+        'storage',
+      );
+    }
+    if ((input.columns === undefined) === (input.expression === undefined)) {
+      throw new ContractValidationError(
+        `Index "${input.name}": exactly one of columns or expression must be set.`,
+        'storage',
+      );
+    }
+    if (input.prefix !== undefined) {
+      const parsed = parseWireName(input.name);
+      if (parsed === undefined || parsed.prefix !== input.prefix) {
+        throw new ContractValidationError(
+          `Index "${input.name}": prefix "${input.prefix}" does not match the wire name (expected "${formatWireName(input.prefix, '<8hex>')}").`,
+          'storage',
+        );
+      }
+    }
+    this.name = input.name;
+    this.unique = input.unique;
+    if (input.prefix !== undefined) this.prefix = input.prefix;
+    if (input.columns !== undefined) this.columns = input.columns;
+    if (input.expression !== undefined) this.expression = input.expression;
+    if (input.where !== undefined) this.where = input.where;
     if (input.type !== undefined) this.type = input.type;
     if (input.options !== undefined) this.options = input.options;
     freezeNode(this);

package/src/ir/sql-storage.ts

@@ -7,6 +7,7 @@ import {
   NamespaceBase,
   type Storage,
 } from '@prisma-next/framework-components/ir';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import { SqlNode } from './sql-node';
 import type { StorageTable } from './storage-table';
 import {
@@ -197,7 +198,7 @@ function normaliseTypeEntry(name: string, entry: SqlStorageTypeEntry): StorageTy
     rawKind === undefined
       ? 'missing `kind` discriminator'
       : `unrecognised \`kind\` discriminator ${JSON.stringify(rawKind)}`;
-  throw new Error(
+  throw new InternalError(
     `storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify('codec-instance')}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`,
   );
 }

package/src/ir/storage-entry-schemas.ts

@@ -75,8 +75,12 @@ const UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({
 });
 
 export const IndexSchema = type({
-  columns: type.string.array().readonly(),
-  'name?': 'string',
+  name: 'string',
+  'prefix?': 'string',
+  'columns?': type.string.array().readonly(),
+  'expression?': 'string',
+  'where?': 'string',
+  unique: 'boolean',
   'type?': 'string',
   'options?': 'Record<string, unknown>',
 });

package/src/ir/storage-table.ts

@@ -1,5 +1,6 @@
 import type { ControlPolicy } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import { CheckConstraint, type CheckConstraintInput } from './check-constraint';
 import { ForeignKey, type ForeignKeyInput } from './foreign-key';
 import { PrimaryKey, type PrimaryKeyInput } from './primary-key';
@@ -86,7 +87,7 @@ export class StorageTable extends SqlNode {
     coordinate: string,
   ): asserts value is StorageTable {
     if (!StorageTable.is(value)) {
-      throw new Error(`Expected a StorageTable at ${coordinate}`);
+      throw new InternalError(`Expected a StorageTable at ${coordinate}`);
     }
   }
 }

package/src/resolve-storage-table.ts

@@ -1,4 +1,5 @@
 import { entityAt } from '@prisma-next/framework-components/ir';
+import { contractError } from './contract-errors';
 import type { SqlStorage } from './ir/sql-storage';
 import type { StorageTable } from './ir/storage-table';
 
@@ -47,8 +48,10 @@ export function resolveStorageTable(
       .map((match) => match.namespaceId)
       .sort()
       .join(', ');
-    throw new Error(
+    throw contractError(
+      'CONTRACT.TABLE_AMBIGUOUS',
       `Storage table "${tableName}" is ambiguous across namespaces [${candidates}]; qualify it with a namespace coordinate.`,
+      { meta: { tableName, candidates: matches.map((match) => match.namespaceId).sort() } },
     );
   }
 

package/src/validators.ts

@@ -14,6 +14,7 @@ import {
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { type Type, type } from 'arktype';
+import { contractError } from './contract-errors';
 import { composeSqlEntityKinds } from './entity-kinds';
 
 export {
@@ -344,7 +345,7 @@ export function createSqlContractSchema(
     'coreHash?': 'string',
     profileHash: 'string',
     'capabilities?': 'Record<string, Record<string, boolean>>',
-    'extensionPacks?': 'Record<string, unknown>',
+    'extensions?': 'Record<string, unknown>',
     'meta?': ContractMetaSchema,
     'defaultControlPolicy?': ControlPolicySchema,
     'roots?': type({ '[string]': CrossReferenceSchema }),
@@ -376,16 +377,28 @@ const SqlContractSchema = createSqlContractSchema(DEFAULT_SQL_KINDS);
 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}`);
+    const errors = result.map((p: { message: string }) => p.message);
+    throw contractError(
+      'CONTRACT.VALIDATION_FAILED',
+      `Storage validation failed: ${errors.join('; ')}`,
+      {
+        meta: { errors },
+      },
+    );
   }
 }
 
 export function validateModel(value: unknown): unknown {
   const result = ModelSchema(value);
   if (result instanceof type.errors) {
-    const messages = result.map((p: { message: string }) => p.message).join('; ');
-    throw new Error(`Model validation failed: ${messages}`);
+    const errors = result.map((p: { message: string }) => p.message);
+    throw contractError(
+      'CONTRACT.VALIDATION_FAILED',
+      `Model validation failed: ${errors.join('; ')}`,
+      {
+        meta: { errors },
+      },
+    );
   }
   return result;
 }
@@ -518,7 +531,7 @@ export function validateStorageSemantics(storage: SqlStorage): string[] {
 
     const seenIndexDefinitions = new Set<string>();
     for (const index of table.indexes) {
-      const duplicateColumn = findDuplicateValue(index.columns);
+      const duplicateColumn = findDuplicateValue(index.columns ?? []);
       if (duplicateColumn !== undefined) {
         errors.push(
           `Namespace "${namespaceId}" table "${tableName}": index contains duplicate column "${duplicateColumn}"`,
@@ -526,13 +539,16 @@ export function validateStorageSemantics(storage: SqlStorage): string[] {
       }
 
       const signature = JSON.stringify({
-        columns: index.columns,
+        columns: index.columns ?? null,
+        expression: index.expression ?? null,
+        where: index.where ?? null,
+        unique: index.unique,
         type: index.type ?? null,
         options: sortOptions(index.options),
       });
       if (seenIndexDefinitions.has(signature)) {
         errors.push(
-          `Namespace "${namespaceId}" table "${tableName}": duplicate index definition on columns [${index.columns.join(', ')}]`,
+          `Namespace "${namespaceId}" table "${tableName}": duplicate index definition on columns [${(index.columns ?? []).join(', ')}]`,
         );
         continue;
       }
@@ -694,7 +710,7 @@ export function validateSqlStorageConsistency(contract: Contract<SqlStorage>): v
     }
 
     for (const index of table.indexes) {
-      for (const colName of index.columns) {
+      for (const colName of index.columns ?? []) {
         if (!columnNames.has(colName)) {
           throw new ContractValidationError(
             `Namespace "${namespaceId}" table "${tableName}" index references non-existent column "${colName}"`,

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

@@ -1 +0,0 @@
-{"version":3,"file":"entity-kinds-CVg6HzG2.mjs","names":[],"sources":["../src/ir/storage-entry-schemas.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  'many?': '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});\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 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/storage-table-DBpYBmty.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage-table-DBpYBmty.mjs","names":[],"sources":["../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"],"sourcesContent":["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}\n\n/**\n * SQL Contract IR node for a table-level foreign-key declaration — the\n * referential constraint only (source, target, `onDelete`/`onUpdate`).\n *\n * A persisted `foreignKeys[]` entry always denotes a real constraint: whether\n * to emit the constraint at all, and whether to back it with an index, are\n * authoring-time decisions (PSL `@relation(index:)`, TS `fk({ constraint,\n * index })`) resolved once at `contract emit` — a `constraint: false` FK\n * simply has no entry here, and a backing index (if any) is its own discrete,\n * named entry in the table's `indexes[]`.\n *\n * Each FK carries explicit `source` and `target` {@link ForeignKeyReference}\n * coordinates (namespace, table, columns). For single-namespace contracts the\n * sentinel `UNBOUND_NAMESPACE_ID` appears on both sides.\n *\n * The nested references are normalised to {@link ForeignKeyReference}\n * instances inside the constructor so downstream walks see a uniform AST\n * regardless of whether the input was a JSON literal or an already-constructed\n * class instance.\n */\nexport class ForeignKey extends SqlNode {\n  readonly source: ForeignKeyReference;\n  readonly target: ForeignKeyReference;\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    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 many?: 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 many?: 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.many !== undefined) this.many = input.many;\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  /**\n   * Runtime guard that a namespace `table` entry is really a `StorageTable`.\n   * The compiler already types the entry as `StorageTable`, but a\n   * freshly-deserialized contract may carry plain JSON at that slot until\n   * hydration; this duck-types the structural shape. Accepts `undefined` so\n   * optional-chained entry lookups pass straight through.\n   */\n  static is(value: StorageTable | undefined): value is StorageTable {\n    if (typeof value !== 'object' || value === null) return false;\n    return 'columns' in value && 'uniques' in value && 'indexes' in value && 'foreignKeys' in value;\n  }\n\n  static assert(\n    value: StorageTable | undefined,\n    coordinate: string,\n  ): asserts value is StorageTable {\n    if (!StorageTable.is(value)) {\n      throw new Error(`Expected a StorageTable at ${coordinate}`);\n    }\n  }\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"storage-table-mNGckl3_.d.mts","names":[],"sources":["../src/ir/check-constraint.ts","../src/ir/storage-column.ts","../src/ir/storage-table.ts"],"mappings":";;;;;;;;;;UASiB;WACN;WACA;WACA,UAAU;;;;;;;;;;;;;;;;cAiBR,wBAAwB;WAC1B;WACA;WACA,UAAU;cAEP,OAAO;;;;;;;;;;;;;;UCpBJ;WACN;WACA;WACA;WACA;WACA,aAAa;WACb;WACA,UAAU;WACV,UAAU;WACV,WAAW;;;;;;;;;;;;;;;cAgBT,sBAAsB;WACxB;WACA;WACA;WACQ;WACA,aAAa;WACb;WACA,UAAU;WACV,UAAU;WACV,WAAW;cAEhB,OAAO;;;;UCxCJ;WACN,SAAS,eAAe,gBAAgB;WACxC,aAAa,aAAa;WAC1B,SAAS,cAAc,mBAAmB;WAC1C,SAAS,cAAc,QAAQ;WAC/B,aAAa,cAAc,aAAa;WACxC,UAAU;WACV,SAAS,cAAc,kBAAkB;;;;;;;;;;;;;;cAevC,qBAAqB;WACvB,SAAS,SAAS,eAAe;WACjC,SAAS,cAAc;WACvB,SAAS,cAAc;WACvB,aAAa,cAAc;WACnB,aAAa;WACb,UAAU;WACV,SAAS,cAAc;cAE5B,OAAO;;;;;;;;SAqCZ,GAAG,OAAO,2BAA2B,SAAS;SAK9C,OACL,OAAO,0BACP,6BACS,SAAS"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types-lpzJtKpv.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;UAIiB,yBAAyB,mCAChC,6BAA6B;EACrC,MAAM,MAAM,yBACV,aACA,8BACC;aAAmB,MAAM;;;KAgDlB;WACD;WACA,WAAW;WACX,WAAW;;KAGV;WACD;WACA;WACA;;KAGC;WACD;WACA;WACA,QAAQ,eAAe;;cAGrB;cACA;iBAEG,gBACd;EAAM;EAAkC;GACxC;EAAqB;EAAkC;;EACpD;EAAqB;;KASd,yBAAyB,eAAe,eAAe;KAEvD,iCAAiC,eAE3C,eAAe;KAGL,SACV,oBAAoB;EAAiB;KAAqB,uBAC1D,6BAA6B,0BAA0B,uBACvD,0BAA0B,yBAAyB,uBACnD,yBAAyB,yBAAyB,uBAClD,4BAA4B,iCAAiC,uBAC7D,iCAAiC,iCAAiC;WAEzD,YAAY;WACZ,qBAAqB;WACrB,kBAAkB;WAClB,iBAAiB;WACjB,oBAAoB;WACpB,yBAAyB;;KAGxB,aAAa,MAAM,qBAC3B,wBACA;WAAqB,kBAAkB;IACrC,UAAU;EAAiB;KACzB,IACA,wBACF;;;;;;;;;KAUM;WACG;WAA0B;WAAyB;;WACnD,iBAAiB;WAAuB;WAA0B;;WAElE;WACA,yBAAyB;WACzB;WACA;;;;;;;;;;KAWH;WACD;aAAuB;aAA0B;;;KAGhD;WACD,OAAO;WACP,UAAU,kBAAkB;;KAG3B,uBACV,YAAY;WAA0B;WAAyB;IAC/D,UAAU,eAAe,4BACvB;KAEQ,0BAA0B,eAAe;KAEzC,sBAAsB,MAAM,qBACpC,wBACA;WAAqB,2BAA2B;IAC9C,UAAU,0BACR,IACA,wBACF;KAEM;KAEA,qBAAqB,WAAW,aAAa,wBAC7C,KAAK,sBAAsB;KAG3B,4BAA4B,KAAK,iCAAiC,IAC1E,YAAY,EAAE,2BAA2B;KAGjC,mBAAmB,MAAM,qBACjC,wBACA;WAAqB,wBAAwB;IAC3C,UAAU,yBACR,IACA,wBACF;KAEM,kBAAkB,MAAM,qBAChC,wBACA;WAAqB,uBAAuB;IAC1C,UAAU,yBACR,IACA,wBACF;KAEM,qBAAqB,MAAM,qBACnC,wBACA;WAAqB,0BAA0B;IAC7C,UAAU,iCACR,IACA,wBACF;KAEM,0BAA0B,MAAM,qBACxC,wBACA;WAAqB,+BAA+B;IAClD,UAAU,iCACR,IACA,wBACF;KAEM,kBAAkB,KAAK,aAAa,4BAA4B;KAChE,2BAA2B,KAAK,sBAAsB,4BAA4B;KAClF,wBAAwB,KAAK,mBAAmB,4BAA4B;KAC5E,uBAAuB,KAAK,kBAAkB,4BAA4B;KAC1E,0BAA0B,KAAK,qBAAqB,4BAA4B;KAChF,+BAA+B,KAAK,0BAC9C,4BAA4B;KAGlB,kBAAkB,WAAW,cAAc,6BACnD,kBAAkB,aAClB,aAAa"}

package/dist/unique-constraint-WHfanEUq.d.mts

@@ -1,54 +0,0 @@
-import { t as SqlNode } from "./sql-node-QXu33IeX.mjs";
-//#region src/ir/primary-key.d.ts
-interface PrimaryKeyInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-/**
- * SQL Contract IR node for a table's primary-key constraint.
- */
-declare class PrimaryKey extends SqlNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  constructor(input: PrimaryKeyInput);
-}
-//#endregion
-//#region src/ir/sql-index.d.ts
-interface IndexInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-}
-/**
- * SQL Contract IR node for a table-level secondary index.
- *
- * Note that this class shadows the global TypeScript `Index` lib type
- * at the family-shared name; consumer files that need both should
- * alias one (e.g.
- * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
- */
-declare class Index extends SqlNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-  constructor(input: IndexInput);
-}
-//#endregion
-//#region src/ir/unique-constraint.d.ts
-interface UniqueConstraintInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-/**
- * SQL Contract IR node for a table-level unique constraint.
- */
-declare class UniqueConstraint extends SqlNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  constructor(input: UniqueConstraintInput);
-}
-//#endregion
-export { PrimaryKey as a, IndexInput as i, UniqueConstraintInput as n, PrimaryKeyInput as o, Index as r, UniqueConstraint as t };
-//# sourceMappingURL=unique-constraint-WHfanEUq.d.mts.map

package/dist/unique-constraint-WHfanEUq.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unique-constraint-WHfanEUq.d.mts","names":[],"sources":["../src/ir/primary-key.ts","../src/ir/sql-index.ts","../src/ir/unique-constraint.ts"],"mappings":";;UAGiB;WACN;WACA;;;;;cAME,mBAAmB;WACrB;WACQ;cAEL,OAAO;;;;UCZJ;WACN;WACA;WACA;WACA,UAAU;;;;;;;;;;cAWR,cAAc;WAChB;WACQ;WACA;WACA,UAAU;cAEf,OAAO;;;;UCrBJ;WACN;WACA;;;;;cAME,yBAAyB;WAC3B;WACQ;cAEL,OAAO"}