@prisma-next/sql-relational-core 0.12.0 → 0.13.0-dev.2

package/dist/exports/codec-descriptor-registry.d.mts

@@ -1,5 +1,5 @@
-import { t as AnyCodecDescriptor } from "../codec-types-Cezo7k-i.mjs";
-import { n as CodecDescriptorRegistry } from "../query-lane-context-Dw1Tz0kv.mjs";
+import { t as AnyCodecDescriptor } from "../codec-types-DFLA6Hmj.mjs";
+import { n as CodecDescriptorRegistry } from "../query-lane-context-CY0-e8Qo.mjs";
 import { CodecRef } from "@prisma-next/framework-components/codec";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 
@@ -20,15 +20,19 @@ declare function buildCodecDescriptorRegistry(allDescriptors: ReadonlyArray<AnyC
 /**
  * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.
  *
- * Resolution rules over `storage.tables[table].columns[column]`:
+ * Resolution rules over namespace `entries.table[table].columns[column]`:
  *
  * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).
  * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.
  * - non-parameterized column → `{codecId}` with `typeParams` undefined.
  *
  * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.
+ *
+ * `namespaceId` leads the coordinate args and is always supplied: every
+ * model/table sits in an explicit namespace, so the table is resolved strictly
+ * within that namespace (see {@link resolveStorageTable}).
  */
-declare function codecRefForStorageColumn(storage: SqlStorage, tableName: string, columnName: string): CodecRef | undefined;
+declare function codecRefForStorageColumn(storage: SqlStorage, namespaceId: string, tableName: string, columnName: string): CodecRef | undefined;
 //#endregion
 export { buildCodecDescriptorRegistry, codecRefForStorageColumn };
 //# sourceMappingURL=codec-descriptor-registry.d.mts.map

package/dist/exports/codec-descriptor-registry.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"codec-descriptor-registry.d.mts","names":[],"sources":["../../src/codec-descriptor-registry.ts","../../src/codec-ref-for-column.ts"],"mappings":";;;;;;;;;AAgBA;;;;;;;iBAAgB,4BAAA,CACd,cAAA,EAAgB,aAAA,CAAc,kBAAA,GAC9B,OAAA,GAAU,UAAA,GACT,uBAAA;;;;;;;AAHH;;;;;;;iBCIgB,wBAAA,CACd,OAAA,EAAS,UAAA,EACT,SAAA,UACA,UAAA,WACC,QAAQ"}
+{"version":3,"file":"codec-descriptor-registry.d.mts","names":[],"sources":["../../src/codec-descriptor-registry.ts","../../src/codec-ref-for-column.ts"],"mappings":";;;;;;;;;AAgBA;;;;;;;iBAAgB,4BAAA,CACd,cAAA,EAAgB,aAAA,CAAc,kBAAA,GAC9B,OAAA,GAAU,UAAA,GACT,uBAAA;;;;;;;AAHH;;;;;;;;;;;iBCQgB,wBAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,SAAA,UACA,UAAA,WACC,QAAQ"}

package/dist/exports/codec-descriptor-registry.mjs

@@ -1,38 +1,33 @@
+import { resolveStorageTable } from "@prisma-next/sql-contract/resolve-storage-table";
 import { isPostgresEnumStorageEntry, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
 //#region src/codec-ref-for-column.ts
 /**
 * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.
 *
-* Resolution rules over `storage.tables[table].columns[column]`:
+* Resolution rules over namespace `entries.table[table].columns[column]`:
 *
 * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).
 * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.
 * - non-parameterized column → `{codecId}` with `typeParams` undefined.
 *
 * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.
+*
+* `namespaceId` leads the coordinate args and is always supplied: every
+* model/table sits in an explicit namespace, so the table is resolved strictly
+* within that namespace (see {@link resolveStorageTable}).
 */
-function codecRefForStorageColumn(storage, tableName, columnName) {
-	let tableDef;
-	for (const ns of Object.values(storage.namespaces)) {
-		const candidate = ns.tables[tableName];
-		if (candidate !== void 0) {
-			tableDef = candidate;
-			break;
-		}
-	}
-	if (!tableDef) return void 0;
-	const columnDef = tableDef.columns[columnName];
+function codecRefForStorageColumn(storage, namespaceId, tableName, columnName) {
+	const resolved = resolveStorageTable(storage, tableName, namespaceId);
+	if (resolved === void 0) return void 0;
+	const columnDef = resolved.table.columns[columnName];
 	if (!columnDef) return void 0;
 	if (columnDef.typeRef !== void 0) {
 		let instance = storage.types?.[columnDef.typeRef];
 		if (!instance) for (const ns of Object.values(storage.namespaces)) {
-			const nsEnums = ns.enum;
-			if (nsEnums) {
-				const nsEntry = nsEnums[columnDef.typeRef];
-				if (nsEntry !== void 0) {
-					instance = nsEntry;
-					break;
-				}
+			const nsEntry = ns.entries.type?.[columnDef.typeRef];
+			if (nsEntry !== void 0) {
+				instance = nsEntry;
+				break;
 			}
 		}
 		if (!instance) return void 0;
@@ -40,13 +35,16 @@ function codecRefForStorageColumn(storage, tableName, columnName) {
 			codecId: instance.codecId,
 			typeParams: { values: instance.values }
 		};
-		if (isStorageTypeInstance(instance)) return {
-			codecId: instance.codecId,
-			typeParams: instance.typeParams
-		};
+		if (isStorageTypeInstance(instance)) {
+			const instanceParams = instance.typeParams;
+			return instanceParams !== void 0 && Object.keys(instanceParams).length > 0 ? {
+				codecId: instance.codecId,
+				typeParams: instanceParams
+			} : { codecId: instance.codecId };
+		}
 		return;
 	}
-	if (columnDef.typeParams !== void 0) return {
+	if (columnDef.typeParams !== void 0 && Object.keys(columnDef.typeParams).length > 0) return {
 		codecId: columnDef.codecId,
 		typeParams: columnDef.typeParams
 	};
@@ -81,9 +79,9 @@ function buildCodecDescriptorRegistry(allDescriptors, storage) {
 		descriptorFor(codecId) {
 			return byId.get(codecId);
 		},
-		codecRefForColumn(table, column) {
+		codecRefForColumn(namespaceId, table, column) {
 			if (!storage) return void 0;
-			return codecRefForStorageColumn(storage, table, column);
+			return codecRefForStorageColumn(storage, namespaceId, table, column);
 		},
 		*values() {
 			yield* byId.values();

package/dist/exports/codec-descriptor-registry.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"codec-descriptor-registry.mjs","names":[],"sources":["../../src/codec-ref-for-column.ts","../../src/codec-descriptor-registry.ts"],"sourcesContent":["import type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecRef } from '@prisma-next/framework-components/codec';\nimport {\n  isPostgresEnumStorageEntry,\n  isStorageTypeInstance,\n  type SqlStorage,\n  type StorageTable,\n} from '@prisma-next/sql-contract/types';\n\n/**\n * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.\n *\n * Resolution rules over `storage.tables[table].columns[column]`:\n *\n * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).\n * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.\n * - non-parameterized column → `{codecId}` with `typeParams` undefined.\n *\n * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.\n */\nexport function codecRefForStorageColumn(\n  storage: SqlStorage,\n  tableName: string,\n  columnName: string,\n): CodecRef | undefined {\n  let tableDef: StorageTable | undefined;\n  for (const ns of Object.values(storage.namespaces)) {\n    const candidate = ns.tables[tableName] as StorageTable | undefined;\n    if (candidate !== undefined) {\n      tableDef = candidate;\n      break;\n    }\n  }\n  if (!tableDef) return undefined;\n  const columnDef = tableDef.columns[columnName];\n  if (!columnDef) return undefined;\n  if (columnDef.typeRef !== undefined) {\n    let instance: unknown = storage.types?.[columnDef.typeRef];\n    if (!instance) {\n      for (const ns of Object.values(storage.namespaces)) {\n        const nsEnums = (ns as { enum?: Record<string, unknown> }).enum;\n        if (nsEnums) {\n          const nsEntry = nsEnums[columnDef.typeRef];\n          if (nsEntry !== undefined) {\n            instance = nsEntry;\n            break;\n          }\n        }\n      }\n    }\n    if (!instance) return undefined;\n    if (isPostgresEnumStorageEntry(instance)) {\n      // Canonical path: the entry is a live `PostgresEnumType` IR\n      // instance reached through the per-target serializer's\n      // hydration. Raw JSON envelopes carrying `kind: 'postgres-enum'`\n      // never reach this site — `SqlStorage.normaliseTypeEntry`\n      // rejects them upstream (F09). Read `codecId` and `values` off\n      // the structural shape (enumerable own properties on the live\n      // instance) so the dispatch stays layered against the family\n      // alphabet rather than a target-specific class import.\n      return {\n        codecId: instance.codecId,\n        typeParams: { values: instance.values } as unknown as JsonValue,\n      };\n    }\n    if (isStorageTypeInstance(instance)) {\n      return { codecId: instance.codecId, typeParams: instance.typeParams as JsonValue };\n    }\n    return undefined;\n  }\n  if (columnDef.typeParams !== undefined) {\n    return { codecId: columnDef.codecId, typeParams: columnDef.typeParams as JsonValue };\n  }\n  return { codecId: columnDef.codecId };\n}\n","import type { CodecDescriptor, CodecRef } from '@prisma-next/framework-components/codec';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { AnyCodecDescriptor } from './ast/codec-types';\nimport { codecRefForStorageColumn } from './codec-ref-for-column';\nimport type { CodecDescriptorRegistry } from './query-lane-context';\n\n/**\n * Build a {@link CodecDescriptorRegistry} from a flat descriptor list.\n *\n * Used by:\n * - Each codec-shipping package's `core/registry.ts` to expose a package-scoped registry as the public consumer surface (replacing raw descriptor-array exports). See ADR 208.\n * - The runtime's `buildExecutionContext` to construct the contract-bound combined registry from every contributor's `codecs:` slot.\n *\n * The descriptor map is heterogeneous in `P` — each codec id has its own params shape. The public {@link CodecDescriptorRegistry} interface widens to `CodecDescriptor<unknown>` and consumers narrow per codec id at the call site (the descriptor's `paramsSchema` validates JSON-sourced params before the factory ever sees them, so the runtime narrow is safe). The cast at registration goes through `unknown` because\n * `CodecDescriptor<P>` is invariant in `P` (the `factory` and `renderOutputType` slots use `P` contravariantly).\n */\nexport function buildCodecDescriptorRegistry(\n  allDescriptors: ReadonlyArray<AnyCodecDescriptor>,\n  storage?: SqlStorage,\n): CodecDescriptorRegistry {\n  type AnyDescriptor = CodecDescriptor<unknown>;\n  const byId = new Map<string, AnyDescriptor>();\n  const byTargetType = new Map<string, Array<AnyDescriptor>>();\n\n  for (const descriptor of allDescriptors) {\n    if (byId.has(descriptor.codecId)) {\n      throw new Error(\n        `Duplicate codec descriptor id: '${descriptor.codecId}' — registered twice during registry construction. ` +\n          'Each codecId must be contributed by exactly one component (target / adapter / extension pack).',\n      );\n    }\n    const widened = descriptor as unknown as AnyDescriptor;\n    byId.set(descriptor.codecId, widened);\n    for (const targetType of descriptor.targetTypes) {\n      const list = byTargetType.get(targetType);\n      if (list) {\n        list.push(widened);\n      } else {\n        byTargetType.set(targetType, [widened]);\n      }\n    }\n  }\n\n  return {\n    descriptorFor(codecId: string): AnyDescriptor | undefined {\n      return byId.get(codecId);\n    },\n    codecRefForColumn(table: string, column: string): CodecRef | undefined {\n      if (!storage) return undefined;\n      return codecRefForStorageColumn(storage, table, column);\n    },\n    *values(): IterableIterator<AnyDescriptor> {\n      yield* byId.values();\n    },\n    byTargetType(targetType: string): readonly AnyDescriptor[] {\n      return byTargetType.get(targetType) ?? Object.freeze([]);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,SAAgB,yBACd,SACA,WACA,YACsB;CACtB,IAAI;CACJ,KAAK,MAAM,MAAM,OAAO,OAAO,QAAQ,UAAU,GAAG;EAClD,MAAM,YAAY,GAAG,OAAO;EAC5B,IAAI,cAAc,KAAA,GAAW;GAC3B,WAAW;GACX;EACF;CACF;CACA,IAAI,CAAC,UAAU,OAAO,KAAA;CACtB,MAAM,YAAY,SAAS,QAAQ;CACnC,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI,UAAU,YAAY,KAAA,GAAW;EACnC,IAAI,WAAoB,QAAQ,QAAQ,UAAU;EAClD,IAAI,CAAC,UACH,KAAK,MAAM,MAAM,OAAO,OAAO,QAAQ,UAAU,GAAG;GAClD,MAAM,UAAW,GAA0C;GAC3D,IAAI,SAAS;IACX,MAAM,UAAU,QAAQ,UAAU;IAClC,IAAI,YAAY,KAAA,GAAW;KACzB,WAAW;KACX;IACF;GACF;EACF;EAEF,IAAI,CAAC,UAAU,OAAO,KAAA;EACtB,IAAI,2BAA2B,QAAQ,GASrC,OAAO;GACL,SAAS,SAAS;GAClB,YAAY,EAAE,QAAQ,SAAS,OAAO;EACxC;EAEF,IAAI,sBAAsB,QAAQ,GAChC,OAAO;GAAE,SAAS,SAAS;GAAS,YAAY,SAAS;EAAwB;EAEnF;CACF;CACA,IAAI,UAAU,eAAe,KAAA,GAC3B,OAAO;EAAE,SAAS,UAAU;EAAS,YAAY,UAAU;CAAwB;CAErF,OAAO,EAAE,SAAS,UAAU,QAAQ;AACtC;;;;;;;;;;;;;AC1DA,SAAgB,6BACd,gBACA,SACyB;CAEzB,MAAM,uBAAO,IAAI,IAA2B;CAC5C,MAAM,+BAAe,IAAI,IAAkC;CAE3D,KAAK,MAAM,cAAc,gBAAgB;EACvC,IAAI,KAAK,IAAI,WAAW,OAAO,GAC7B,MAAM,IAAI,MACR,mCAAmC,WAAW,QAAQ,kJAExD;EAEF,MAAM,UAAU;EAChB,KAAK,IAAI,WAAW,SAAS,OAAO;EACpC,KAAK,MAAM,cAAc,WAAW,aAAa;GAC/C,MAAM,OAAO,aAAa,IAAI,UAAU;GACxC,IAAI,MACF,KAAK,KAAK,OAAO;QAEjB,aAAa,IAAI,YAAY,CAAC,OAAO,CAAC;EAE1C;CACF;CAEA,OAAO;EACL,cAAc,SAA4C;GACxD,OAAO,KAAK,IAAI,OAAO;EACzB;EACA,kBAAkB,OAAe,QAAsC;GACrE,IAAI,CAAC,SAAS,OAAO,KAAA;GACrB,OAAO,yBAAyB,SAAS,OAAO,MAAM;EACxD;EACA,CAAC,SAA0C;GACzC,OAAO,KAAK,OAAO;EACrB;EACA,aAAa,YAA8C;GACzD,OAAO,aAAa,IAAI,UAAU,KAAK,OAAO,OAAO,CAAC,CAAC;EACzD;CACF;AACF"}
+{"version":3,"file":"codec-descriptor-registry.mjs","names":[],"sources":["../../src/codec-ref-for-column.ts","../../src/codec-descriptor-registry.ts"],"sourcesContent":["import type { JsonValue } from '@prisma-next/contract/types';\nimport type { CodecRef } from '@prisma-next/framework-components/codec';\nimport { resolveStorageTable } from '@prisma-next/sql-contract/resolve-storage-table';\nimport {\n  isPostgresEnumStorageEntry,\n  isStorageTypeInstance,\n  type SqlStorage,\n} from '@prisma-next/sql-contract/types';\n\n/**\n * Derive the canonical {@link CodecRef} for a `(table, column)` pair against a {@link SqlStorage}. This is the build-time path every column-bound `ParamRef` / `ProjectionItem` uses to stamp its `codec` slot before the AST is handed to the runtime — the runtime resolver then materialises a memoised {@link import('@prisma-next/sql-relational-core/ast').Codec} for the same `CodecRef` via `forCodecRef`.\n *\n * Resolution rules over namespace `entries.table[table].columns[column]`:\n *\n * - `typeRef` column → `{codecId, typeParams}` from `storage.types[typeRef]` (multiple columns sharing the typeRef share one ref → one memoised codec).\n * - inline `typeParams` column → `{codecId, typeParams}` from the column itself.\n * - non-parameterized column → `{codecId}` with `typeParams` undefined.\n *\n * Returns `undefined` when the table or column is unknown, or when a `typeRef` column references a `storage.types` entry that does not exist.\n *\n * `namespaceId` leads the coordinate args and is always supplied: every\n * model/table sits in an explicit namespace, so the table is resolved strictly\n * within that namespace (see {@link resolveStorageTable}).\n */\nexport function codecRefForStorageColumn(\n  storage: SqlStorage,\n  namespaceId: string,\n  tableName: string,\n  columnName: string,\n): CodecRef | undefined {\n  const resolved = resolveStorageTable(storage, tableName, namespaceId);\n  if (resolved === undefined) return undefined;\n  const tableDef = resolved.table;\n  const columnDef = tableDef.columns[columnName];\n  if (!columnDef) return undefined;\n  if (columnDef.typeRef !== undefined) {\n    let instance: unknown = storage.types?.[columnDef.typeRef];\n    if (!instance) {\n      for (const ns of Object.values(storage.namespaces)) {\n        const typeSlot = (ns.entries as { type?: Record<string, unknown> }).type;\n        const nsEntry = typeSlot?.[columnDef.typeRef];\n        if (nsEntry !== undefined) {\n          instance = nsEntry;\n          break;\n        }\n      }\n    }\n    if (!instance) return undefined;\n    if (isPostgresEnumStorageEntry(instance)) {\n      // Canonical path: the entry is a live `PostgresEnumType` IR\n      // instance reached through the per-target serializer's\n      // hydration. Raw JSON envelopes carrying `kind: 'postgres-enum'`\n      // never reach this site — `SqlStorage.normaliseTypeEntry`\n      // rejects them upstream (F09). Read `codecId` and `values` off\n      // the structural shape (enumerable own properties on the live\n      // instance) so the dispatch stays layered against the family\n      // alphabet rather than a target-specific class import.\n      return {\n        codecId: instance.codecId,\n        typeParams: { values: instance.values } as unknown as JsonValue,\n      };\n    }\n    if (isStorageTypeInstance(instance)) {\n      // Empty-state canonicalization: a `StorageTypeInstance` with absent\n      // (or empty) `typeParams` produces a `CodecRef` with no `typeParams`\n      // field. Equivalent to the non-parameterized-column branch below.\n      // Carrying `{}` here would break content-keyed memoisation and trip\n      // the runtime validator against non-parameterized codec descriptors.\n      const instanceParams = instance.typeParams;\n      const hasParamKeys = instanceParams !== undefined && Object.keys(instanceParams).length > 0;\n      return hasParamKeys\n        ? { codecId: instance.codecId, typeParams: instanceParams as JsonValue }\n        : { codecId: instance.codecId };\n    }\n    return undefined;\n  }\n  if (columnDef.typeParams !== undefined && Object.keys(columnDef.typeParams).length > 0) {\n    return { codecId: columnDef.codecId, typeParams: columnDef.typeParams as JsonValue };\n  }\n  return { codecId: columnDef.codecId };\n}\n","import type { CodecDescriptor, CodecRef } from '@prisma-next/framework-components/codec';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { AnyCodecDescriptor } from './ast/codec-types';\nimport { codecRefForStorageColumn } from './codec-ref-for-column';\nimport type { CodecDescriptorRegistry } from './query-lane-context';\n\n/**\n * Build a {@link CodecDescriptorRegistry} from a flat descriptor list.\n *\n * Used by:\n * - Each codec-shipping package's `core/registry.ts` to expose a package-scoped registry as the public consumer surface (replacing raw descriptor-array exports). See ADR 208.\n * - The runtime's `buildExecutionContext` to construct the contract-bound combined registry from every contributor's `codecs:` slot.\n *\n * The descriptor map is heterogeneous in `P` — each codec id has its own params shape. The public {@link CodecDescriptorRegistry} interface widens to `CodecDescriptor<unknown>` and consumers narrow per codec id at the call site (the descriptor's `paramsSchema` validates JSON-sourced params before the factory ever sees them, so the runtime narrow is safe). The cast at registration goes through `unknown` because\n * `CodecDescriptor<P>` is invariant in `P` (the `factory` and `renderOutputType` slots use `P` contravariantly).\n */\nexport function buildCodecDescriptorRegistry(\n  allDescriptors: ReadonlyArray<AnyCodecDescriptor>,\n  storage?: SqlStorage,\n): CodecDescriptorRegistry {\n  type AnyDescriptor = CodecDescriptor<unknown>;\n  const byId = new Map<string, AnyDescriptor>();\n  const byTargetType = new Map<string, Array<AnyDescriptor>>();\n\n  for (const descriptor of allDescriptors) {\n    if (byId.has(descriptor.codecId)) {\n      throw new Error(\n        `Duplicate codec descriptor id: '${descriptor.codecId}' — registered twice during registry construction. ` +\n          'Each codecId must be contributed by exactly one component (target / adapter / extension pack).',\n      );\n    }\n    const widened = descriptor as unknown as AnyDescriptor;\n    byId.set(descriptor.codecId, widened);\n    for (const targetType of descriptor.targetTypes) {\n      const list = byTargetType.get(targetType);\n      if (list) {\n        list.push(widened);\n      } else {\n        byTargetType.set(targetType, [widened]);\n      }\n    }\n  }\n\n  return {\n    descriptorFor(codecId: string): AnyDescriptor | undefined {\n      return byId.get(codecId);\n    },\n    codecRefForColumn(namespaceId: string, table: string, column: string): CodecRef | undefined {\n      if (!storage) return undefined;\n      return codecRefForStorageColumn(storage, namespaceId, table, column);\n    },\n    *values(): IterableIterator<AnyDescriptor> {\n      yield* byId.values();\n    },\n    byTargetType(targetType: string): readonly AnyDescriptor[] {\n      return byTargetType.get(targetType) ?? Object.freeze([]);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,SAAgB,yBACd,SACA,aACA,WACA,YACsB;CACtB,MAAM,WAAW,oBAAoB,SAAS,WAAW,WAAW;CACpE,IAAI,aAAa,KAAA,GAAW,OAAO,KAAA;CAEnC,MAAM,YADW,SAAS,MACC,QAAQ;CACnC,IAAI,CAAC,WAAW,OAAO,KAAA;CACvB,IAAI,UAAU,YAAY,KAAA,GAAW;EACnC,IAAI,WAAoB,QAAQ,QAAQ,UAAU;EAClD,IAAI,CAAC,UACH,KAAK,MAAM,MAAM,OAAO,OAAO,QAAQ,UAAU,GAAG;GAElD,MAAM,UADY,GAAG,QAA+C,OACzC,UAAU;GACrC,IAAI,YAAY,KAAA,GAAW;IACzB,WAAW;IACX;GACF;EACF;EAEF,IAAI,CAAC,UAAU,OAAO,KAAA;EACtB,IAAI,2BAA2B,QAAQ,GASrC,OAAO;GACL,SAAS,SAAS;GAClB,YAAY,EAAE,QAAQ,SAAS,OAAO;EACxC;EAEF,IAAI,sBAAsB,QAAQ,GAAG;GAMnC,MAAM,iBAAiB,SAAS;GAEhC,OADqB,mBAAmB,KAAA,KAAa,OAAO,KAAK,cAAc,CAAC,CAAC,SAAS,IAEtF;IAAE,SAAS,SAAS;IAAS,YAAY;GAA4B,IACrE,EAAE,SAAS,SAAS,QAAQ;EAClC;EACA;CACF;CACA,IAAI,UAAU,eAAe,KAAA,KAAa,OAAO,KAAK,UAAU,UAAU,CAAC,CAAC,SAAS,GACnF,OAAO;EAAE,SAAS,UAAU;EAAS,YAAY,UAAU;CAAwB;CAErF,OAAO,EAAE,SAAS,UAAU,QAAQ;AACtC;;;;;;;;;;;;;AChEA,SAAgB,6BACd,gBACA,SACyB;CAEzB,MAAM,uBAAO,IAAI,IAA2B;CAC5C,MAAM,+BAAe,IAAI,IAAkC;CAE3D,KAAK,MAAM,cAAc,gBAAgB;EACvC,IAAI,KAAK,IAAI,WAAW,OAAO,GAC7B,MAAM,IAAI,MACR,mCAAmC,WAAW,QAAQ,kJAExD;EAEF,MAAM,UAAU;EAChB,KAAK,IAAI,WAAW,SAAS,OAAO;EACpC,KAAK,MAAM,cAAc,WAAW,aAAa;GAC/C,MAAM,OAAO,aAAa,IAAI,UAAU;GACxC,IAAI,MACF,KAAK,KAAK,OAAO;QAEjB,aAAa,IAAI,YAAY,CAAC,OAAO,CAAC;EAE1C;CACF;CAEA,OAAO;EACL,cAAc,SAA4C;GACxD,OAAO,KAAK,IAAI,OAAO;EACzB;EACA,kBAAkB,aAAqB,OAAe,QAAsC;GAC1F,IAAI,CAAC,SAAS,OAAO,KAAA;GACrB,OAAO,yBAAyB,SAAS,aAAa,OAAO,MAAM;EACrE;EACA,CAAC,SAA0C;GACzC,OAAO,KAAK,OAAO;EACrB;EACA,aAAa,YAA8C;GACzD,OAAO,aAAa,IAAI,UAAU,KAAK,OAAO,OAAO,CAAC,CAAC;EACzD;CACF;AACF"}

package/dist/exports/contract-free.d.mts

@@ -0,0 +1,161 @@
+import { A as InsertAst, Z as ProjectionItem, at as TableSource, g as ColumnRef, o as AnyExpression, q as OrderByItem, st as UpdateAst, tt as SelectAst } from "../types-BbGUx5Bi.mjs";
+import { c as ForeignKeyConstraint, d as PrimaryKeyConstraint, f as UniqueConstraint, l as FunctionColumnDefault, n as DdlColumn, t as AnyDdlColumnDefault, u as LiteralColumnDefault } from "../ddl-types-D3vlEjMA.mjs";
+import { ColumnDefaultLiteralInputValue } from "@prisma-next/contract/types";
+import { ReferentialAction } from "@prisma-next/sql-contract/types";
+
+//#region src/contract-free/column.d.ts
+interface DdlColumnOptions {
+  readonly notNull?: boolean;
+  readonly primaryKey?: boolean;
+  readonly default?: AnyDdlColumnDefault;
+}
+declare function lit(value: ColumnDefaultLiteralInputValue): LiteralColumnDefault;
+declare function fn(expression: string): FunctionColumnDefault;
+declare function col(name: string, type: string, options?: DdlColumnOptions): DdlColumn;
+declare function primaryKey(columns: readonly string[], options?: {
+  readonly name?: string;
+}): PrimaryKeyConstraint;
+declare function foreignKey(columns: readonly string[], refTable: string, refColumns: readonly string[], options?: {
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+}): ForeignKeyConstraint;
+declare function unique(columns: readonly string[], options?: {
+  readonly name?: string;
+}): UniqueConstraint;
+//#endregion
+//#region src/contract-free/table.d.ts
+interface ColumnDescriptor {
+  readonly codecId: string;
+  readonly nullable: boolean;
+}
+type ColumnSchema = Record<string, ColumnDescriptor>;
+/**
+ * A composable WHERE / ON expression. Wraps an `AnyExpression` and exposes
+ * fluent boolean combinators, mirroring the spirit of `sql-builder`'s
+ * `Expression` interface without the contract-bound type machinery.
+ */
+declare class CfExpr {
+  readonly ast: AnyExpression;
+  constructor(ast: AnyExpression);
+  and(other: CfExpr): CfExpr;
+  or(other: CfExpr): CfExpr;
+  not(): CfExpr;
+}
+/**
+ * Per-column authoring handle exposed as a keyed property on a {@link TableHandle}.
+ * Carries codec metadata baked at declaration time so no codec ID, table name, or
+ * column name needs to be repeated at the call site.
+ */
+interface ColumnProxy {
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly columnName: string;
+  readonly tableName: string;
+  eq(value: unknown): CfExpr;
+  neq(value: unknown): CfExpr;
+  isNull(): CfExpr;
+  isNotNull(): CfExpr;
+  toRef(): ColumnRef;
+  toProjectionItem(alias?: string): ProjectionItem;
+}
+/**
+ * Object passed to the {@link CfConflictClause.doUpdate} callback. Each key
+ * resolves to a `ColumnRef` for the corresponding `excluded.<column>`, so the
+ * upsert conflict-update branch can copy proposed values without re-binding
+ * parameters.
+ */
+type ExcludedProxy<Schema extends ColumnSchema> = { readonly [K in keyof Schema]: ColumnRef };
+type TableInsertRow<Schema extends ColumnSchema> = { readonly [K in keyof Schema]: unknown };
+type TableSetValues<Schema extends ColumnSchema> = { readonly [K in keyof Schema]?: unknown };
+/**
+ * Fluent authoring handle for a fixed control-plane table. Column proxies are
+ * exposed as keyed properties so `handle.columnName.eq(value)` composes without
+ * threading codec IDs, table names, or column refs at the call site.
+ */
+type TableHandle<Schema extends ColumnSchema> = {
+  readonly source: TableSource;
+  insert(row: TableInsertRow<Schema>): CfInsertQuery<Schema>;
+  upsert(row: TableInsertRow<Schema>): CfUpsertBuilder<Schema>;
+  update(): CfUpdateQuery<Schema>;
+  select(...columns: ReadonlyArray<ColumnProxy>): CfSelectQuery;
+} & { readonly [K in keyof Schema]: ColumnProxy };
+declare class CfInsertQuery<Schema extends ColumnSchema> {
+  private readonly src;
+  private readonly schema;
+  private readonly rowValues;
+  private readonly returningItems;
+  constructor(src: TableSource, schema: Schema, rowValues: TableInsertRow<Schema>, returningItems?: ReadonlyArray<ProjectionItem> | undefined);
+  returning(...columns: ReadonlyArray<ColumnProxy>): CfInsertQuery<Schema>;
+  build(): InsertAst;
+}
+declare class CfUpsertBuilder<Schema extends ColumnSchema> {
+  private readonly src;
+  private readonly schema;
+  private readonly rowValues;
+  constructor(src: TableSource, schema: Schema, rowValues: TableInsertRow<Schema>);
+  onConflict(...columns: ReadonlyArray<ColumnProxy>): CfConflictClause<Schema>;
+}
+declare class CfConflictClause<Schema extends ColumnSchema> {
+  private readonly src;
+  private readonly schema;
+  private readonly rowValues;
+  private readonly conflictCols;
+  constructor(src: TableSource, schema: Schema, rowValues: TableInsertRow<Schema>, conflictCols: ReadonlyArray<ColumnProxy>);
+  doUpdate(setOrCallback: TableSetValues<Schema> | ((excluded: ExcludedProxy<Schema>) => TableSetValues<Schema>)): CfUpsertQuery<Schema>;
+  doNothing(): CfUpsertQuery<Schema>;
+}
+declare class CfUpsertQuery<Schema extends ColumnSchema> {
+  private readonly src;
+  private readonly schema;
+  private readonly rowValues;
+  private readonly conflictCols;
+  private readonly updateSet;
+  constructor(src: TableSource, schema: Schema, rowValues: TableInsertRow<Schema>, conflictCols: ReadonlyArray<ColumnProxy>, updateSet: TableSetValues<Schema> | undefined);
+  build(): InsertAst;
+}
+declare class CfUpdateQuery<Schema extends ColumnSchema> {
+  private readonly src;
+  private readonly schema;
+  private readonly setValues;
+  private readonly whereExpr;
+  private readonly returningItems;
+  constructor(src: TableSource, schema: Schema, setValues?: TableSetValues<Schema> | undefined, whereExpr?: CfExpr | undefined, returningItems?: ReadonlyArray<ProjectionItem> | undefined);
+  set(values: TableSetValues<Schema>): CfUpdateQuery<Schema>;
+  where(expr: CfExpr): CfUpdateQuery<Schema>;
+  returning(...columns: ReadonlyArray<ColumnProxy>): CfUpdateQuery<Schema>;
+  build(): UpdateAst;
+}
+declare class CfSelectQuery {
+  private readonly src;
+  private readonly projectionItems;
+  private readonly whereExpr;
+  private readonly orderByItems;
+  constructor(src: TableSource, projectionItems: ReadonlyArray<ProjectionItem>, whereExpr?: CfExpr | undefined, orderByItems?: ReadonlyArray<OrderByItem>);
+  where(expr: CfExpr): CfSelectQuery;
+  orderBy(column: ColumnProxy, dir?: 'asc' | 'desc'): CfSelectQuery;
+  build(): SelectAst;
+}
+/**
+ * Declare a control-plane table once, binding column codecs at declaration time.
+ * Returns a `TableHandle` whose column properties compose expressions directly
+ * without per-call-site codec or column-name threading.
+ *
+ * ```ts
+ * const marker = pgTable({ name: 'marker', schema: 'prisma_contract' }, {
+ *   space:      text(),
+ *   core_hash:  text(),
+ *   updated_at: timestamptz(),
+ * });
+ *
+ * const query = marker.update()
+ *   .set({ core_hash: newHash, updated_at: NOW })
+ *   .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))
+ *   .returning(marker.space)
+ *   .build();
+ * ```
+ */
+declare function table<Schema extends ColumnSchema>(source: TableSource, schema: Schema): TableHandle<Schema>;
+//#endregion
+export { CfConflictClause, CfExpr, CfInsertQuery, CfSelectQuery, CfUpdateQuery, CfUpsertBuilder, CfUpsertQuery, type ColumnDescriptor, type ColumnProxy, type ColumnSchema, type DdlColumnOptions, type ExcludedProxy, type TableHandle, type TableInsertRow, type TableSetValues, col, fn, foreignKey, lit, primaryKey, table, unique };
+//# sourceMappingURL=contract-free.d.mts.map

package/dist/exports/contract-free.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-free.d.mts","names":[],"sources":["../../src/contract-free/column.ts","../../src/contract-free/table.ts"],"mappings":"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"}

package/dist/exports/contract-free.mjs

@@ -0,0 +1,268 @@
+import { a as FunctionColumnDefault, c as UniqueConstraint, i as ForeignKeyConstraint, o as LiteralColumnDefault, s as PrimaryKeyConstraint, t as DdlColumn } from "../ddl-types-X9_XHUl0.mjs";
+import { A as SelectAst, C as OrExpr, D as ProjectionItem, N as UpdateAst, T as ParamRef, i as ColumnRef, m as InsertOnConflict, n as AndExpr, p as InsertAst, r as BinaryExpr, w as OrderByItem, x as NullCheckExpr } from "../types-D72v8s92.mjs";
+import { blindCast } from "@prisma-next/utils/casts";
+//#region src/contract-free/column.ts
+function lit(value) {
+	return new LiteralColumnDefault(value);
+}
+function fn(expression) {
+	return new FunctionColumnDefault(expression);
+}
+function col(name, type, options) {
+	return new DdlColumn({
+		name,
+		type,
+		...options
+	});
+}
+function primaryKey(columns, options) {
+	return new PrimaryKeyConstraint({
+		columns,
+		...options
+	});
+}
+function foreignKey(columns, refTable, refColumns, options) {
+	return new ForeignKeyConstraint({
+		columns,
+		refTable,
+		refColumns,
+		...options
+	});
+}
+function unique(columns, options) {
+	return new UniqueConstraint({
+		columns,
+		...options
+	});
+}
+//#endregion
+//#region src/contract-free/table.ts
+/**
+* A composable WHERE / ON expression. Wraps an `AnyExpression` and exposes
+* fluent boolean combinators, mirroring the spirit of `sql-builder`'s
+* `Expression` interface without the contract-bound type machinery.
+*/
+var CfExpr = class CfExpr {
+	ast;
+	constructor(ast) {
+		this.ast = ast;
+	}
+	and(other) {
+		return new CfExpr(AndExpr.of([this.ast, other.ast]));
+	}
+	or(other) {
+		return new CfExpr(OrExpr.of([this.ast, other.ast]));
+	}
+	not() {
+		return new CfExpr(this.ast.not());
+	}
+};
+var CfInsertQuery = class CfInsertQuery {
+	src;
+	schema;
+	rowValues;
+	returningItems;
+	constructor(src, schema, rowValues, returningItems = void 0) {
+		this.src = src;
+		this.schema = schema;
+		this.rowValues = rowValues;
+		this.returningItems = returningItems;
+	}
+	returning(...columns) {
+		return new CfInsertQuery(this.src, this.schema, this.rowValues, columns.map((col) => col.toProjectionItem()));
+	}
+	build() {
+		const row = buildInsertRow(this.schema, this.rowValues);
+		const ast = InsertAst.into(this.src).withRows([row]);
+		return this.returningItems ? ast.withReturning(this.returningItems) : ast;
+	}
+};
+var CfUpsertBuilder = class {
+	src;
+	schema;
+	rowValues;
+	constructor(src, schema, rowValues) {
+		this.src = src;
+		this.schema = schema;
+		this.rowValues = rowValues;
+	}
+	onConflict(...columns) {
+		return new CfConflictClause(this.src, this.schema, this.rowValues, [...columns]);
+	}
+};
+var CfConflictClause = class {
+	src;
+	schema;
+	rowValues;
+	conflictCols;
+	constructor(src, schema, rowValues, conflictCols) {
+		this.src = src;
+		this.schema = schema;
+		this.rowValues = rowValues;
+		this.conflictCols = conflictCols;
+	}
+	doUpdate(setOrCallback) {
+		const set = typeof setOrCallback === "function" ? setOrCallback(buildExcludedProxy(this.schema)) : setOrCallback;
+		return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, set);
+	}
+	doNothing() {
+		return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, void 0);
+	}
+};
+var CfUpsertQuery = class {
+	src;
+	schema;
+	rowValues;
+	conflictCols;
+	updateSet;
+	constructor(src, schema, rowValues, conflictCols, updateSet) {
+		this.src = src;
+		this.schema = schema;
+		this.rowValues = rowValues;
+		this.conflictCols = conflictCols;
+		this.updateSet = updateSet;
+	}
+	build() {
+		const row = buildInsertRow(this.schema, this.rowValues);
+		const conflictRefs = this.conflictCols.map((col) => col.toRef());
+		const onConflict = this.updateSet === void 0 ? InsertOnConflict.on(conflictRefs).doNothing() : InsertOnConflict.on(conflictRefs).doUpdateSet(buildSetMap(this.schema, this.updateSet));
+		return InsertAst.into(this.src).withRows([row]).withOnConflict(onConflict);
+	}
+};
+var CfUpdateQuery = class CfUpdateQuery {
+	src;
+	schema;
+	setValues;
+	whereExpr;
+	returningItems;
+	constructor(src, schema, setValues = void 0, whereExpr = void 0, returningItems = void 0) {
+		this.src = src;
+		this.schema = schema;
+		this.setValues = setValues;
+		this.whereExpr = whereExpr;
+		this.returningItems = returningItems;
+	}
+	set(values) {
+		return new CfUpdateQuery(this.src, this.schema, values, this.whereExpr, this.returningItems);
+	}
+	where(expr) {
+		return new CfUpdateQuery(this.src, this.schema, this.setValues, expr, this.returningItems);
+	}
+	returning(...columns) {
+		return new CfUpdateQuery(this.src, this.schema, this.setValues, this.whereExpr, columns.map((col) => col.toProjectionItem()));
+	}
+	build() {
+		const set = buildSetMap(this.schema, this.setValues);
+		const base = UpdateAst.table(this.src).withSet(set);
+		const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;
+		return this.returningItems ? withWhere.withReturning(this.returningItems) : withWhere;
+	}
+};
+var CfSelectQuery = class CfSelectQuery {
+	src;
+	projectionItems;
+	whereExpr;
+	orderByItems;
+	constructor(src, projectionItems, whereExpr = void 0, orderByItems = []) {
+		this.src = src;
+		this.projectionItems = projectionItems;
+		this.whereExpr = whereExpr;
+		this.orderByItems = orderByItems;
+	}
+	where(expr) {
+		return new CfSelectQuery(this.src, this.projectionItems, expr, this.orderByItems);
+	}
+	orderBy(column, dir = "asc") {
+		const item = dir === "asc" ? OrderByItem.asc(column.toRef()) : OrderByItem.desc(column.toRef());
+		return new CfSelectQuery(this.src, this.projectionItems, this.whereExpr, [...this.orderByItems, item]);
+	}
+	build() {
+		const base = SelectAst.from(this.src).withProjection(this.projectionItems);
+		const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;
+		return this.orderByItems.length > 0 ? withWhere.withOrderBy(this.orderByItems) : withWhere;
+	}
+};
+/**
+* Declare a control-plane table once, binding column codecs at declaration time.
+* Returns a `TableHandle` whose column properties compose expressions directly
+* without per-call-site codec or column-name threading.
+*
+* ```ts
+* const marker = pgTable({ name: 'marker', schema: 'prisma_contract' }, {
+*   space:      text(),
+*   core_hash:  text(),
+*   updated_at: timestamptz(),
+* });
+*
+* const query = marker.update()
+*   .set({ core_hash: newHash, updated_at: NOW })
+*   .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))
+*   .returning(marker.space)
+*   .build();
+* ```
+*/
+function table(source, schema) {
+	const proxies = {};
+	for (const [col, desc] of Object.entries(schema)) proxies[col] = makeColumnProxy(source.alias ?? source.name, col, desc);
+	return blindCast({
+		...proxies,
+		source,
+		insert: (row) => new CfInsertQuery(source, schema, row),
+		upsert: (row) => new CfUpsertBuilder(source, schema, row),
+		update: () => new CfUpdateQuery(source, schema),
+		select: (...cols) => new CfSelectQuery(source, cols.map((col) => col.toProjectionItem()))
+	});
+}
+function makeColumnProxy(tableName, columnName, desc) {
+	const ref = ColumnRef.of(tableName, columnName);
+	return {
+		codecId: desc.codecId,
+		nullable: desc.nullable,
+		columnName,
+		tableName,
+		eq: (value) => value === null ? new CfExpr(NullCheckExpr.isNull(ref)) : new CfExpr(BinaryExpr.eq(ref, toSetExpression(value, desc))),
+		neq: (value) => value === null ? new CfExpr(NullCheckExpr.isNotNull(ref)) : new CfExpr(BinaryExpr.neq(ref, toSetExpression(value, desc))),
+		isNull: () => new CfExpr(NullCheckExpr.isNull(ref)),
+		isNotNull: () => new CfExpr(NullCheckExpr.isNotNull(ref)),
+		toRef: () => ref,
+		toProjectionItem: (alias = columnName) => ProjectionItem.of(alias, ref, { codecId: desc.codecId })
+	};
+}
+function buildExcludedProxy(schema) {
+	return blindCast(Object.fromEntries(Object.keys(schema).map((col) => [col, ColumnRef.of("excluded", col)])));
+}
+function isExpressionSource(value) {
+	return typeof value === "object" && value !== null && "toExpr" in value && typeof value.toExpr === "function";
+}
+function toInsertValue(value, desc) {
+	if (isExpressionSource(value)) {
+		const expr = value.toExpr();
+		if (expr.kind === "column-ref" || expr.kind === "param-ref" || expr.kind === "prepared-param-ref" || expr.kind === "raw-expr") return expr;
+	}
+	return ParamRef.of(value, { codec: { codecId: desc.codecId } });
+}
+function toSetExpression(value, desc) {
+	if (isExpressionSource(value)) return value.toExpr();
+	return ParamRef.of(value, { codec: { codecId: desc.codecId } });
+}
+function buildInsertRow(schema, values) {
+	const row = {};
+	const rawValues = blindCast(values);
+	for (const [col, desc] of Object.entries(schema)) row[col] = toInsertValue(rawValues[col], desc);
+	return row;
+}
+function buildSetMap(schema, values) {
+	if (values === void 0) return {};
+	const set = {};
+	const rawSchema = blindCast(schema);
+	const rawValues = blindCast(values);
+	for (const [col, value] of Object.entries(rawValues)) {
+		const desc = rawSchema[col];
+		if (desc !== void 0) set[col] = toSetExpression(value, desc);
+	}
+	return set;
+}
+//#endregion
+export { CfConflictClause, CfExpr, CfInsertQuery, CfSelectQuery, CfUpdateQuery, CfUpsertBuilder, CfUpsertQuery, col, fn, foreignKey, lit, primaryKey, table, unique };
+
+//# sourceMappingURL=contract-free.mjs.map

package/dist/exports/contract-free.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-free.mjs","names":[],"sources":["../../src/contract-free/column.ts","../../src/contract-free/table.ts"],"sourcesContent":["import type { ColumnDefaultLiteralInputValue } from '@prisma-next/contract/types';\nimport type { ReferentialAction } from '@prisma-next/sql-contract/types';\nimport type { AnyDdlColumnDefault } from '../ast/ddl-types';\nimport {\n  DdlColumn,\n  ForeignKeyConstraint,\n  FunctionColumnDefault,\n  LiteralColumnDefault,\n  PrimaryKeyConstraint,\n  UniqueConstraint,\n} from '../ast/ddl-types';\n\nexport interface DdlColumnOptions {\n  readonly notNull?: boolean;\n  readonly primaryKey?: boolean;\n  readonly default?: AnyDdlColumnDefault;\n}\n\nexport function lit(value: ColumnDefaultLiteralInputValue): LiteralColumnDefault {\n  return new LiteralColumnDefault(value);\n}\n\nexport function fn(expression: string): FunctionColumnDefault {\n  return new FunctionColumnDefault(expression);\n}\n\nexport function col(name: string, type: string, options?: DdlColumnOptions): DdlColumn {\n  return new DdlColumn({ name, type, ...options });\n}\n\nexport function primaryKey(\n  columns: readonly string[],\n  options?: { readonly name?: string },\n): PrimaryKeyConstraint {\n  return new PrimaryKeyConstraint({ columns, ...options });\n}\n\nexport function foreignKey(\n  columns: readonly string[],\n  refTable: string,\n  refColumns: readonly string[],\n  options?: {\n    readonly name?: string;\n    readonly onDelete?: ReferentialAction;\n    readonly onUpdate?: ReferentialAction;\n  },\n): ForeignKeyConstraint {\n  return new ForeignKeyConstraint({ columns, refTable, refColumns, ...options });\n}\n\nexport function unique(\n  columns: readonly string[],\n  options?: { readonly name?: string },\n): UniqueConstraint {\n  return new UniqueConstraint({ columns, ...options });\n}\n","import { blindCast } from '@prisma-next/utils/casts';\nimport {\n  AndExpr,\n  type AnyExpression,\n  BinaryExpr,\n  ColumnRef,\n  InsertAst,\n  InsertOnConflict,\n  type InsertValue,\n  NullCheckExpr,\n  OrderByItem,\n  OrExpr,\n  ParamRef,\n  ProjectionItem,\n  SelectAst,\n  type TableSource,\n  UpdateAst,\n} from '../ast/types';\n\nexport interface ColumnDescriptor {\n  readonly codecId: string;\n  readonly nullable: boolean;\n}\n\nexport type ColumnSchema = Record<string, ColumnDescriptor>;\n\n/**\n * A composable WHERE / ON expression. Wraps an `AnyExpression` and exposes\n * fluent boolean combinators, mirroring the spirit of `sql-builder`'s\n * `Expression` interface without the contract-bound type machinery.\n */\nexport class CfExpr {\n  constructor(readonly ast: AnyExpression) {}\n\n  and(other: CfExpr): CfExpr {\n    return new CfExpr(AndExpr.of([this.ast, other.ast]));\n  }\n\n  or(other: CfExpr): CfExpr {\n    return new CfExpr(OrExpr.of([this.ast, other.ast]));\n  }\n\n  not(): CfExpr {\n    return new CfExpr(this.ast.not());\n  }\n}\n\n/**\n * Per-column authoring handle exposed as a keyed property on a {@link TableHandle}.\n * Carries codec metadata baked at declaration time so no codec ID, table name, or\n * column name needs to be repeated at the call site.\n */\nexport interface ColumnProxy {\n  readonly codecId: string;\n  readonly nullable: boolean;\n  readonly columnName: string;\n  readonly tableName: string;\n  eq(value: unknown): CfExpr;\n  neq(value: unknown): CfExpr;\n  isNull(): CfExpr;\n  isNotNull(): CfExpr;\n  toRef(): ColumnRef;\n  toProjectionItem(alias?: string): ProjectionItem;\n}\n\n/**\n * Object passed to the {@link CfConflictClause.doUpdate} callback. Each key\n * resolves to a `ColumnRef` for the corresponding `excluded.<column>`, so the\n * upsert conflict-update branch can copy proposed values without re-binding\n * parameters.\n */\nexport type ExcludedProxy<Schema extends ColumnSchema> = {\n  readonly [K in keyof Schema]: ColumnRef;\n};\n\nexport type TableInsertRow<Schema extends ColumnSchema> = {\n  readonly [K in keyof Schema]: unknown;\n};\n\nexport type TableSetValues<Schema extends ColumnSchema> = {\n  readonly [K in keyof Schema]?: unknown;\n};\n\n/**\n * Fluent authoring handle for a fixed control-plane table. Column proxies are\n * exposed as keyed properties so `handle.columnName.eq(value)` composes without\n * threading codec IDs, table names, or column refs at the call site.\n */\nexport type TableHandle<Schema extends ColumnSchema> = {\n  readonly source: TableSource;\n  insert(row: TableInsertRow<Schema>): CfInsertQuery<Schema>;\n  upsert(row: TableInsertRow<Schema>): CfUpsertBuilder<Schema>;\n  update(): CfUpdateQuery<Schema>;\n  select(...columns: ReadonlyArray<ColumnProxy>): CfSelectQuery;\n} & {\n  readonly [K in keyof Schema]: ColumnProxy;\n};\n\nexport class CfInsertQuery<Schema extends ColumnSchema> {\n  constructor(\n    private readonly src: TableSource,\n    private readonly schema: Schema,\n    private readonly rowValues: TableInsertRow<Schema>,\n    private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,\n  ) {}\n\n  returning(...columns: ReadonlyArray<ColumnProxy>): CfInsertQuery<Schema> {\n    return new CfInsertQuery(\n      this.src,\n      this.schema,\n      this.rowValues,\n      columns.map((col) => col.toProjectionItem()),\n    );\n  }\n\n  build(): InsertAst {\n    const row = buildInsertRow(this.schema, this.rowValues);\n    const ast = InsertAst.into(this.src).withRows([row]);\n    return this.returningItems ? ast.withReturning(this.returningItems) : ast;\n  }\n}\n\nexport class CfUpsertBuilder<Schema extends ColumnSchema> {\n  constructor(\n    private readonly src: TableSource,\n    private readonly schema: Schema,\n    private readonly rowValues: TableInsertRow<Schema>,\n  ) {}\n\n  onConflict(...columns: ReadonlyArray<ColumnProxy>): CfConflictClause<Schema> {\n    return new CfConflictClause(this.src, this.schema, this.rowValues, [...columns]);\n  }\n}\n\nexport class CfConflictClause<Schema extends ColumnSchema> {\n  constructor(\n    private readonly src: TableSource,\n    private readonly schema: Schema,\n    private readonly rowValues: TableInsertRow<Schema>,\n    private readonly conflictCols: ReadonlyArray<ColumnProxy>,\n  ) {}\n\n  doUpdate(\n    setOrCallback:\n      | TableSetValues<Schema>\n      | ((excluded: ExcludedProxy<Schema>) => TableSetValues<Schema>),\n  ): CfUpsertQuery<Schema> {\n    const set =\n      typeof setOrCallback === 'function'\n        ? setOrCallback(buildExcludedProxy(this.schema))\n        : setOrCallback;\n    return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, set);\n  }\n\n  doNothing(): CfUpsertQuery<Schema> {\n    return new CfUpsertQuery(this.src, this.schema, this.rowValues, this.conflictCols, undefined);\n  }\n}\n\nexport class CfUpsertQuery<Schema extends ColumnSchema> {\n  constructor(\n    private readonly src: TableSource,\n    private readonly schema: Schema,\n    private readonly rowValues: TableInsertRow<Schema>,\n    private readonly conflictCols: ReadonlyArray<ColumnProxy>,\n    private readonly updateSet: TableSetValues<Schema> | undefined,\n  ) {}\n\n  build(): InsertAst {\n    const row = buildInsertRow(this.schema, this.rowValues);\n    const conflictRefs = this.conflictCols.map((col) => col.toRef());\n    const onConflict =\n      this.updateSet === undefined\n        ? InsertOnConflict.on(conflictRefs).doNothing()\n        : InsertOnConflict.on(conflictRefs).doUpdateSet(buildSetMap(this.schema, this.updateSet));\n    return InsertAst.into(this.src).withRows([row]).withOnConflict(onConflict);\n  }\n}\n\nexport class CfUpdateQuery<Schema extends ColumnSchema> {\n  constructor(\n    private readonly src: TableSource,\n    private readonly schema: Schema,\n    private readonly setValues: TableSetValues<Schema> | undefined = undefined,\n    private readonly whereExpr: CfExpr | undefined = undefined,\n    private readonly returningItems: ReadonlyArray<ProjectionItem> | undefined = undefined,\n  ) {}\n\n  set(values: TableSetValues<Schema>): CfUpdateQuery<Schema> {\n    return new CfUpdateQuery(this.src, this.schema, values, this.whereExpr, this.returningItems);\n  }\n\n  where(expr: CfExpr): CfUpdateQuery<Schema> {\n    return new CfUpdateQuery(this.src, this.schema, this.setValues, expr, this.returningItems);\n  }\n\n  returning(...columns: ReadonlyArray<ColumnProxy>): CfUpdateQuery<Schema> {\n    return new CfUpdateQuery(\n      this.src,\n      this.schema,\n      this.setValues,\n      this.whereExpr,\n      columns.map((col) => col.toProjectionItem()),\n    );\n  }\n\n  build(): UpdateAst {\n    const set = buildSetMap(this.schema, this.setValues);\n    const base = UpdateAst.table(this.src).withSet(set);\n    const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;\n    return this.returningItems ? withWhere.withReturning(this.returningItems) : withWhere;\n  }\n}\n\nexport class CfSelectQuery {\n  constructor(\n    private readonly src: TableSource,\n    private readonly projectionItems: ReadonlyArray<ProjectionItem>,\n    private readonly whereExpr: CfExpr | undefined = undefined,\n    private readonly orderByItems: ReadonlyArray<OrderByItem> = [],\n  ) {}\n\n  where(expr: CfExpr): CfSelectQuery {\n    return new CfSelectQuery(this.src, this.projectionItems, expr, this.orderByItems);\n  }\n\n  orderBy(column: ColumnProxy, dir: 'asc' | 'desc' = 'asc'): CfSelectQuery {\n    const item = dir === 'asc' ? OrderByItem.asc(column.toRef()) : OrderByItem.desc(column.toRef());\n    return new CfSelectQuery(this.src, this.projectionItems, this.whereExpr, [\n      ...this.orderByItems,\n      item,\n    ]);\n  }\n\n  build(): SelectAst {\n    const base = SelectAst.from(this.src).withProjection(this.projectionItems);\n    const withWhere = this.whereExpr ? base.withWhere(this.whereExpr.ast) : base;\n    return this.orderByItems.length > 0 ? withWhere.withOrderBy(this.orderByItems) : withWhere;\n  }\n}\n\n/**\n * Declare a control-plane table once, binding column codecs at declaration time.\n * Returns a `TableHandle` whose column properties compose expressions directly\n * without per-call-site codec or column-name threading.\n *\n * ```ts\n * const marker = pgTable({ name: 'marker', schema: 'prisma_contract' }, {\n *   space:      text(),\n *   core_hash:  text(),\n *   updated_at: timestamptz(),\n * });\n *\n * const query = marker.update()\n *   .set({ core_hash: newHash, updated_at: NOW })\n *   .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))\n *   .returning(marker.space)\n *   .build();\n * ```\n */\nexport function table<Schema extends ColumnSchema>(\n  source: TableSource,\n  schema: Schema,\n): TableHandle<Schema> {\n  const proxies: Record<string, ColumnProxy> = {};\n  for (const [col, desc] of Object.entries(schema)) {\n    proxies[col] = makeColumnProxy(source.alias ?? source.name, col, desc);\n  }\n\n  const handle = {\n    ...proxies,\n    source,\n    insert: (row: TableInsertRow<Schema>) => new CfInsertQuery(source, schema, row),\n    upsert: (row: TableInsertRow<Schema>) => new CfUpsertBuilder(source, schema, row),\n    update: () => new CfUpdateQuery(source, schema),\n    select: (...cols: ReadonlyArray<ColumnProxy>) =>\n      new CfSelectQuery(\n        source,\n        cols.map((col) => col.toProjectionItem()),\n      ),\n  };\n\n  return blindCast<\n    TableHandle<Schema>,\n    'Column proxies are dynamically built from Schema keys — TypeScript cannot verify the per-key ColumnProxy constraint at the spread call site. Construction is correct by construction: every key maps to makeColumnProxy(source.name, key, schema[key]).'\n  >(handle);\n}\n\nfunction makeColumnProxy(\n  tableName: string,\n  columnName: string,\n  desc: ColumnDescriptor,\n): ColumnProxy {\n  const ref = ColumnRef.of(tableName, columnName);\n  return {\n    codecId: desc.codecId,\n    nullable: desc.nullable,\n    columnName,\n    tableName,\n    eq: (value) =>\n      value === null\n        ? new CfExpr(NullCheckExpr.isNull(ref))\n        : new CfExpr(BinaryExpr.eq(ref, toSetExpression(value, desc))),\n    neq: (value) =>\n      value === null\n        ? new CfExpr(NullCheckExpr.isNotNull(ref))\n        : new CfExpr(BinaryExpr.neq(ref, toSetExpression(value, desc))),\n    isNull: () => new CfExpr(NullCheckExpr.isNull(ref)),\n    isNotNull: () => new CfExpr(NullCheckExpr.isNotNull(ref)),\n    toRef: () => ref,\n    toProjectionItem: (alias = columnName) =>\n      ProjectionItem.of(alias, ref, { codecId: desc.codecId }),\n  };\n}\n\nfunction buildExcludedProxy<Schema extends ColumnSchema>(schema: Schema): ExcludedProxy<Schema> {\n  return blindCast<\n    ExcludedProxy<Schema>,\n    'Object.fromEntries cannot preserve per-key ColumnRef types — correct by construction: every key maps to ColumnRef.of(\"excluded\", key).'\n  >(Object.fromEntries(Object.keys(schema).map((col) => [col, ColumnRef.of('excluded', col)])));\n}\n\nfunction isExpressionSource(value: unknown): value is { toExpr(): AnyExpression } {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'toExpr' in value &&\n    typeof value.toExpr === 'function'\n  );\n}\n\nfunction toInsertValue(value: unknown, desc: ColumnDescriptor): InsertValue {\n  if (isExpressionSource(value)) {\n    const expr = value.toExpr();\n    if (\n      expr.kind === 'column-ref' ||\n      expr.kind === 'param-ref' ||\n      expr.kind === 'prepared-param-ref' ||\n      expr.kind === 'raw-expr'\n    ) {\n      return expr;\n    }\n  }\n  return ParamRef.of(value, { codec: { codecId: desc.codecId } });\n}\n\nfunction toSetExpression(value: unknown, desc: ColumnDescriptor): AnyExpression {\n  if (isExpressionSource(value)) {\n    return value.toExpr();\n  }\n  return ParamRef.of(value, { codec: { codecId: desc.codecId } });\n}\n\nfunction buildInsertRow<Schema extends ColumnSchema>(\n  schema: Schema,\n  values: TableInsertRow<Schema>,\n): Record<string, InsertValue> {\n  const row: Record<string, InsertValue> = {};\n  const rawValues = blindCast<\n    Record<string, unknown>,\n    'TableInsertRow<Schema> maps Schema keys to unknown; indexing by the same string keys is correct by construction'\n  >(values);\n  for (const [col, desc] of Object.entries(schema)) {\n    row[col] = toInsertValue(rawValues[col], desc);\n  }\n  return row;\n}\n\nfunction buildSetMap<Schema extends ColumnSchema>(\n  schema: Schema,\n  values: TableSetValues<Schema> | undefined,\n): Record<string, AnyExpression> {\n  if (values === undefined) return {};\n  const set: Record<string, AnyExpression> = {};\n  const rawSchema = blindCast<\n    Record<string, ColumnDescriptor>,\n    'Schema extends ColumnSchema = Record<string, ColumnDescriptor>; runtime key access is correct by construction'\n  >(schema);\n  const rawValues = blindCast<\n    Record<string, unknown>,\n    'TableSetValues<Schema> maps Schema keys to unknown; iterating with Object.entries is correct by construction'\n  >(values);\n  for (const [col, value] of Object.entries(rawValues)) {\n    const desc = rawSchema[col];\n    if (desc !== undefined) {\n      set[col] = toSetExpression(value, desc);\n    }\n  }\n  return set;\n}\n"],"mappings":";;;;AAkBA,SAAgB,IAAI,OAA6D;CAC/E,OAAO,IAAI,qBAAqB,KAAK;AACvC;AAEA,SAAgB,GAAG,YAA2C;CAC5D,OAAO,IAAI,sBAAsB,UAAU;AAC7C;AAEA,SAAgB,IAAI,MAAc,MAAc,SAAuC;CACrF,OAAO,IAAI,UAAU;EAAE;EAAM;EAAM,GAAG;CAAQ,CAAC;AACjD;AAEA,SAAgB,WACd,SACA,SACsB;CACtB,OAAO,IAAI,qBAAqB;EAAE;EAAS,GAAG;CAAQ,CAAC;AACzD;AAEA,SAAgB,WACd,SACA,UACA,YACA,SAKsB;CACtB,OAAO,IAAI,qBAAqB;EAAE;EAAS;EAAU;EAAY,GAAG;CAAQ,CAAC;AAC/E;AAEA,SAAgB,OACd,SACA,SACkB;CAClB,OAAO,IAAI,iBAAiB;EAAE;EAAS,GAAG;CAAQ,CAAC;AACrD;;;;;;;;ACxBA,IAAa,SAAb,MAAa,OAAO;CACG;CAArB,YAAY,KAA6B;EAApB,KAAA,MAAA;CAAqB;CAE1C,IAAI,OAAuB;EACzB,OAAO,IAAI,OAAO,QAAQ,GAAG,CAAC,KAAK,KAAK,MAAM,GAAG,CAAC,CAAC;CACrD;CAEA,GAAG,OAAuB;EACxB,OAAO,IAAI,OAAO,OAAO,GAAG,CAAC,KAAK,KAAK,MAAM,GAAG,CAAC,CAAC;CACpD;CAEA,MAAc;EACZ,OAAO,IAAI,OAAO,KAAK,IAAI,IAAI,CAAC;CAClC;AACF;AAqDA,IAAa,gBAAb,MAAa,cAA2C;CAEnC;CACA;CACA;CACA;CAJnB,YACE,KACA,QACA,WACA,iBAA6E,KAAA,GAC7E;EAJiB,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,YAAA;EACA,KAAA,iBAAA;CAChB;CAEH,UAAU,GAAG,SAA4D;EACvE,OAAO,IAAI,cACT,KAAK,KACL,KAAK,QACL,KAAK,WACL,QAAQ,KAAK,QAAQ,IAAI,iBAAiB,CAAC,CAC7C;CACF;CAEA,QAAmB;EACjB,MAAM,MAAM,eAAe,KAAK,QAAQ,KAAK,SAAS;EACtD,MAAM,MAAM,UAAU,KAAK,KAAK,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC;EACnD,OAAO,KAAK,iBAAiB,IAAI,cAAc,KAAK,cAAc,IAAI;CACxE;AACF;AAEA,IAAa,kBAAb,MAA0D;CAErC;CACA;CACA;CAHnB,YACE,KACA,QACA,WACA;EAHiB,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,YAAA;CAChB;CAEH,WAAW,GAAG,SAA+D;EAC3E,OAAO,IAAI,iBAAiB,KAAK,KAAK,KAAK,QAAQ,KAAK,WAAW,CAAC,GAAG,OAAO,CAAC;CACjF;AACF;AAEA,IAAa,mBAAb,MAA2D;CAEtC;CACA;CACA;CACA;CAJnB,YACE,KACA,QACA,WACA,cACA;EAJiB,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,YAAA;EACA,KAAA,eAAA;CAChB;CAEH,SACE,eAGuB;EACvB,MAAM,MACJ,OAAO,kBAAkB,aACrB,cAAc,mBAAmB,KAAK,MAAM,CAAC,IAC7C;EACN,OAAO,IAAI,cAAc,KAAK,KAAK,KAAK,QAAQ,KAAK,WAAW,KAAK,cAAc,GAAG;CACxF;CAEA,YAAmC;EACjC,OAAO,IAAI,cAAc,KAAK,KAAK,KAAK,QAAQ,KAAK,WAAW,KAAK,cAAc,KAAA,CAAS;CAC9F;AACF;AAEA,IAAa,gBAAb,MAAwD;CAEnC;CACA;CACA;CACA;CACA;CALnB,YACE,KACA,QACA,WACA,cACA,WACA;EALiB,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,YAAA;EACA,KAAA,eAAA;EACA,KAAA,YAAA;CAChB;CAEH,QAAmB;EACjB,MAAM,MAAM,eAAe,KAAK,QAAQ,KAAK,SAAS;EACtD,MAAM,eAAe,KAAK,aAAa,KAAK,QAAQ,IAAI,MAAM,CAAC;EAC/D,MAAM,aACJ,KAAK,cAAc,KAAA,IACf,iBAAiB,GAAG,YAAY,CAAC,CAAC,UAAU,IAC5C,iBAAiB,GAAG,YAAY,CAAC,CAAC,YAAY,YAAY,KAAK,QAAQ,KAAK,SAAS,CAAC;EAC5F,OAAO,UAAU,KAAK,KAAK,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,UAAU;CAC3E;AACF;AAEA,IAAa,gBAAb,MAAa,cAA2C;CAEnC;CACA;CACA;CACA;CACA;CALnB,YACE,KACA,QACA,YAAiE,KAAA,GACjE,YAAiD,KAAA,GACjD,iBAA6E,KAAA,GAC7E;EALiB,KAAA,MAAA;EACA,KAAA,SAAA;EACA,KAAA,YAAA;EACA,KAAA,YAAA;EACA,KAAA,iBAAA;CAChB;CAEH,IAAI,QAAuD;EACzD,OAAO,IAAI,cAAc,KAAK,KAAK,KAAK,QAAQ,QAAQ,KAAK,WAAW,KAAK,cAAc;CAC7F;CAEA,MAAM,MAAqC;EACzC,OAAO,IAAI,cAAc,KAAK,KAAK,KAAK,QAAQ,KAAK,WAAW,MAAM,KAAK,cAAc;CAC3F;CAEA,UAAU,GAAG,SAA4D;EACvE,OAAO,IAAI,cACT,KAAK,KACL,KAAK,QACL,KAAK,WACL,KAAK,WACL,QAAQ,KAAK,QAAQ,IAAI,iBAAiB,CAAC,CAC7C;CACF;CAEA,QAAmB;EACjB,MAAM,MAAM,YAAY,KAAK,QAAQ,KAAK,SAAS;EACnD,MAAM,OAAO,UAAU,MAAM,KAAK,GAAG,CAAC,CAAC,QAAQ,GAAG;EAClD,MAAM,YAAY,KAAK,YAAY,KAAK,UAAU,KAAK,UAAU,GAAG,IAAI;EACxE,OAAO,KAAK,iBAAiB,UAAU,cAAc,KAAK,cAAc,IAAI;CAC9E;AACF;AAEA,IAAa,gBAAb,MAAa,cAAc;CAEN;CACA;CACA;CACA;CAJnB,YACE,KACA,iBACA,YAAiD,KAAA,GACjD,eAA4D,CAAC,GAC7D;EAJiB,KAAA,MAAA;EACA,KAAA,kBAAA;EACA,KAAA,YAAA;EACA,KAAA,eAAA;CAChB;CAEH,MAAM,MAA6B;EACjC,OAAO,IAAI,cAAc,KAAK,KAAK,KAAK,iBAAiB,MAAM,KAAK,YAAY;CAClF;CAEA,QAAQ,QAAqB,MAAsB,OAAsB;EACvE,MAAM,OAAO,QAAQ,QAAQ,YAAY,IAAI,OAAO,MAAM,CAAC,IAAI,YAAY,KAAK,OAAO,MAAM,CAAC;EAC9F,OAAO,IAAI,cAAc,KAAK,KAAK,KAAK,iBAAiB,KAAK,WAAW,CACvE,GAAG,KAAK,cACR,IACF,CAAC;CACH;CAEA,QAAmB;EACjB,MAAM,OAAO,UAAU,KAAK,KAAK,GAAG,CAAC,CAAC,eAAe,KAAK,eAAe;EACzE,MAAM,YAAY,KAAK,YAAY,KAAK,UAAU,KAAK,UAAU,GAAG,IAAI;EACxE,OAAO,KAAK,aAAa,SAAS,IAAI,UAAU,YAAY,KAAK,YAAY,IAAI;CACnF;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,MACd,QACA,QACqB;CACrB,MAAM,UAAuC,CAAC;CAC9C,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,MAAM,GAC7C,QAAQ,OAAO,gBAAgB,OAAO,SAAS,OAAO,MAAM,KAAK,IAAI;CAgBvE,OAAO,UAGL;EAfA,GAAG;EACH;EACA,SAAS,QAAgC,IAAI,cAAc,QAAQ,QAAQ,GAAG;EAC9E,SAAS,QAAgC,IAAI,gBAAgB,QAAQ,QAAQ,GAAG;EAChF,cAAc,IAAI,cAAc,QAAQ,MAAM;EAC9C,SAAS,GAAG,SACV,IAAI,cACF,QACA,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,CAC1C;CAMG,CAAC;AACV;AAEA,SAAS,gBACP,WACA,YACA,MACa;CACb,MAAM,MAAM,UAAU,GAAG,WAAW,UAAU;CAC9C,OAAO;EACL,SAAS,KAAK;EACd,UAAU,KAAK;EACf;EACA;EACA,KAAK,UACH,UAAU,OACN,IAAI,OAAO,cAAc,OAAO,GAAG,CAAC,IACpC,IAAI,OAAO,WAAW,GAAG,KAAK,gBAAgB,OAAO,IAAI,CAAC,CAAC;EACjE,MAAM,UACJ,UAAU,OACN,IAAI,OAAO,cAAc,UAAU,GAAG,CAAC,IACvC,IAAI,OAAO,WAAW,IAAI,KAAK,gBAAgB,OAAO,IAAI,CAAC,CAAC;EAClE,cAAc,IAAI,OAAO,cAAc,OAAO,GAAG,CAAC;EAClD,iBAAiB,IAAI,OAAO,cAAc,UAAU,GAAG,CAAC;EACxD,aAAa;EACb,mBAAmB,QAAQ,eACzB,eAAe,GAAG,OAAO,KAAK,EAAE,SAAS,KAAK,QAAQ,CAAC;CAC3D;AACF;AAEA,SAAS,mBAAgD,QAAuC;CAC9F,OAAO,UAGL,OAAO,YAAY,OAAO,KAAK,MAAM,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,UAAU,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;AAC9F;AAEA,SAAS,mBAAmB,OAAsD;CAChF,OACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAO,MAAM,WAAW;AAE5B;AAEA,SAAS,cAAc,OAAgB,MAAqC;CAC1E,IAAI,mBAAmB,KAAK,GAAG;EAC7B,MAAM,OAAO,MAAM,OAAO;EAC1B,IACE,KAAK,SAAS,gBACd,KAAK,SAAS,eACd,KAAK,SAAS,wBACd,KAAK,SAAS,YAEd,OAAO;CAEX;CACA,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;AAChE;AAEA,SAAS,gBAAgB,OAAgB,MAAuC;CAC9E,IAAI,mBAAmB,KAAK,GAC1B,OAAO,MAAM,OAAO;CAEtB,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;AAChE;AAEA,SAAS,eACP,QACA,QAC6B;CAC7B,MAAM,MAAmC,CAAC;CAC1C,MAAM,YAAY,UAGhB,MAAM;CACR,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,MAAM,GAC7C,IAAI,OAAO,cAAc,UAAU,MAAM,IAAI;CAE/C,OAAO;AACT;AAEA,SAAS,YACP,QACA,QAC+B;CAC/B,IAAI,WAAW,KAAA,GAAW,OAAO,CAAC;CAClC,MAAM,MAAqC,CAAC;CAC5C,MAAM,YAAY,UAGhB,MAAM;CACR,MAAM,YAAY,UAGhB,MAAM;CACR,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,GAAG;EACpD,MAAM,OAAO,UAAU;EACvB,IAAI,SAAS,KAAA,GACX,IAAI,OAAO,gBAAgB,OAAO,IAAI;CAE1C;CACA,OAAO;AACT"}