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

package/dist/serialized-index-Dp5_EjXD-DMsw8jf3.mjs

@@ -0,0 +1,64 @@
+import { d as parseNaming } from "./naming-BwqqVcZy-BgTObIQw.mjs";
+import { o as SqlNode } from "./storage-table-_LWDmPfv-DFhU2dML.mjs";
+import { freezeNode } from "@prisma/orm-framework/components/ir";
+import { ContractValidationError } from "@prisma/orm-framework/contract/contract-validation-error";
+//#region ../../../2-sql/1-core/contract/dist/serialized-index-Dp5_EjXD.mjs
+/**
+* SQL Contract IR node for a value-set entry in a namespace's `valueSet`
+* map (`SqlNamespace.entries.valueSet`).
+*
+* A value-set records the ordered set of permitted codec-encoded values for
+* an enum-like column restriction. It does not carry a `codecId` — the
+* column that references it already holds the codec; the value-set holds
+* only the permitted values.
+*
+* The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope
+* carries the discriminator and the serializer hydration walker can
+* dispatch on it. This follows the per-leaf enumerable-kind convention
+* established in the SQL-node comment (future polymorphic dispatch on
+* namespace entries needs the discriminator in JSON).
+*
+* The entry's name is not on the class — value-sets are keyed by name in
+* the parent namespace's `valueSet: Record<string, StorageValueSet>` map.
+*/
+var StorageValueSet = class extends SqlNode {
+	kind = "valueSet";
+	values;
+	constructor(input) {
+		super();
+		this.values = Object.freeze([...input.values]);
+		freezeNode(this);
+	}
+};
+function isStorageValueSet(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "kind" in value && value.kind === "valueSet" && "values" in value;
+}
+/**
+* Hydrates one stored index into constructor input. The parameter is typed
+* but the values are whatever the file held, so each field the union depends
+* on is checked here rather than downstream — by the time `Index` sees the
+* data it is already a valid union.
+*/
+function indexInputFromSerialized(flat) {
+	if (flat.name === void 0 || flat.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 (flat.columns === void 0 === (flat.expression === void 0)) throw new ContractValidationError(`Index "${flat.name}": exactly one of columns or expression must be set.`, "storage");
+	const carried = {
+		naming: parseNaming(flat.name, flat.prefix),
+		where: flat.where,
+		unique: flat.unique,
+		type: flat.type,
+		options: flat.options
+	};
+	return flat.expression !== void 0 ? {
+		...carried,
+		expression: flat.expression
+	} : {
+		...carried,
+		columns: flat.columns ?? []
+	};
+}
+//#endregion
+export { indexInputFromSerialized as n, isStorageValueSet as r, StorageValueSet as t };
+
+//# sourceMappingURL=serialized-index-Dp5_EjXD-DMsw8jf3.mjs.map

package/dist/serialized-index-Dp5_EjXD-DMsw8jf3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized-index-Dp5_EjXD-DMsw8jf3.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/serialized-index-Dp5_EjXD.mjs"],"sourcesContent":["import { l as SqlNode } from \"./storage-table-_LWDmPfv.mjs\";\nimport { freezeNode } from \"@internal/framework-components/ir\";\nimport { ContractValidationError } from \"@internal/contract/contract-validation-error\";\nimport { parseNaming } from \"@internal/sql-schema-ir/naming\";\n//#region src/ir/storage-value-set.ts\n/**\n* SQL Contract IR node for a value-set entry in a namespace's `valueSet`\n* map (`SqlNamespace.entries.valueSet`).\n*\n* A value-set records the ordered set of permitted codec-encoded values for\n* an enum-like column restriction. It does not carry a `codecId` — the\n* column that references it already holds the codec; the value-set holds\n* only the permitted values.\n*\n* The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope\n* carries the discriminator and the serializer hydration walker can\n* dispatch on it. This follows the per-leaf enumerable-kind convention\n* established in the SQL-node comment (future polymorphic dispatch on\n* namespace entries needs the discriminator in JSON).\n*\n* The entry's name is not on the class — value-sets are keyed by name in\n* the parent namespace's `valueSet: Record<string, StorageValueSet>` map.\n*/\nvar StorageValueSet = class extends SqlNode {\n\tkind = \"valueSet\";\n\tvalues;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.values = Object.freeze([...input.values]);\n\t\tfreezeNode(this);\n\t}\n};\nfunction isStorageValueSet(value) {\n\tif (typeof value !== \"object\" || value === null) return false;\n\treturn \"kind\" in value && value.kind === \"valueSet\" && \"values\" in value;\n}\n//#endregion\n//#region src/serialized-index.ts\n/**\n* Hydrates one stored index into constructor input. The parameter is typed\n* but the values are whatever the file held, so each field the union depends\n* on is checked here rather than downstream — by the time `Index` sees the\n* data it is already a valid union.\n*/\nfunction indexInputFromSerialized(flat) {\n\tif (flat.name === void 0 || flat.name.length === 0) throw new ContractValidationError(\"Index: every index carries a full physical name; an expression index must be explicitly named (a default name cannot be derived from an expression).\", \"storage\");\n\tif (flat.columns === void 0 === (flat.expression === void 0)) throw new ContractValidationError(`Index \"${flat.name}\": exactly one of columns or expression must be set.`, \"storage\");\n\tconst carried = {\n\t\tnaming: parseNaming(flat.name, flat.prefix),\n\t\twhere: flat.where,\n\t\tunique: flat.unique,\n\t\ttype: flat.type,\n\t\toptions: flat.options\n\t};\n\treturn flat.expression !== void 0 ? {\n\t\t...carried,\n\t\texpression: flat.expression\n\t} : {\n\t\t...carried,\n\t\tcolumns: flat.columns ?? []\n\t};\n}\n//#endregion\nexport { StorageValueSet as n, isStorageValueSet as r, indexInputFromSerialized as t };\n\n//# sourceMappingURL=serialized-index-Dp5_EjXD.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAI,kBAAkB,cAAc,QAAQ;CAC3C,OAAO;CACP;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC;EAC7C,WAAW,IAAI;CAChB;AACD;AACA,SAAS,kBAAkB,OAAO;CACjC,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,OAAO,UAAU,SAAS,MAAM,SAAS,cAAc,YAAY;AACpE;;;;;;;AASA,SAAS,yBAAyB,MAAM;CACvC,IAAI,KAAK,SAAS,KAAK,KAAK,KAAK,KAAK,WAAW,GAAG,MAAM,IAAI,wBAAwB,wJAAwJ,SAAS;CACvP,IAAI,KAAK,YAAY,KAAK,OAAO,KAAK,eAAe,KAAK,IAAI,MAAM,IAAI,wBAAwB,UAAU,KAAK,KAAK,uDAAuD,SAAS;CACpL,MAAM,UAAU;EACf,QAAQ,YAAY,KAAK,MAAM,KAAK,MAAM;EAC1C,OAAO,KAAK;EACZ,QAAQ,KAAK;EACb,MAAM,KAAK;EACX,SAAS,KAAK;CACf;CACA,OAAO,KAAK,eAAe,KAAK,IAAI;EACnC,GAAG;EACH,YAAY,KAAK;CAClB,IAAI;EACH,GAAG;EACH,SAAS,KAAK,WAAW,CAAC;CAC3B;AACD"}

package/dist/sql-contract-serializer-2oBWuxTe-B9hzBBv1.mjs

@@ -0,0 +1,171 @@
+import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-DfIc_lOO.mjs";
+import { f as composeSqlEntityKinds } from "./entity-kinds-DKxwKolf-CcsY-iYV.mjs";
+import { a as SqlStorage, s as isMaterializedSqlNamespace } from "./types-CMMQS6aG.mjs";
+import { r as createSqlContractSchema, s as validateSqlContractFully } from "./validators-C4PItWnf.mjs";
+import { t as sqlFamilyError } from "./errors-B5g0xWro-mWH2C07F.mjs";
+import { hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
+import { ContractValidationError } from "@prisma/orm-framework/contract/contract-validation-error";
+import { type } from "arktype";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { isPlainRecord as isPlainRecord$1 } from "@prisma/orm-framework/contract/is-plain-record";
+//#region ../../../2-sql/9-family/dist/sql-contract-serializer-2oBWuxTe.mjs
+const NamespaceRawSchema = type({
+	id: "string",
+	"kind?": "string",
+	entries: type({ "+": "ignore" })
+});
+/**
+* SQL family `ContractSerializer` abstract base. Carries the SQL-shared
+* deserialization pipeline:
+*
+* 1. `parseSqlContractStructure` validates the on-disk JSON envelope
+*    against the SQL contract arktype schema (`validateSqlContractFully`)
+*    and returns the validated flat-data shape.
+* 2. `hydrateSqlStorage` walks the validated `storage` subtree and
+*    constructs the family-shared SQL Contract IR class hierarchy
+*    (`SqlStorage` -> `StorageTable` -> `StorageColumn` / `PrimaryKey`
+*    / …). The rest of the contract envelope is JSON-clean primitive
+*    data and passes through unchanged.
+* 3. `constructTargetContract` is the target-specific extension hook;
+*    defaults to identity. Targets that need to attach target-only
+*    fields (e.g. target-specific derived storage fields) override it.
+*
+* Default `serializeContract` is identity over the contract — concrete
+* SQL targets ship JSON-clean class instances, so the contract value
+* can be stringified directly. The non-enumerable family-level `kind`
+* discriminator on `SqlNode` instances stays out of the persisted
+* envelope automatically. Targets that need to canonicalize on the way
+* out (key ordering, dropping computed-only fields) override
+* `serializeContract` directly.
+*/
+var SqlContractSerializerBase = class {
+	entityHydrationRegistry;
+	contractSchema;
+	entryKinds;
+	constructor(entityHydrationRegistry = /* @__PURE__ */ new Map(), packEntityKinds = []) {
+		this.entityHydrationRegistry = entityHydrationRegistry;
+		this.entryKinds = composeSqlEntityKinds(packEntityKinds);
+		this.contractSchema = packEntityKinds.length > 0 ? createSqlContractSchema(this.entryKinds) : void 0;
+	}
+	deserializeContract(json) {
+		const validated = this.parseSqlContractStructure(json);
+		const hydrated = this.hydrateSqlStorage(validated);
+		return this.constructTargetContract(hydrated);
+	}
+	serializeContract(contract) {
+		return contract;
+	}
+	shouldPreserveEmpty = sqlContractCanonicalizationHooks.shouldPreserveEmpty;
+	sortStorage = sqlContractCanonicalizationHooks.sortStorage;
+	parseSqlContractStructure(json) {
+		return validateSqlContractFully(json, this.contractSchema !== void 0 ? { contractSchema: this.contractSchema } : void 0);
+	}
+	hydrateSqlStorage(validated) {
+		const types = validated.storage.types;
+		const hydratedTypes = types !== void 0 ? Object.fromEntries(Object.entries(types).map(([name, entry]) => [name, this.hydrateStorageTypeEntry(entry)])) : void 0;
+		const rawNamespaces = validated.storage.namespaces;
+		if (rawNamespaces === void 0) throw new ContractValidationError("Contract storage.namespaces is required after structural validation", "structural");
+		const hydratedNamespaces = this.hydrateSqlNamespaceMap(blindCast(rawNamespaces));
+		return {
+			...validated,
+			storage: new SqlStorage({
+				storageHash: validated.storage.storageHash,
+				...ifDefined("types", hydratedTypes),
+				namespaces: blindCast(hydratedNamespaces)
+			})
+		};
+	}
+	hydrateSqlNamespaceMap(namespaces) {
+		return Object.fromEntries(Object.entries(namespaces).map(([nsId, namespaceEntryRaw]) => {
+			const namespaceHydrated = this.hydrateSqlNamespaceEntry(nsId, namespaceEntryRaw);
+			if (!isMaterializedSqlNamespace(namespaceHydrated)) throw sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Target serializer bug: hydrateSqlNamespaceEntry for namespace "${nsId}" returned a non-NamespaceBase value. Override hydrateSqlNamespaceEntry to produce a target namespace concretion.`, {
+				why: "The target contract serializer hydrated a namespace into a value that is not a materialized namespace concretion.",
+				fix: "Fix the target package: its hydrateSqlNamespaceEntry override must return a target namespace concretion.",
+				meta: { namespaceId: nsId }
+			});
+			return [nsId, namespaceHydrated];
+		}));
+	}
+	hydrateSqlNamespaceEntry(nsId, raw) {
+		const id = typeof raw["id"] === "string" ? raw["id"] : nsId;
+		const parsed = NamespaceRawSchema({
+			...raw,
+			id
+		});
+		if (parsed instanceof type.errors) throw new ContractValidationError(`Namespace hydration failed: ${parsed.map((p) => p.message).join("; ")}`, "structural");
+		const entriesRaw = parsed.entries;
+		const rawEntriesMap = isPlainRecord$1(entriesRaw) ? entriesRaw : {};
+		const entriesInput = {};
+		for (const [key, innerMap] of Object.entries(rawEntriesMap)) entriesInput[key] = isPlainRecord$1(innerMap) ? innerMap : Object.freeze({});
+		const entriesOutput = hydrateNamespaceEntities(entriesInput, this.entryKinds, "fail", id);
+		if (!Object.hasOwn(entriesOutput, "table")) entriesOutput["table"] = {};
+		return blindCast({
+			id,
+			entries: entriesOutput
+		});
+	}
+	hydrateStorageTypeEntry(entry) {
+		if (typeof entry !== "object" || entry === null) return entry;
+		const kind = entry.kind;
+		if (typeof kind !== "string") return entry;
+		const factory = this.entityHydrationRegistry.get(kind);
+		if (factory === void 0) return entry;
+		return blindCast(factory(entry));
+	}
+	constructTargetContract(hydrated) {
+		return hydrated;
+	}
+	/**
+	* Serializes a namespace's `entries` dict by walking every enumerable
+	* kind — no kind is named here, mirroring the generic hydrate walk in
+	* `hydrateSqlNamespaceEntry` above. `table` is the SQL family's one
+	* universal base kind (every namespace carries it), so it is always
+	* emitted, even when empty; every other kind — target- or
+	* pack-contributed — is emitted only when it holds at least one entry.
+	* A kind carried non-enumerable on `entries` is excluded here for free,
+	* since `Object.entries` honors enumerability.
+	*/
+	serializeNamespaceEntries(entries) {
+		const out = { table: this.serializeEntries(entries["table"] ?? {}) };
+		for (const [kind, record] of Object.entries(entries)) {
+			if (kind === "table" || record == null || Object.keys(record).length === 0) continue;
+			out[kind] = this.serializeEntries(record);
+		}
+		return out;
+	}
+	serializeEntries(entries) {
+		const out = {};
+		for (const [name, entry] of Object.entries(entries)) out[name] = this.serializeJsonObject(entry);
+		return out;
+	}
+	serializeJsonObject(value) {
+		return blindCast(this.serializeJsonValue(value));
+	}
+	serializeJsonValue(value) {
+		return blindCast(JSON.parse(JSON.stringify(value)));
+	}
+};
+/**
+* Default SQL family `ContractSerializer` concretion. Inherits the
+* full SQL-shared deserialization pipeline (structural validation +
+* IR-class hydration) without pack-registered `storage.types`
+* hydration factories — targets that emit polymorphic JSON outside the
+* codec-typed envelope wire a target-specific subclass with a populated
+* registry (see Postgres). Family-level call sites instantiate this
+* default directly when no target serializer is supplied.
+*
+* Because this serializer has no target concretion, deserialization of
+* contracts that include namespace entries from JSON will throw unless
+* the caller provides pre-hydrated `NamespaceBase` instances. Production
+* paths always supply a target-specific serializer.
+*/
+var SqlContractSerializer = class extends SqlContractSerializerBase {
+	constructor() {
+		super(/* @__PURE__ */ new Map());
+	}
+};
+//#endregion
+export { SqlContractSerializerBase as n, SqlContractSerializer as t };
+
+//# sourceMappingURL=sql-contract-serializer-2oBWuxTe-B9hzBBv1.mjs.map

package/dist/sql-contract-serializer-2oBWuxTe-B9hzBBv1.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-contract-serializer-2oBWuxTe-B9hzBBv1.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/sql-contract-serializer-2oBWuxTe.mjs"],"sourcesContent":["import { t as sqlFamilyError } from \"./errors-B5g0xWro.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { hydrateNamespaceEntities } from \"@internal/framework-components/ir\";\nimport { sqlContractCanonicalizationHooks } from \"@internal/sql-contract/canonicalization-hooks\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { SqlStorage, isMaterializedSqlNamespace } from \"@internal/sql-contract/types\";\nimport { ContractValidationError } from \"@internal/contract/contract-validation-error\";\nimport { isPlainRecord as isPlainRecord$1 } from \"@internal/contract/is-plain-record\";\nimport { composeSqlEntityKinds } from \"@internal/sql-contract/entity-kinds\";\nimport { createSqlContractSchema, validateSqlContractFully } from \"@internal/sql-contract/validators\";\nimport { type } from \"arktype\";\n//#region src/core/ir/sql-contract-serializer-base.ts\nconst NamespaceRawSchema = type({\n\tid: \"string\",\n\t\"kind?\": \"string\",\n\tentries: type({ \"+\": \"ignore\" })\n});\n/**\n* SQL family `ContractSerializer` abstract base. Carries the SQL-shared\n* deserialization pipeline:\n*\n* 1. `parseSqlContractStructure` validates the on-disk JSON envelope\n*    against the SQL contract arktype schema (`validateSqlContractFully`)\n*    and returns the validated flat-data shape.\n* 2. `hydrateSqlStorage` walks the validated `storage` subtree and\n*    constructs the family-shared SQL Contract IR class hierarchy\n*    (`SqlStorage` -> `StorageTable` -> `StorageColumn` / `PrimaryKey`\n*    / …). The rest of the contract envelope is JSON-clean primitive\n*    data and passes through unchanged.\n* 3. `constructTargetContract` is the target-specific extension hook;\n*    defaults to identity. Targets that need to attach target-only\n*    fields (e.g. target-specific derived storage fields) override it.\n*\n* Default `serializeContract` is identity over the contract — concrete\n* SQL targets ship JSON-clean class instances, so the contract value\n* can be stringified directly. The non-enumerable family-level `kind`\n* discriminator on `SqlNode` instances stays out of the persisted\n* envelope automatically. Targets that need to canonicalize on the way\n* out (key ordering, dropping computed-only fields) override\n* `serializeContract` directly.\n*/\nvar SqlContractSerializerBase = class {\n\tentityHydrationRegistry;\n\tcontractSchema;\n\tentryKinds;\n\tconstructor(entityHydrationRegistry = /* @__PURE__ */ new Map(), packEntityKinds = []) {\n\t\tthis.entityHydrationRegistry = entityHydrationRegistry;\n\t\tthis.entryKinds = composeSqlEntityKinds(packEntityKinds);\n\t\tthis.contractSchema = packEntityKinds.length > 0 ? createSqlContractSchema(this.entryKinds) : void 0;\n\t}\n\tdeserializeContract(json) {\n\t\tconst validated = this.parseSqlContractStructure(json);\n\t\tconst hydrated = this.hydrateSqlStorage(validated);\n\t\treturn this.constructTargetContract(hydrated);\n\t}\n\tserializeContract(contract) {\n\t\treturn contract;\n\t}\n\tshouldPreserveEmpty = sqlContractCanonicalizationHooks.shouldPreserveEmpty;\n\tsortStorage = sqlContractCanonicalizationHooks.sortStorage;\n\tparseSqlContractStructure(json) {\n\t\treturn validateSqlContractFully(json, this.contractSchema !== void 0 ? { contractSchema: this.contractSchema } : void 0);\n\t}\n\thydrateSqlStorage(validated) {\n\t\tconst types = validated.storage.types;\n\t\tconst hydratedTypes = types !== void 0 ? Object.fromEntries(Object.entries(types).map(([name, entry]) => [name, this.hydrateStorageTypeEntry(entry)])) : void 0;\n\t\tconst rawNamespaces = validated.storage.namespaces;\n\t\tif (rawNamespaces === void 0) throw new ContractValidationError(\"Contract storage.namespaces is required after structural validation\", \"structural\");\n\t\tconst hydratedNamespaces = this.hydrateSqlNamespaceMap(blindCast(rawNamespaces));\n\t\treturn {\n\t\t\t...validated,\n\t\t\tstorage: new SqlStorage({\n\t\t\t\tstorageHash: validated.storage.storageHash,\n\t\t\t\t...ifDefined(\"types\", hydratedTypes),\n\t\t\t\tnamespaces: blindCast(hydratedNamespaces)\n\t\t\t})\n\t\t};\n\t}\n\thydrateSqlNamespaceMap(namespaces) {\n\t\treturn Object.fromEntries(Object.entries(namespaces).map(([nsId, namespaceEntryRaw]) => {\n\t\t\tconst namespaceHydrated = this.hydrateSqlNamespaceEntry(nsId, namespaceEntryRaw);\n\t\t\tif (!isMaterializedSqlNamespace(namespaceHydrated)) throw sqlFamilyError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Target serializer bug: hydrateSqlNamespaceEntry for namespace \"${nsId}\" returned a non-NamespaceBase value. Override hydrateSqlNamespaceEntry to produce a target namespace concretion.`, {\n\t\t\t\twhy: \"The target contract serializer hydrated a namespace into a value that is not a materialized namespace concretion.\",\n\t\t\t\tfix: \"Fix the target package: its hydrateSqlNamespaceEntry override must return a target namespace concretion.\",\n\t\t\t\tmeta: { namespaceId: nsId }\n\t\t\t});\n\t\t\treturn [nsId, namespaceHydrated];\n\t\t}));\n\t}\n\thydrateSqlNamespaceEntry(nsId, raw) {\n\t\tconst id = typeof raw[\"id\"] === \"string\" ? raw[\"id\"] : nsId;\n\t\tconst parsed = NamespaceRawSchema({\n\t\t\t...raw,\n\t\t\tid\n\t\t});\n\t\tif (parsed instanceof type.errors) throw new ContractValidationError(`Namespace hydration failed: ${parsed.map((p) => p.message).join(\"; \")}`, \"structural\");\n\t\tconst entriesRaw = parsed.entries;\n\t\tconst rawEntriesMap = isPlainRecord$1(entriesRaw) ? entriesRaw : {};\n\t\tconst entriesInput = {};\n\t\tfor (const [key, innerMap] of Object.entries(rawEntriesMap)) entriesInput[key] = isPlainRecord$1(innerMap) ? innerMap : Object.freeze({});\n\t\tconst entriesOutput = hydrateNamespaceEntities(entriesInput, this.entryKinds, \"fail\", id);\n\t\tif (!Object.hasOwn(entriesOutput, \"table\")) entriesOutput[\"table\"] = {};\n\t\treturn blindCast({\n\t\t\tid,\n\t\t\tentries: entriesOutput\n\t\t});\n\t}\n\thydrateStorageTypeEntry(entry) {\n\t\tif (typeof entry !== \"object\" || entry === null) return entry;\n\t\tconst kind = entry.kind;\n\t\tif (typeof kind !== \"string\") return entry;\n\t\tconst factory = this.entityHydrationRegistry.get(kind);\n\t\tif (factory === void 0) return entry;\n\t\treturn blindCast(factory(entry));\n\t}\n\tconstructTargetContract(hydrated) {\n\t\treturn hydrated;\n\t}\n\t/**\n\t* Serializes a namespace's `entries` dict by walking every enumerable\n\t* kind — no kind is named here, mirroring the generic hydrate walk in\n\t* `hydrateSqlNamespaceEntry` above. `table` is the SQL family's one\n\t* universal base kind (every namespace carries it), so it is always\n\t* emitted, even when empty; every other kind — target- or\n\t* pack-contributed — is emitted only when it holds at least one entry.\n\t* A kind carried non-enumerable on `entries` is excluded here for free,\n\t* since `Object.entries` honors enumerability.\n\t*/\n\tserializeNamespaceEntries(entries) {\n\t\tconst out = { table: this.serializeEntries(entries[\"table\"] ?? {}) };\n\t\tfor (const [kind, record] of Object.entries(entries)) {\n\t\t\tif (kind === \"table\" || record == null || Object.keys(record).length === 0) continue;\n\t\t\tout[kind] = this.serializeEntries(record);\n\t\t}\n\t\treturn out;\n\t}\n\tserializeEntries(entries) {\n\t\tconst out = {};\n\t\tfor (const [name, entry] of Object.entries(entries)) out[name] = this.serializeJsonObject(entry);\n\t\treturn out;\n\t}\n\tserializeJsonObject(value) {\n\t\treturn blindCast(this.serializeJsonValue(value));\n\t}\n\tserializeJsonValue(value) {\n\t\treturn blindCast(JSON.parse(JSON.stringify(value)));\n\t}\n};\n//#endregion\n//#region src/core/ir/sql-contract-serializer.ts\n/**\n* Default SQL family `ContractSerializer` concretion. Inherits the\n* full SQL-shared deserialization pipeline (structural validation +\n* IR-class hydration) without pack-registered `storage.types`\n* hydration factories — targets that emit polymorphic JSON outside the\n* codec-typed envelope wire a target-specific subclass with a populated\n* registry (see Postgres). Family-level call sites instantiate this\n* default directly when no target serializer is supplied.\n*\n* Because this serializer has no target concretion, deserialization of\n* contracts that include namespace entries from JSON will throw unless\n* the caller provides pre-hydrated `NamespaceBase` instances. Production\n* paths always supply a target-specific serializer.\n*/\nvar SqlContractSerializer = class extends SqlContractSerializerBase {\n\tconstructor() {\n\t\tsuper(/* @__PURE__ */ new Map());\n\t}\n};\n//#endregion\nexport { SqlContractSerializerBase as n, SqlContractSerializer as t };\n\n//# sourceMappingURL=sql-contract-serializer-2oBWuxTe.mjs.map"],"mappings":"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"}

package/dist/sql-execution-plan-CJmsCP7n-DoEpNn7r.d.mts

@@ -0,0 +1,32 @@
+import { p as AnyQueryAst } from "./types-DIBA80mc-wf5wLmON.mjs";
+import { ExecutionPlan } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql/4-lanes/relational-core/dist/sql-execution-plan-CJmsCP7n.d.mts
+//#region src/sql-execution-plan.d.ts
+/**
+ * SQL-domain execution plan: a query lowered to the wire-level shape that a
+ * SQL driver can run.
+ *
+ * The plan carries:
+ * - `sql` — the rendered SQL text
+ * - `params` — the bound parameter list
+ * - `ast` — the pre-lowering AST, retained for decoding / telemetry / middleware
+ * - `meta` — family-agnostic plan metadata (target, lane, hashes, ...)
+ * - `_row` — phantom row type, propagated from the originating `SqlQueryPlan`
+ *
+ * Extends the framework-level `ExecutionPlan<Row>` marker so generic SPIs
+ * (`RuntimeExecutor<SqlExecutionPlan>`, `RuntimeMiddleware<SqlExecutionPlan>`)
+ * can be parameterized over it.
+ *
+ * Co-located with `SqlQueryPlan` (its pre-lowering counterpart) in the lanes
+ * layer because lane-level utilities (`RawTemplateFactory`, `RawFactory`,
+ * `SqlPlan`) compose against the executable shape and the lanes layer cannot
+ * depend on the runtime layer.
+ */
+interface SqlExecutionPlan<Row = unknown> extends ExecutionPlan<Row> {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+  readonly ast: AnyQueryAst;
+}
+//#endregion
+export { SqlExecutionPlan as t };
+//# sourceMappingURL=sql-execution-plan-CJmsCP7n-DoEpNn7r.d.mts.map

package/dist/sql-execution-plan-CJmsCP7n-DoEpNn7r.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-execution-plan-CJmsCP7n-DoEpNn7r.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/sql-execution-plan-CJmsCP7n.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;UAuBU,iBAAiB,uBAAuB,cAAc;WACrD;WACA;WACA,KAAK"}

package/dist/sql-index-DsI8HAeK-BJsn-jvD.d.mts

@@ -0,0 +1,72 @@
+import { t as SqlNode } from "./sql-node-kEz6YFZo-v2F7delx.mjs";
+import { n as SqlObjectNaming } from "./naming-jLgdauLi-C84G_UHi.mjs";
+//#region ../../../2-sql/1-core/contract/dist/sql-index-DsI8HAeK.d.mts
+//#region src/ir/sql-index.d.ts
+/**
+ * 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.
+ */
+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;
+};
+/**
+ * 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.
+ */
+type IndexInput = IndexElements & {
+  /** The index's identity. Read back off a built node with `namingOf`. */
+  readonly naming: SqlObjectNaming;
+  /** 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
+ * wire-named (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`
+ * marks it exact (the name is adopted verbatim).
+ *
+ * `expression`, `where`, and `unique` are genuine SQL-family attributes —
+ * functional and partial indexes are standard SQL supported natively by
+ * Postgres and SQLite alike, and the family IR must be able to represent
+ * anything any SQL target can introspect. A target declining to AUTHOR them
+ * (SQLite's rejection at namespace construction) is a capability decision,
+ * not evidence of target-specificity.
+ *
+ * Note that this class shadows the global TypeScript `Index` lib type
+ * at the family-shared name; consumer files that need both should
+ * alias one (e.g.
+ * `import { Index as SqlIndexNode } from '@internal/sql-contract/types'`).
+ */
+declare class Index extends SqlNode {
+  readonly name: string;
+  readonly unique: boolean;
+  /** Derived from the wire naming arm — presence is the naming-mode discriminator in the flat JSON. */
+  readonly prefix?: string;
+  readonly columns?: readonly string[];
+  readonly expression?: string;
+  readonly where?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  constructor(input: IndexInput);
+}
+//#endregion
+export { IndexElements as n, IndexInput as r, Index as t };
+//# sourceMappingURL=sql-index-DsI8HAeK-BJsn-jvD.d.mts.map

package/dist/sql-index-DsI8HAeK-BJsn-jvD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-index-DsI8HAeK-BJsn-jvD.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/sql-index-DsI8HAeK.d.mts"],"mappings":";;;;;;;;;;;KAUK;;WAEM;WACA;;WAEA;;;;;WAKA;;;;;;;;KAQN,aAAa;;WAEP,QAAQ;;WAER;;WAEA;WACA;WACA,SAAS;;;;;;;;;;;;;;;;;;;;cAoBN,cAAc;WACjB;WACA;;WAEA;WACA;WACA;WACA;WACA;WACA,UAAU;EACnB,YAAY,OAAO"}

package/dist/sql-node-kEz6YFZo-v2F7delx.d.mts

@@ -0,0 +1,42 @@
+import { IRNodeBase } from "@prisma/orm-framework/components/ir";
+//#region ../../../2-sql/1-core/contract/dist/sql-node-kEz6YFZo.d.mts
+//#region src/ir/sql-node.d.ts
+/**
+ * SQL family IR node base. Carries the family-level `kind` discriminator
+ * `'sql'` and inherits the framework's `freezeNode` affordance.
+ *
+ * Single family-level discriminator (not per-leaf) reflects the fact that
+ * SQL IR has no polymorphic dispatch today — verifiers and serializers
+ * walk by structural position (`storage.tables[name].columns[name]`),
+ * not by inspecting `kind`. The abstract bar for per-leaf discriminators
+ * isn't earned until a future polymorphic consumer arrives.
+ *
+ * `kind` is installed as a non-enumerable own property on every instance,
+ * which keeps three things clean simultaneously:
+ *
+ * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+ *   shape (no `kind` field), so emitted contract.json files and the
+ *   `validateSqlContractFully` arktype schemas stay unchanged.
+ * - Test assertions that use `toEqual({...})` against the pre-lift flat
+ *   shape continue to pass — only enumerable own properties are
+ *   compared.
+ * - Direct access (`node.kind`) and runtime narrowing
+ *   (`if (node.kind === 'sql')`) still work, so future polymorphic
+ *   dispatch can begin reading `kind` without a runtime change.
+ *
+ * Future per-leaf overrides land cleanly: a class that gains a
+ * polymorphic-dispatch consumer (e.g. an enum type instance walked
+ * alongside other types) overrides `kind` with its narrower literal
+ * at that leaf level. Per-leaf overrides will use enumerable kind
+ * (matching the Mongo per-class-discriminator precedent) because they
+ * encode dispatch-relevant information that callers need to see in
+ * JSON envelopes; the family-level `'sql'` is uniform across all SQL
+ * IR and carries no dispatch-relevant information.
+ */
+declare abstract class SqlNode extends IRNodeBase {
+  readonly kind?: string;
+  constructor();
+}
+//#endregion
+export { SqlNode as t };
+//# sourceMappingURL=sql-node-kEz6YFZo-v2F7delx.d.mts.map

package/dist/sql-node-kEz6YFZo-v2F7delx.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-node-kEz6YFZo-v2F7delx.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/sql-node-kEz6YFZo.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAkCuB,gBAAgB;WAC5B;EACT"}

package/dist/sql-storage-B0QwiTg6-B8DVctJm.d.mts

@@ -0,0 +1,171 @@
+import { t as SqlNode } from "./sql-node-kEz6YFZo-v2F7delx.mjs";
+import { a as StorageTable } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { t as StorageValueSet } from "./storage-value-set-BGlj5Uus-CvZD--GG.mjs";
+import { Namespace, NamespaceBase, Storage, StorageType } from "@prisma/orm-framework/components/ir";
+import { StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { AuthoringContributions } from "@prisma/orm-framework/components/authoring";
+//#region ../../../2-sql/1-core/contract/dist/sql-storage-B0QwiTg6.d.mts
+//#region src/ir/storage-type-instance.d.ts
+/**
+ * Sentinel kind for the legacy codec-triple shape persisted under
+ * `SqlStorage.types`. Plain JSON-clean object literals carry this
+ * discriminator so the polymorphic slot dispatch can route them down
+ * the codec path while target-specific IR class instances (e.g. the
+ * Postgres enum class) keep their own narrower `kind` literal.
+ */
+declare const CODEC_INSTANCE_KIND: "codec-instance";
+/**
+ * Structural sub-interface of {@link StorageType} for codec-typed entries
+ * in `SqlStorage.types`. These are plain object literals — there is no
+ * runtime IR class, the JSON envelope round-trips through the slot
+ * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch
+ * key that distinguishes codec-typed entries from any class-instance
+ * kinds a target pack contributes to the polymorphic slot.
+ */
+interface StorageTypeInstance extends StorageType {
+  readonly kind: typeof CODEC_INSTANCE_KIND;
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+}
+/**
+ * Construction-time input for a codec-triple entry. Symmetric with the
+ * structural runtime shape minus the `kind` discriminator — callers may
+ * omit `kind`; the helper {@link toStorageTypeInstance} stamps it on.
+ * `typeParams` may be omitted on input; the constructor normalises a
+ * missing value to `{}` so the in-memory shape is always present.
+ */
+interface StorageTypeInstanceInput {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+}
+/**
+ * Stamp the codec-instance `kind` discriminator on a caller-supplied
+ * codec triple. Idempotent: input that already carries the discriminator
+ * passes through unchanged. Missing `typeParams` is normalised to `{}`.
+ */
+declare function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageTypeInstance;
+/**
+ * Type-guard for codec-typed entries on the polymorphic
+ * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
+ * any class-instance kinds a target pack contributes.
+ */
+declare function isStorageTypeInstance(value: unknown): value is StorageTypeInstance;
+//#endregion
+//#region src/ir/sql-storage.d.ts
+/**
+ * Polymorphic value type for document-scoped `SqlStorage.types` entries
+ * (codec aliases / parameterised native type registrations).
+ *
+ * Postgres native enum registrations live under the postgres-specific
+ * `entries.type` slot on `PostgresSchema` (target layer), not here.
+ */
+type SqlStorageTypeEntry = StorageTypeInstance | StorageTypeInstanceInput;
+interface SqlNamespaceInput {
+  readonly id: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+/**
+ * Target-supplied factory that materializes a `Namespace` from a SQL
+ * `SqlNamespaceInput` (used to populate `SqlStorage.namespaces`).
+ */
+type SqlNamespaceFactory = (input: SqlNamespaceInput) => Namespace;
+/**
+ * SQL-family extension of the framework `AuthoringContributions`. SQL target
+ * packs add a `createNamespace` factory so the PSL/TS authoring paths can
+ * materialize namespaces (and merge lowered extension-block entities) without
+ * each consumer re-specifying it. The factory is SQL-specific, so it lives here
+ * rather than on the framework `AuthoringContributions` base.
+ */
+interface SqlAuthoringContributions extends AuthoringContributions {
+  readonly createNamespace?: SqlNamespaceFactory;
+}
+/**
+ * Narrows framework `AuthoringContributions` to the SQL-family shape by testing
+ * for the SQL-specific `createNamespace` capability.
+ */
+declare function isSqlAuthoringContributions(authoring: AuthoringContributions | undefined): authoring is SqlAuthoringContributions;
+interface SqlStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly types?: Record<string, SqlStorageTypeEntry>;
+  readonly namespaces: Readonly<Record<string, SqlNamespaceBase>>;
+}
+/**
+ * SQL Contract IR root node for the `storage` field.
+ *
+ * Single concrete family-shared class — both Postgres and SQLite
+ * consume this class today. Per-target storage subclasses are
+ * introduced when each target's namespace shape earns its
+ * target-specific concretion (target-specific derived fields,
+ * target-specific storage extensions).
+ *
+ * Honours the framework `Storage` interface: every SQL IR carries a
+ * `namespaces` map keyed by namespace id. Callers must supply fully
+ * constructed `Namespace` instances — construction discipline lives
+ * in the authoring builders and deserializer hydration paths.
+ *
+ * The constructor normalises optional `types` into class instances.
+ * `types` is polymorphic per Decision 18 Option B: codec-triple inputs
+ * are stamped with `kind: 'codec-instance'`; hydration of raw JSON
+ * class-instance entries (carrying their narrower `kind` literal) is
+ * the per-target serializer's responsibility (so the family base does
+ * not import target-specific subclasses).
+ */
+/**
+ * The typed `entries` shape for SQL family namespaces. The open dictionary
+ * is intersected with optional known-kind maps so that `ns.entries.table`
+ * and `ns.entries.valueSet` resolve without a cast, while unknown pack-
+ * contributed kinds remain valid (the `Record` part allows any string key).
+ */
+type SqlNamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+  readonly table?: Readonly<Record<string, StorageTable>>;
+  readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
+};
+/**
+ * Structural interface for SQL family namespaces. Generated `.d.ts` contract
+ * types satisfy this structurally (no prototype methods). The runtime
+ * abstract class `SqlNamespaceBase` extends this.
+ *
+ * `qualifyTable` and `isUnbound` are optional so JSON-shaped contract types
+ * (which carry no methods) are accepted where `SqlNamespace` is required.
+ * Hydrated `SqlNamespaceBase` instances always have both.
+ */
+interface SqlNamespace {
+  readonly kind: string;
+  readonly id: string;
+  readonly entries: SqlNamespaceEntries;
+  readonly isUnbound?: boolean;
+  qualifyTable?(tableName: string): string;
+}
+/**
+ * Abstract SQL family namespace base class. Target concretions (`PostgresSchema`,
+ * `SqliteDatabase`, …) extend this — it is never instantiated directly.
+ * `entries` is the open ADR 224 dictionary: `entries[entityKind][entityName]`
+ * addresses any entity.
+ */
+declare abstract class SqlNamespaceBase extends NamespaceBase implements SqlNamespace {
+  abstract readonly id: string;
+  abstract readonly entries: SqlNamespaceEntries;
+  abstract qualifyTable(tableName: string): string;
+}
+/**
+ * Realm-safe guard for hydrated `SqlNamespaceBase` concretions. Checks
+ * `qualifyTable` structurally instead of `instanceof NamespaceBase`, so it
+ * survives duplicate-module boundaries (e.g. dist e2e where the target and
+ * the family carry separate copies of `@internal/framework-components`).
+ *
+ * Every concrete `SqlNamespaceBase` subclass (`PostgresSchema`, `SqliteDatabase`,
+ * `TestSqlNamespace`, …) implements `qualifyTable`. Raw `SqlNamespaceInput`
+ * objects (`{ id, entries }`) do not.
+ */
+declare function isMaterializedSqlNamespace(x: unknown): x is SqlNamespaceBase;
+declare class SqlStorage<THash extends string = string> extends SqlNode implements Storage {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, SqlNamespace>>;
+  readonly types?: Readonly<Record<string, StorageTypeInstance>>;
+  constructor(input: SqlStorageInput<THash>);
+}
+//#endregion
+export { SqlNamespaceEntries as a, SqlStorage as c, StorageTypeInstance as d, StorageTypeInstanceInput as f, toStorageTypeInstance as g, isStorageTypeInstance as h, SqlNamespaceBase as i, SqlStorageInput as l, isSqlAuthoringContributions as m, SqlAuthoringContributions as n, SqlNamespaceFactory as o, isMaterializedSqlNamespace as p, SqlNamespace as r, SqlNamespaceInput as s, CODEC_INSTANCE_KIND as t, SqlStorageTypeEntry as u };
+//# sourceMappingURL=sql-storage-B0QwiTg6-B8DVctJm.d.mts.map

package/dist/sql-storage-B0QwiTg6-B8DVctJm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-storage-B0QwiTg6-B8DVctJm.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/sql-storage-B0QwiTg6.d.mts"],"mappings":";;;;;;;;;;;;;;;cAcc;;;;;;;;;UASJ,4BAA4B;WAC3B,aAAa;WACb;WACA;WACA,YAAY;;;;;;;;;UASb;WACC;WACA;WACA,aAAa;;;;;;;iBAOP,sBAAsB,OAAO,2BAA2B;;;;;;iBAMxD,sBAAsB,iBAAiB,SAAS;;;;;;;;;;KAU5D,sBAAsB,sBAAsB;UACvC;WACC;WACA,SAAS,SAAS,eAAe,SAAS;;;;;;KAMhD,uBAAuB,OAAO,sBAAsB;;;;;;;;UAQ/C,kCAAkC;WACjC,kBAAkB;;;;;;iBAMZ,4BAA4B,WAAW,qCAAqC,aAAa;UAChG,gBAAgB;WACf,aAAa,gBAAgB;WAC7B,QAAQ,eAAe;WACvB,YAAY,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6B1C,sBAAsB,SAAS,eAAe,SAAS;WACjD,QAAQ,SAAS,eAAe;WAChC,WAAW,SAAS,eAAe;;;;;;;;;;;UAWpC;WACC;WACA;WACA,SAAS;WACT;EACT,cAAc;;;;;;;;uBAQO,yBAAyB,yBAAyB;oBACrD;oBACA,SAAS;WAClB,aAAa;;;;;;;;;;;;iBAYP,2BAA2B,aAAa,KAAK;cAChD,WAAW,uCAAuC,mBAAmB;WACxE,aAAa,gBAAgB;WAC7B,YAAY,SAAS,eAAe;WACpC,QAAQ,SAAS,eAAe;EACzC,YAAY,OAAO,gBAAgB"}