@prisma/orm-framework 0.16.0

package/dist/canonical-stringify-DY4NaAJi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-stringify-DY4NaAJi.mjs","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/canonical-stringify.mjs"],"sourcesContent":["//#region src/canonical-stringify.ts\n/**\n* Produces a deterministic, JSON-like string representation of a value.\n*\n* Designed for use as a stable identity / cache key. Two values that are\n* structurally equivalent — regardless of object key insertion order —\n* produce the same string. Two values that differ in any meaningful way\n* (including types that JSON would conflate, like `BigInt(1)` vs `1`)\n* produce different strings.\n*\n* Supported inputs:\n* - `null`, `undefined` (distinguishable: `null` → `\"null\"`, `undefined` → `\"undefined\"`)\n* - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)\n* - `bigint` (suffixed with `n` to disambiguate from `number`)\n* - `Date` (tagged + ISO string)\n* - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)\n* - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,\n*   `DataView`, etc. (tagged with the constructor name + hex-encoded over\n*   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes\n*   are read in host byte order, so callers that need cross-platform\n*   stability for multi-byte typed arrays should normalize endianness\n*   before passing the value in.\n* - Arrays (order-preserving)\n* - Plain objects (key-sorted) — only objects whose prototype is\n*   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,\n*   `RegExp`, class instances, etc.) are rejected so they cannot silently\n*   collapse to `{}` and collide with each other.\n*\n* Throws on `function`, `symbol`, circular references, non-plain objects,\n* and objects with symbol-keyed properties (which `Object.keys` would\n* silently drop). Callers that need to canonicalize any of these must\n* convert them to a supported representation first.\n*\n* The output format is intentionally not JSON: the type tags and BigInt\n* suffix mean it cannot be round-tripped via `JSON.parse`. The goal is\n* keying, not serialization.\n*\n* @example\n* ```typescript\n* canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })\n* // → true\n*\n* canonicalStringify(1n) !== canonicalStringify(1)\n* // → true\n* ```\n*/\nfunction canonicalStringify(value) {\n\treturn write(value, /* @__PURE__ */ new Set());\n}\nfunction write(value, seen) {\n\tif (value === null) return \"null\";\n\tif (value === void 0) return \"undefined\";\n\tswitch (typeof value) {\n\t\tcase \"boolean\": return value ? \"true\" : \"false\";\n\t\tcase \"number\": return writeNumber(value);\n\t\tcase \"bigint\": return `${value.toString()}n`;\n\t\tcase \"string\": return JSON.stringify(value);\n\t\tcase \"function\": throw new TypeError(\"canonicalStringify: functions are not supported\");\n\t\tcase \"symbol\": throw new TypeError(\"canonicalStringify: symbols are not supported\");\n\t}\n\tconst obj = value;\n\tif (value instanceof Date) return `Date(${value.toISOString()})`;\n\tif (value instanceof Uint8Array) return `Bytes(${bytesToHex(value)})`;\n\tif (ArrayBuffer.isView(value)) return `${value.constructor.name}(${bytesToHex(new Uint8Array(value.buffer, value.byteOffset, value.byteLength))})`;\n\tif (seen.has(obj)) throw new TypeError(\"canonicalStringify: circular reference detected\");\n\tseen.add(obj);\n\ttry {\n\t\tif (Array.isArray(value)) return `[${value.map((item) => write(item, seen)).join(\",\")}]`;\n\t\treturn writePlainObject(obj, seen);\n\t} finally {\n\t\tseen.delete(obj);\n\t}\n}\nfunction writeNumber(value) {\n\tif (Number.isNaN(value)) return \"NaN\";\n\tif (value === Number.POSITIVE_INFINITY) return \"Infinity\";\n\tif (value === Number.NEGATIVE_INFINITY) return \"-Infinity\";\n\tif (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return \"-0\";\n\treturn String(value);\n}\nfunction writePlainObject(obj, seen) {\n\tconst proto = Object.getPrototypeOf(obj);\n\tif (proto !== Object.prototype && proto !== null) {\n\t\tconst tag = proto?.constructor?.name ?? \"unknown\";\n\t\tthrow new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);\n\t}\n\tif (Object.getOwnPropertySymbols(obj).length > 0) throw new TypeError(\"canonicalStringify: objects with symbol-keyed properties are not supported\");\n\tconst keys = Object.keys(obj).sort();\n\tconst parts = [];\n\tfor (const key of keys) parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);\n\treturn `{${parts.join(\",\")}}`;\n}\nfunction bytesToHex(bytes) {\n\tlet out = \"\";\n\tfor (let i = 0; i < bytes.length; i++) {\n\t\tconst byte = bytes[i];\n\t\tout += byte.toString(16).padStart(2, \"0\");\n\t}\n\treturn out;\n}\n//#endregion\nexport { canonicalStringify };\n\n//# sourceMappingURL=canonical-stringify.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAS,mBAAmB,OAAO;CAClC,OAAO,MAAM,uBAAuB,IAAI,IAAI,CAAC;AAC9C;AACA,SAAS,MAAM,OAAO,MAAM;CAC3B,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,UAAU,KAAK,GAAG,OAAO;CAC7B,QAAQ,OAAO,OAAf;EACC,KAAK,WAAW,OAAO,QAAQ,SAAS;EACxC,KAAK,UAAU,OAAO,YAAY,KAAK;EACvC,KAAK,UAAU,OAAO,GAAG,MAAM,SAAS,EAAE;EAC1C,KAAK,UAAU,OAAO,KAAK,UAAU,KAAK;EAC1C,KAAK,YAAY,MAAM,IAAI,UAAU,iDAAiD;EACtF,KAAK,UAAU,MAAM,IAAI,UAAU,+CAA+C;CACnF;CACA,MAAM,MAAM;CACZ,IAAI,iBAAiB,MAAM,OAAO,QAAQ,MAAM,YAAY,EAAE;CAC9D,IAAI,iBAAiB,YAAY,OAAO,SAAS,WAAW,KAAK,EAAE;CACnE,IAAI,YAAY,OAAO,KAAK,GAAG,OAAO,GAAG,MAAM,YAAY,KAAK,GAAG,WAAW,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU,CAAC,EAAE;CAChJ,IAAI,KAAK,IAAI,GAAG,GAAG,MAAM,IAAI,UAAU,iDAAiD;CACxF,KAAK,IAAI,GAAG;CACZ,IAAI;EACH,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,IAAI,MAAM,KAAK,SAAS,MAAM,MAAM,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;EACtF,OAAO,iBAAiB,KAAK,IAAI;CAClC,UAAU;EACT,KAAK,OAAO,GAAG;CAChB;AACD;AACA,SAAS,YAAY,OAAO;CAC3B,IAAI,OAAO,MAAM,KAAK,GAAG,OAAO;CAChC,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAC/C,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAC/C,IAAI,UAAU,KAAK,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAClE,OAAO,OAAO,KAAK;AACpB;AACA,SAAS,iBAAiB,KAAK,MAAM;CACpC,MAAM,QAAQ,OAAO,eAAe,GAAG;CACvC,IAAI,UAAU,OAAO,aAAa,UAAU,MAAM;EACjD,MAAM,MAAM,OAAO,aAAa,QAAQ;EACxC,MAAM,IAAI,UAAU,gEAAgE,IAAI,EAAE;CAC3F;CACA,IAAI,OAAO,sBAAsB,GAAG,CAAC,CAAC,SAAS,GAAG,MAAM,IAAI,UAAU,4EAA4E;CAClJ,MAAM,OAAO,OAAO,KAAK,GAAG,CAAC,CAAC,KAAK;CACnC,MAAM,QAAQ,CAAC;CACf,KAAK,MAAM,OAAO,MAAM,MAAM,KAAK,GAAG,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,IAAI,MAAM,IAAI,GAAG;CACpF,OAAO,IAAI,MAAM,KAAK,GAAG,EAAE;AAC5B;AACA,SAAS,WAAW,OAAO;CAC1B,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACtC,MAAM,OAAO,MAAM;EACnB,OAAO,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CACzC;CACA,OAAO;AACR"}

package/dist/canonicalization-DFpB09nP-4OdB2nsy.d.mts

@@ -0,0 +1,69 @@
+import { t as Contract } from "./contract-types-CkdMH7F7-9EHXSwbH.mjs";
+import { n as JsonObject } from "./json-Dkqr3say.mjs";
+//#region ../../../1-framework/0-foundation/contract/dist/canonicalization-DFpB09nP.d.mts
+//#region src/canonicalization.d.ts
+/**
+ * Per-target contract serializer hook. The framework canonicalizer uses
+ * this to convert an in-memory contract (which may carry class-instance
+ * IR nodes whose runtime-only fields must not appear in the on-disk
+ * envelope) into a plain JsonObject before applying the family-agnostic
+ * canonical-key ordering / default-omission / sort steps. Targets whose
+ * contract is JSON-clean by construction return the contract unchanged.
+ */
+type SerializeContract = (contract: Contract) => JsonObject;
+/**
+ * Family-contributed predicate for the default-omission walk. Called when
+ * a value at `path` is a default (empty object/array or `false`); if this
+ * returns `true` the value is kept rather than stripped.
+ *
+ * The framework only calls the predicate inside the `isDefaultValue` branch,
+ * so there is no need to guard against non-default values.
+ */
+type PreserveEmptyPredicate = (path: readonly string[]) => boolean;
+/**
+ * Family-contributed storage sort. Applied to the serialized `storage`
+ * subtree after the default-omission walk; the result replaces the
+ * `storage` field before the final key sort. Use to establish a
+ * deterministic order for storage arrays (indexes, uniques) that the
+ * family-agnostic `sortObjectKeys` pass cannot handle.
+ */
+type StorageSort = (storage: unknown) => unknown;
+interface CanonicalizeContractOptions {
+  readonly schemaVersion?: string;
+  /**
+   * Per-target hook that converts the in-memory contract (which may
+   * carry class-instance IR nodes) into a plain JsonObject before the
+   * family-agnostic canonicalization steps run.
+   *
+   * Routing through the hook is what lets each target decide which
+   * fields appear in the on-disk envelope; runtime-only class API
+   * fields stay invisible to the canonicalization walk by virtue of
+   * the per-target serializer not putting them in the JSON shape.
+   */
+  readonly serializeContract: SerializeContract;
+  /**
+   * Family-contributed preserve-empty predicate. When the walk encounters a
+   * default value (empty object/array or `false`) at `path`, calling this
+   * with the full path allows the family to veto the omission. If absent,
+   * only the framework's family-agnostic required-slot rules apply.
+   */
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  /**
+   * Family-contributed storage sort. Applied to the serialized `storage`
+   * subtree after the default-omission walk, before the final key sort.
+   * SQL family uses this to impose a deterministic order on `indexes` and
+   * `uniques` arrays within each namespace table. Families that require no
+   * special storage ordering omit this hook.
+   */
+  readonly sortStorage?: StorageSort;
+}
+/**
+ * Object-form variant of {@link canonicalizeContract}. Exported because the
+ * emitter writes the canonical contract through a separate JSON-stringify
+ * pass and consumes the structured object directly.
+ */
+declare function canonicalizeContractToObject(contract: Contract, options: CanonicalizeContractOptions): Record<string, unknown>;
+declare function canonicalizeContract(contract: Contract, options: CanonicalizeContractOptions): string;
+//#endregion
+export { canonicalizeContract as a, StorageSort as i, PreserveEmptyPredicate as n, canonicalizeContractToObject as o, SerializeContract as r, CanonicalizeContractOptions as t };
+//# sourceMappingURL=canonicalization-DFpB09nP-4OdB2nsy.d.mts.map

package/dist/canonicalization-DFpB09nP-4OdB2nsy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalization-DFpB09nP-4OdB2nsy.d.mts","names":[],"sources":["../../../../1-framework/0-foundation/contract/dist/canonicalization-DFpB09nP.d.mts"],"mappings":";;;;;;;;;;;;KAWK,qBAAqB,UAAU,aAAa;;;;;;;;;KAS5C,0BAA0B;;;;;;;;KAQ1B,eAAe;UACV;WACC;;;;;;;;;;;WAWA,mBAAmB;;;;;;;WAOnB,sBAAsB;;;;;;;;WAQtB,cAAc;;;;;;;iBAOR,6BAA6B,UAAU,UAAU,SAAS,8BAA8B;iBACxF,qBAAqB,UAAU,UAAU,SAAS"}

package/dist/canonicalization-path-match-CNgHuwM_-CCPBeUuk.mjs

@@ -0,0 +1,25 @@
+//#region ../../../1-framework/0-foundation/contract/dist/canonicalization-path-match-CNgHuwM_.mjs
+function matchesPathPattern(path, pattern) {
+	if (path.length !== pattern.length) return false;
+	for (let i = 0; i < pattern.length; i++) {
+		const segment = pattern[i];
+		const value = path[i];
+		if (segment === void 0 || value === void 0) return false;
+		if (segment === "*") continue;
+		if (typeof segment === "string") {
+			if (value !== segment) return false;
+			continue;
+		}
+		if (Array.isArray(segment)) {
+			if (!segment.includes(value)) return false;
+		}
+	}
+	return true;
+}
+function createPreserveEmptyPredicate(patterns) {
+	return (path) => patterns.some((pattern) => matchesPathPattern(path, pattern));
+}
+//#endregion
+export { matchesPathPattern as n, createPreserveEmptyPredicate as t };
+
+//# sourceMappingURL=canonicalization-path-match-CNgHuwM_-CCPBeUuk.mjs.map

package/dist/canonicalization-path-match-CNgHuwM_-CCPBeUuk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalization-path-match-CNgHuwM_-CCPBeUuk.mjs","names":[],"sources":["../../../../1-framework/0-foundation/contract/dist/canonicalization-path-match-CNgHuwM_.mjs"],"sourcesContent":["//#region src/canonicalization-path-match.ts\nfunction matchesPathPattern(path, pattern) {\n\tif (path.length !== pattern.length) return false;\n\tfor (let i = 0; i < pattern.length; i++) {\n\t\tconst segment = pattern[i];\n\t\tconst value = path[i];\n\t\tif (segment === void 0 || value === void 0) return false;\n\t\tif (segment === \"*\") continue;\n\t\tif (typeof segment === \"string\") {\n\t\t\tif (value !== segment) return false;\n\t\t\tcontinue;\n\t\t}\n\t\tif (Array.isArray(segment)) {\n\t\t\tif (!segment.includes(value)) return false;\n\t\t}\n\t}\n\treturn true;\n}\nfunction createPreserveEmptyPredicate(patterns) {\n\treturn (path) => patterns.some((pattern) => matchesPathPattern(path, pattern));\n}\n//#endregion\nexport { matchesPathPattern as n, createPreserveEmptyPredicate as t };\n\n//# sourceMappingURL=canonicalization-path-match-CNgHuwM_.mjs.map"],"mappings":";AACA,SAAS,mBAAmB,MAAM,SAAS;CAC1C,IAAI,KAAK,WAAW,QAAQ,QAAQ,OAAO;CAC3C,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACxC,MAAM,UAAU,QAAQ;EACxB,MAAM,QAAQ,KAAK;EACnB,IAAI,YAAY,KAAK,KAAK,UAAU,KAAK,GAAG,OAAO;EACnD,IAAI,YAAY,KAAK;EACrB,IAAI,OAAO,YAAY,UAAU;GAChC,IAAI,UAAU,SAAS,OAAO;GAC9B;EACD;EACA,IAAI,MAAM,QAAQ,OAAO,GACpB;OAAA,CAAC,QAAQ,SAAS,KAAK,GAAG,OAAO;EAAA;CAEvC;CACA,OAAO;AACR;AACA,SAAS,6BAA6B,UAAU;CAC/C,QAAQ,SAAS,SAAS,MAAM,YAAY,mBAAmB,MAAM,OAAO,CAAC;AAC9E"}

package/dist/capabilities-CPj7MfXO-GRkp0Q_D.mjs

@@ -0,0 +1,64 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/capabilities-CPj7MfXO.mjs
+/**
+* Capability matrix merge primitive shared by emit-time and runtime stack composition.
+*
+* The CLI's `enrichContract` and the SQL runtime's `createExecutionContext` both need
+* to fold a stack of component descriptors' `capabilities` declarations into a single
+* matrix keyed by namespace. Keeping the primitive here lets both call sites stay
+* byte-for-byte consistent without one depending on the other.
+*/
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortDeep(value) {
+	if (Array.isArray(value)) return value.map(sortDeep);
+	if (!isPlainObject(value)) return value;
+	const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+	const next = {};
+	for (const [key, child] of entries) next[key] = sortDeep(child);
+	return next;
+}
+function extractCapabilityMatrix(value) {
+	if (!isPlainObject(value)) return {};
+	const out = {};
+	for (const [namespace, maybeCaps] of Object.entries(value)) {
+		if (!isPlainObject(maybeCaps)) continue;
+		const caps = {};
+		for (const [key, flag] of Object.entries(maybeCaps)) if (typeof flag === "boolean") caps[key] = flag;
+		if (Object.keys(caps).length > 0) out[namespace] = caps;
+	}
+	return out;
+}
+/**
+* Merge an ordered list of contributor capability declarations into a base matrix.
+*
+* Behaviour:
+* - `base` and each contributor's `capabilities` are filtered through the same
+*   structural extraction: non-plain-object namespace blocks are dropped,
+*   non-boolean leaves inside a namespace block are dropped, and a namespace
+*   block that ends up with zero boolean leaves is omitted entirely (so a
+*   later contributor with a malformed namespace cannot erase a namespace
+*   already present in `base`).
+* - Non-plain-object `capabilities` on a contributor (including `undefined`,
+*   `null`, arrays, primitives) are skipped silently — the contributor
+*   contributes nothing.
+* - Later contributors win on `(namespace, key)` collisions.
+* - The returned object is fresh — neither `base` nor any contributor is mutated.
+* - Output keys are sorted lexicographically at every plain-object level.
+*/
+function mergeCapabilityMatrices(base, contributors) {
+	const merged = extractCapabilityMatrix(base);
+	for (const contributor of contributors) {
+		const extracted = extractCapabilityMatrix(contributor.capabilities);
+		for (const [namespace, capabilities] of Object.entries(extracted)) merged[namespace] = {
+			...merged[namespace] ?? {},
+			...capabilities
+		};
+	}
+	return blindCast(sortDeep(merged));
+}
+//#endregion
+export { mergeCapabilityMatrices as t };
+
+//# sourceMappingURL=capabilities-CPj7MfXO-GRkp0Q_D.mjs.map

package/dist/capabilities-CPj7MfXO-GRkp0Q_D.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities-CPj7MfXO-GRkp0Q_D.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/capabilities-CPj7MfXO.mjs"],"sourcesContent":["import { blindCast } from \"@internal/utils/casts\";\n//#region src/shared/capabilities.ts\n/**\n* Capability matrix merge primitive shared by emit-time and runtime stack composition.\n*\n* The CLI's `enrichContract` and the SQL runtime's `createExecutionContext` both need\n* to fold a stack of component descriptors' `capabilities` declarations into a single\n* matrix keyed by namespace. Keeping the primitive here lets both call sites stay\n* byte-for-byte consistent without one depending on the other.\n*/\nfunction isPlainObject(value) {\n\treturn typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\nfunction sortDeep(value) {\n\tif (Array.isArray(value)) return value.map(sortDeep);\n\tif (!isPlainObject(value)) return value;\n\tconst entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));\n\tconst next = {};\n\tfor (const [key, child] of entries) next[key] = sortDeep(child);\n\treturn next;\n}\nfunction extractCapabilityMatrix(value) {\n\tif (!isPlainObject(value)) return {};\n\tconst out = {};\n\tfor (const [namespace, maybeCaps] of Object.entries(value)) {\n\t\tif (!isPlainObject(maybeCaps)) continue;\n\t\tconst caps = {};\n\t\tfor (const [key, flag] of Object.entries(maybeCaps)) if (typeof flag === \"boolean\") caps[key] = flag;\n\t\tif (Object.keys(caps).length > 0) out[namespace] = caps;\n\t}\n\treturn out;\n}\n/**\n* Merge an ordered list of contributor capability declarations into a base matrix.\n*\n* Behaviour:\n* - `base` and each contributor's `capabilities` are filtered through the same\n*   structural extraction: non-plain-object namespace blocks are dropped,\n*   non-boolean leaves inside a namespace block are dropped, and a namespace\n*   block that ends up with zero boolean leaves is omitted entirely (so a\n*   later contributor with a malformed namespace cannot erase a namespace\n*   already present in `base`).\n* - Non-plain-object `capabilities` on a contributor (including `undefined`,\n*   `null`, arrays, primitives) are skipped silently — the contributor\n*   contributes nothing.\n* - Later contributors win on `(namespace, key)` collisions.\n* - The returned object is fresh — neither `base` nor any contributor is mutated.\n* - Output keys are sorted lexicographically at every plain-object level.\n*/\nfunction mergeCapabilityMatrices(base, contributors) {\n\tconst merged = extractCapabilityMatrix(base);\n\tfor (const contributor of contributors) {\n\t\tconst extracted = extractCapabilityMatrix(contributor.capabilities);\n\t\tfor (const [namespace, capabilities] of Object.entries(extracted)) merged[namespace] = {\n\t\t\t...merged[namespace] ?? {},\n\t\t\t...capabilities\n\t\t};\n\t}\n\treturn blindCast(sortDeep(merged));\n}\n//#endregion\nexport { mergeCapabilityMatrices as t };\n\n//# sourceMappingURL=capabilities-CPj7MfXO.mjs.map"],"mappings":";;;;;;;;;;AAUA,SAAS,cAAc,OAAO;CAC7B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC3E;AACA,SAAS,SAAS,OAAO;CACxB,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,IAAI,QAAQ;CACnD,IAAI,CAAC,cAAc,KAAK,GAAG,OAAO;CAClC,MAAM,UAAU,OAAO,QAAQ,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;CAC3E,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,CAAC,KAAK,UAAU,SAAS,KAAK,OAAO,SAAS,KAAK;CAC9D,OAAO;AACR;AACA,SAAS,wBAAwB,OAAO;CACvC,IAAI,CAAC,cAAc,KAAK,GAAG,OAAO,CAAC;CACnC,MAAM,MAAM,CAAC;CACb,KAAK,MAAM,CAAC,WAAW,cAAc,OAAO,QAAQ,KAAK,GAAG;EAC3D,IAAI,CAAC,cAAc,SAAS,GAAG;EAC/B,MAAM,OAAO,CAAC;EACd,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,SAAS,GAAG,IAAI,OAAO,SAAS,WAAW,KAAK,OAAO;EAChG,IAAI,OAAO,KAAK,IAAI,CAAC,CAAC,SAAS,GAAG,IAAI,aAAa;CACpD;CACA,OAAO;AACR;;;;;;;;;;;;;;;;;;AAkBA,SAAS,wBAAwB,MAAM,cAAc;CACpD,MAAM,SAAS,wBAAwB,IAAI;CAC3C,KAAK,MAAM,eAAe,cAAc;EACvC,MAAM,YAAY,wBAAwB,YAAY,YAAY;EAClE,KAAK,MAAM,CAAC,WAAW,iBAAiB,OAAO,QAAQ,SAAS,GAAG,OAAO,aAAa;GACtF,GAAG,OAAO,cAAc,CAAC;GACzB,GAAG;EACJ;CACD;CACA,OAAO,UAAU,SAAS,MAAM,CAAC;AAClC"}

package/dist/capabilities-Cupq4-1--C71ORI3N.d.mts

@@ -0,0 +1,34 @@
+//#region ../../../1-framework/1-core/framework-components/dist/capabilities-Cupq4-1-.d.mts
+//#region src/shared/capabilities.d.ts
+/**
+ * Capability matrix merge primitive shared by emit-time and runtime stack composition.
+ *
+ * The CLI's `enrichContract` and the SQL runtime's `createExecutionContext` both need
+ * to fold a stack of component descriptors' `capabilities` declarations into a single
+ * matrix keyed by namespace. Keeping the primitive here lets both call sites stay
+ * byte-for-byte consistent without one depending on the other.
+ */
+type CapabilityMatrix = Record<string, Record<string, boolean>>;
+/**
+ * Merge an ordered list of contributor capability declarations into a base matrix.
+ *
+ * Behaviour:
+ * - `base` and each contributor's `capabilities` are filtered through the same
+ *   structural extraction: non-plain-object namespace blocks are dropped,
+ *   non-boolean leaves inside a namespace block are dropped, and a namespace
+ *   block that ends up with zero boolean leaves is omitted entirely (so a
+ *   later contributor with a malformed namespace cannot erase a namespace
+ *   already present in `base`).
+ * - Non-plain-object `capabilities` on a contributor (including `undefined`,
+ *   `null`, arrays, primitives) are skipped silently — the contributor
+ *   contributes nothing.
+ * - Later contributors win on `(namespace, key)` collisions.
+ * - The returned object is fresh — neither `base` nor any contributor is mutated.
+ * - Output keys are sorted lexicographically at every plain-object level.
+ */
+declare function mergeCapabilityMatrices(base: Record<string, Record<string, boolean>>, contributors: ReadonlyArray<{
+  readonly capabilities?: unknown;
+}>): Record<string, Record<string, boolean>>;
+//#endregion
+export { mergeCapabilityMatrices as n, CapabilityMatrix as t };
+//# sourceMappingURL=capabilities-Cupq4-1--C71ORI3N.d.mts.map

package/dist/capabilities-Cupq4-1--C71ORI3N.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities-Cupq4-1--C71ORI3N.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/capabilities-Cupq4-1-.d.mts"],"mappings":";;;;;;;;;;KASK,mBAAmB,eAAe;;;;;;;;;;;;;;;;;;iBAkBtB,wBAAwB,MAAM,eAAe,0BAA0B,cAAc;WAC3F;KACN,eAAe"}

package/dist/casts-D29CHGrr.d.mts

@@ -0,0 +1,78 @@
+//#region ../../../1-framework/0-foundation/utils/dist/casts.d.mts
+//#region src/casts.d.ts
+/**
+ * **Last-resort escape hatch for unsafe type assertions. Not a sanctioned tool to reach for.**
+ *
+ * Before reaching for `blindCast`, **rewrite the surrounding code so the cast becomes
+ * unnecessary**: tighten an input type, add a runtime check that narrows via a type
+ * predicate, restructure a generic so the compiler can see the relationship you're
+ * asserting, or use {@link castAs} when the value already satisfies the target type.
+ * Only when no rewrite is feasible does `blindCast` become the right answer — and at
+ * that point, the `Reason` literal you supply must articulate the compromise in
+ * language a reviewer can evaluate.
+ *
+ * The reviewer **will** validate the `Reason`. If it doesn't hold up under scrutiny,
+ * that is not a signal to soften the reason; it is a signal to go back and solve the
+ * underlying type-system problem properly. An unconvincing justification is rework,
+ * not a free pass.
+ *
+ * `blindCast` is the auditable form of `as Foo` / `as unknown as Foo`: it bypasses
+ * the compiler's checks (the input type is `unknown`, the output type is whatever the
+ * caller asks for), but it forces the unsafety to be named at the call site instead of
+ * smuggled in via a bare `as`. The `Reason` type parameter exists only at compile
+ * time — it is not present in the emitted JavaScript — but it is grep-able and
+ * visible to future readers.
+ *
+ * @example
+ * ```typescript
+ * const stringValue = blindCast<
+ *   string,
+ *   "JSON.parse returns `unknown`; this field is documented to be a string in the API contract"
+ * >(parsed[key]);
+ * ```
+ *
+ * @typeParam TargetType - The type the caller is asserting the input has.
+ * @typeParam _Reason - A string literal describing why bypassing the type system is necessary here.
+ *                     Only meaningful at compile time. The reviewer evaluates whether it justifies the unsafety.
+ */
+declare function blindCast<TargetType, _Reason extends string>(input: unknown): TargetType;
+/**
+ * Type-checked, runtime pass-through alternative to a bare `as Type` cast.
+ *
+ * Use `castAs` when the value already satisfies the target type but you want to make
+ * the type assertion explicit at the call site — for example, when an inferred type is
+ * wider than the type you want to publish, or when a literal object should be tagged
+ * with its nominal interface. Unlike {@link blindCast}, the compiler still checks that
+ * the value is assignable to the target type, so this helper cannot smuggle in an
+ * unsafe assertion.
+ *
+ * `castAs` exists alongside `blindCast` so authors pick the right name at the call
+ * site: a `castAs` is type-checked and benign; a `blindCast` is the unsafe escape
+ * hatch. The split makes review faster — readers know which casts to scrutinize and
+ * which are pure annotations.
+ *
+ * @example
+ * ```typescript
+ * interface FancyObject {
+ *   key: string;
+ *   keyTwo: {
+ *     subKey: string;
+ *     subKeyTwo: number;
+ *   };
+ * }
+ *
+ * const typedObject = castAs<FancyObject>({
+ *   key: 'Chookede',
+ *   keyTwo: {
+ *     subKey: 'Choookeeeee',
+ *     subKeyTwo: 2,
+ *   },
+ * });
+ * ```
+ *
+ * @typeParam Type - The type to constrain and tag the value with. The value must be assignable to `Type`.
+ */
+declare function castAs<Type>(value: Type): Type;
+//#endregion
+export { castAs as n, blindCast as t };
+//# sourceMappingURL=casts-D29CHGrr.d.mts.map

package/dist/casts-D29CHGrr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"casts-D29CHGrr.d.mts","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/casts.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCiB,UAAU,YAAY,wBAAwB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC/D,OAAO,MAAM,OAAO,OAAO"}

package/dist/casts-DpaahrlC-Bd5n2coI.mjs

@@ -0,0 +1,82 @@
+//#region ../../../1-framework/0-foundation/utils/dist/casts-DpaahrlC.mjs
+/**
+* **Last-resort escape hatch for unsafe type assertions. Not a sanctioned tool to reach for.**
+*
+* Before reaching for `blindCast`, **rewrite the surrounding code so the cast becomes
+* unnecessary**: tighten an input type, add a runtime check that narrows via a type
+* predicate, restructure a generic so the compiler can see the relationship you're
+* asserting, or use {@link castAs} when the value already satisfies the target type.
+* Only when no rewrite is feasible does `blindCast` become the right answer — and at
+* that point, the `Reason` literal you supply must articulate the compromise in
+* language a reviewer can evaluate.
+*
+* The reviewer **will** validate the `Reason`. If it doesn't hold up under scrutiny,
+* that is not a signal to soften the reason; it is a signal to go back and solve the
+* underlying type-system problem properly. An unconvincing justification is rework,
+* not a free pass.
+*
+* `blindCast` is the auditable form of `as Foo` / `as unknown as Foo`: it bypasses
+* the compiler's checks (the input type is `unknown`, the output type is whatever the
+* caller asks for), but it forces the unsafety to be named at the call site instead of
+* smuggled in via a bare `as`. The `Reason` type parameter exists only at compile
+* time — it is not present in the emitted JavaScript — but it is grep-able and
+* visible to future readers.
+*
+* @example
+* ```typescript
+* const stringValue = blindCast<
+*   string,
+*   "JSON.parse returns `unknown`; this field is documented to be a string in the API contract"
+* >(parsed[key]);
+* ```
+*
+* @typeParam TargetType - The type the caller is asserting the input has.
+* @typeParam _Reason - A string literal describing why bypassing the type system is necessary here.
+*                     Only meaningful at compile time. The reviewer evaluates whether it justifies the unsafety.
+*/
+function blindCast(input) {
+	return input;
+}
+/**
+* Type-checked, runtime pass-through alternative to a bare `as Type` cast.
+*
+* Use `castAs` when the value already satisfies the target type but you want to make
+* the type assertion explicit at the call site — for example, when an inferred type is
+* wider than the type you want to publish, or when a literal object should be tagged
+* with its nominal interface. Unlike {@link blindCast}, the compiler still checks that
+* the value is assignable to the target type, so this helper cannot smuggle in an
+* unsafe assertion.
+*
+* `castAs` exists alongside `blindCast` so authors pick the right name at the call
+* site: a `castAs` is type-checked and benign; a `blindCast` is the unsafe escape
+* hatch. The split makes review faster — readers know which casts to scrutinize and
+* which are pure annotations.
+*
+* @example
+* ```typescript
+* interface FancyObject {
+*   key: string;
+*   keyTwo: {
+*     subKey: string;
+*     subKeyTwo: number;
+*   };
+* }
+*
+* const typedObject = castAs<FancyObject>({
+*   key: 'Chookede',
+*   keyTwo: {
+*     subKey: 'Choookeeeee',
+*     subKeyTwo: 2,
+*   },
+* });
+* ```
+*
+* @typeParam Type - The type to constrain and tag the value with. The value must be assignable to `Type`.
+*/
+function castAs(value) {
+	return value;
+}
+//#endregion
+export { castAs as n, blindCast as t };
+
+//# sourceMappingURL=casts-DpaahrlC-Bd5n2coI.mjs.map

package/dist/casts-DpaahrlC-Bd5n2coI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"casts-DpaahrlC-Bd5n2coI.mjs","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/casts-DpaahrlC.mjs"],"sourcesContent":["//#region src/casts.ts\n/**\n* **Last-resort escape hatch for unsafe type assertions. Not a sanctioned tool to reach for.**\n*\n* Before reaching for `blindCast`, **rewrite the surrounding code so the cast becomes\n* unnecessary**: tighten an input type, add a runtime check that narrows via a type\n* predicate, restructure a generic so the compiler can see the relationship you're\n* asserting, or use {@link castAs} when the value already satisfies the target type.\n* Only when no rewrite is feasible does `blindCast` become the right answer — and at\n* that point, the `Reason` literal you supply must articulate the compromise in\n* language a reviewer can evaluate.\n*\n* The reviewer **will** validate the `Reason`. If it doesn't hold up under scrutiny,\n* that is not a signal to soften the reason; it is a signal to go back and solve the\n* underlying type-system problem properly. An unconvincing justification is rework,\n* not a free pass.\n*\n* `blindCast` is the auditable form of `as Foo` / `as unknown as Foo`: it bypasses\n* the compiler's checks (the input type is `unknown`, the output type is whatever the\n* caller asks for), but it forces the unsafety to be named at the call site instead of\n* smuggled in via a bare `as`. The `Reason` type parameter exists only at compile\n* time — it is not present in the emitted JavaScript — but it is grep-able and\n* visible to future readers.\n*\n* @example\n* ```typescript\n* const stringValue = blindCast<\n*   string,\n*   \"JSON.parse returns `unknown`; this field is documented to be a string in the API contract\"\n* >(parsed[key]);\n* ```\n*\n* @typeParam TargetType - The type the caller is asserting the input has.\n* @typeParam _Reason - A string literal describing why bypassing the type system is necessary here.\n*                     Only meaningful at compile time. The reviewer evaluates whether it justifies the unsafety.\n*/\nfunction blindCast(input) {\n\treturn input;\n}\n/**\n* Type-checked, runtime pass-through alternative to a bare `as Type` cast.\n*\n* Use `castAs` when the value already satisfies the target type but you want to make\n* the type assertion explicit at the call site — for example, when an inferred type is\n* wider than the type you want to publish, or when a literal object should be tagged\n* with its nominal interface. Unlike {@link blindCast}, the compiler still checks that\n* the value is assignable to the target type, so this helper cannot smuggle in an\n* unsafe assertion.\n*\n* `castAs` exists alongside `blindCast` so authors pick the right name at the call\n* site: a `castAs` is type-checked and benign; a `blindCast` is the unsafe escape\n* hatch. The split makes review faster — readers know which casts to scrutinize and\n* which are pure annotations.\n*\n* @example\n* ```typescript\n* interface FancyObject {\n*   key: string;\n*   keyTwo: {\n*     subKey: string;\n*     subKeyTwo: number;\n*   };\n* }\n*\n* const typedObject = castAs<FancyObject>({\n*   key: 'Chookede',\n*   keyTwo: {\n*     subKey: 'Choookeeeee',\n*     subKeyTwo: 2,\n*   },\n* });\n* ```\n*\n* @typeParam Type - The type to constrain and tag the value with. The value must be assignable to `Type`.\n*/\nfunction castAs(value) {\n\treturn value;\n}\n//#endregion\nexport { castAs as n, blindCast as t };\n\n//# sourceMappingURL=casts-DpaahrlC.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAS,UAAU,OAAO;CACzB,OAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAS,OAAO,OAAO;CACtB,OAAO;AACR"}

package/dist/codec-Cly9VPoA.mjs

@@ -0,0 +1,78 @@
+//#region ../../../1-framework/1-core/framework-components/dist/codec.mjs
+/**
+* Abstract base class for concrete codec implementations.
+*
+* Codec authors extend this class with their typed `Id`, `TTraits`, `TWire`, `TInput` and override all four abstract conversion methods: `encode`, `decode`, `encodeJson`, and `decodeJson`. The runtime instance carries only its `id` (proxied through the descriptor so alias subclasses inherit the descriptor's id automatically) and the conversion methods — static metadata lives on the {@link CodecDescriptor}.
+*/
+var CodecImpl = class {
+	descriptor;
+	/**
+	* Variance-erased descriptor reference. Concrete codec subclasses receive the typed descriptor in their own constructors and forward it via `super(descriptor)`; the variance erasure lives at this base because the abstract surface can't carry the concrete `TParams`.
+	*/
+	constructor(descriptor) {
+		this.descriptor = descriptor;
+	}
+	get id() {
+		return this.descriptor.codecId;
+	}
+};
+const emptyCodecLookup = {
+	get: () => void 0,
+	targetTypesFor: () => void 0,
+	renderOutputTypeFor: () => void 0
+};
+/**
+* Standard Schema validator for `void` params. Accepts only `undefined` (or absent input); rejects any other value so a contract that tries to thread `typeParams` through a non-parameterized codec id fails fast at the JSON boundary instead of silently coercing the value away. Used by the framework-supplied non-parameterized descriptor synthesizer.
+*/
+const voidParamsSchema = { "~standard": {
+	version: 1,
+	vendor: "prisma-next",
+	validate: (input) => input === void 0 ? { value: void 0 } : { issues: [{ message: "unexpected typeParams for non-parameterized codec (void params expected)" }] }
+} };
+/**
+* Abstract base class for concrete codec descriptors.
+*
+* Codec authors extend this class with their typed `TParams` and declare `codecId`, `traits`, `targetTypes`, `paramsSchema`, the curried `factory(params)`, and (optionally) `renderOutputType`.
+*
+* Implements the {@link CodecDescriptor} interface so a concrete subclass instance is directly usable wherever the framework expects a `CodecDescriptor<P>`.
+*/
+var CodecDescriptorImpl = class {
+	/** Boolean derived from `paramsSchema`: `true` whenever the schema is not the singleton `voidParamsSchema`. */
+	get isParameterized() {
+		return this.paramsSchema !== voidParamsSchema;
+	}
+};
+/**
+* Trivial column packager. Per-codec helpers call this directly with the result of `descriptor.factory(params)` — direct method invocation binds the descriptor's method-level generic at the call site and the literal flows through `R`.
+*
+* `nativeType` is the column's database-native type spelling — the value the postgres adapter's migration planner, the SQL renderer's cast policy, and the emitted contract's column `nativeType` slot read. Per-codec helpers pass the literal native-type string for their codec (e.g. `'text'`, `'int4'`, `'character varying'`); for codecs whose native-type spelling depends on parameters (none today; reserved for future shapes), the helper computes the rendered string before calling `column`. The framework does not derive the value from `codecId` — that mapping is target-specific and lives at the helper.
+*/
+function column(codecFactory, codecId, typeParams, nativeType) {
+	return {
+		codecFactory,
+		codecId,
+		typeParams,
+		nativeType
+	};
+}
+/**
+* Renders a codec-encoded value as a TypeScript literal (e.g. `'low'`, `1`, `true`), or `undefined`
+* when the value isn't literal-expressible (objects, arrays, null).
+*
+* Valid **only for identity codecs** whose `encodeJson` output equals their decoded output type
+* (text, int, float, bool). A non-identity codec (e.g. one that encodes to an int but decodes to a
+* string literal) must NOT use this: it has to `decodeJson` first, then render, in its own
+* `renderValueLiteral`.
+*
+* String values are fully escaped for a single-quoted `.d.ts` literal: backslash, single quote, and
+* every character a raw single-quoted TS literal cannot contain — newline, carriage return, and the
+* U+2028/U+2029 line/paragraph separators (which JS also treats as line terminators).
+*/
+function renderTsLiteral(value) {
+	if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+}
+//#endregion
+export { renderTsLiteral as a, emptyCodecLookup as i, CodecImpl as n, voidParamsSchema as o, column as r, CodecDescriptorImpl as t };
+
+//# sourceMappingURL=codec-Cly9VPoA.mjs.map

package/dist/codec-Cly9VPoA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-Cly9VPoA.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec.mjs"],"sourcesContent":["import { i as validateCodecTypeParams, n as materializeCodec, r as resolveCodecDescriptorOrThrow, t as CONTRACT_CODEC_DESCRIPTOR_MISSING } from \"./resolve-codec-BZF8TZh_.mjs\";\n//#region src/shared/codec.ts\n/**\n* Abstract base class for concrete codec implementations.\n*\n* Codec authors extend this class with their typed `Id`, `TTraits`, `TWire`, `TInput` and override all four abstract conversion methods: `encode`, `decode`, `encodeJson`, and `decodeJson`. The runtime instance carries only its `id` (proxied through the descriptor so alias subclasses inherit the descriptor's id automatically) and the conversion methods — static metadata lives on the {@link CodecDescriptor}.\n*/\nvar CodecImpl = class {\n\tdescriptor;\n\t/**\n\t* Variance-erased descriptor reference. Concrete codec subclasses receive the typed descriptor in their own constructors and forward it via `super(descriptor)`; the variance erasure lives at this base because the abstract surface can't carry the concrete `TParams`.\n\t*/\n\tconstructor(descriptor) {\n\t\tthis.descriptor = descriptor;\n\t}\n\tget id() {\n\t\treturn this.descriptor.codecId;\n\t}\n};\n//#endregion\n//#region src/shared/codec-types.ts\nconst emptyCodecLookup = {\n\tget: () => void 0,\n\ttargetTypesFor: () => void 0,\n\trenderOutputTypeFor: () => void 0\n};\n/**\n* Standard Schema validator for `void` params. Accepts only `undefined` (or absent input); rejects any other value so a contract that tries to thread `typeParams` through a non-parameterized codec id fails fast at the JSON boundary instead of silently coercing the value away. Used by the framework-supplied non-parameterized descriptor synthesizer.\n*/\nconst voidParamsSchema = { \"~standard\": {\n\tversion: 1,\n\tvendor: \"prisma-next\",\n\tvalidate: (input) => input === void 0 ? { value: void 0 } : { issues: [{ message: \"unexpected typeParams for non-parameterized codec (void params expected)\" }] }\n} };\n//#endregion\n//#region src/shared/codec-descriptor.ts\n/**\n* Abstract base class for concrete codec descriptors.\n*\n* Codec authors extend this class with their typed `TParams` and declare `codecId`, `traits`, `targetTypes`, `paramsSchema`, the curried `factory(params)`, and (optionally) `renderOutputType`.\n*\n* Implements the {@link CodecDescriptor} interface so a concrete subclass instance is directly usable wherever the framework expects a `CodecDescriptor<P>`.\n*/\nvar CodecDescriptorImpl = class {\n\t/** Boolean derived from `paramsSchema`: `true` whenever the schema is not the singleton `voidParamsSchema`. */\n\tget isParameterized() {\n\t\treturn this.paramsSchema !== voidParamsSchema;\n\t}\n};\n//#endregion\n//#region src/shared/column-spec.ts\n/**\n* Trivial column packager. Per-codec helpers call this directly with the result of `descriptor.factory(params)` — direct method invocation binds the descriptor's method-level generic at the call site and the literal flows through `R`.\n*\n* `nativeType` is the column's database-native type spelling — the value the postgres adapter's migration planner, the SQL renderer's cast policy, and the emitted contract's column `nativeType` slot read. Per-codec helpers pass the literal native-type string for their codec (e.g. `'text'`, `'int4'`, `'character varying'`); for codecs whose native-type spelling depends on parameters (none today; reserved for future shapes), the helper computes the rendered string before calling `column`. The framework does not derive the value from `codecId` — that mapping is target-specific and lives at the helper.\n*/\nfunction column(codecFactory, codecId, typeParams, nativeType) {\n\treturn {\n\t\tcodecFactory,\n\t\tcodecId,\n\t\ttypeParams,\n\t\tnativeType\n\t};\n}\n//#endregion\n//#region src/shared/render-ts-literal.ts\n/**\n* Renders a codec-encoded value as a TypeScript literal (e.g. `'low'`, `1`, `true`), or `undefined`\n* when the value isn't literal-expressible (objects, arrays, null).\n*\n* Valid **only for identity codecs** whose `encodeJson` output equals their decoded output type\n* (text, int, float, bool). A non-identity codec (e.g. one that encodes to an int but decodes to a\n* string literal) must NOT use this: it has to `decodeJson` first, then render, in its own\n* `renderValueLiteral`.\n*\n* String values are fully escaped for a single-quoted `.d.ts` literal: backslash, single quote, and\n* every character a raw single-quoted TS literal cannot contain — newline, carriage return, and the\n* U+2028/U+2029 line/paragraph separators (which JS also treats as line terminators).\n*/\nfunction renderTsLiteral(value) {\n\tif (typeof value === \"string\") return `'${value.replace(/\\\\/g, \"\\\\\\\\\").replace(/'/g, \"\\\\'\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/\\u2028/g, \"\\\\u2028\").replace(/\\u2029/g, \"\\\\u2029\")}'`;\n\tif (typeof value === \"number\" || typeof value === \"boolean\") return String(value);\n}\n//#endregion\nexport { CONTRACT_CODEC_DESCRIPTOR_MISSING, CodecDescriptorImpl, CodecImpl, column, emptyCodecLookup, materializeCodec, renderTsLiteral, resolveCodecDescriptorOrThrow, validateCodecTypeParams, voidParamsSchema };\n\n//# sourceMappingURL=codec.mjs.map"],"mappings":";;;;;;AAOA,IAAI,YAAY,MAAM;CACrB;;;;CAIA,YAAY,YAAY;EACvB,KAAK,aAAa;CACnB;CACA,IAAI,KAAK;EACR,OAAO,KAAK,WAAW;CACxB;AACD;AAGA,MAAM,mBAAmB;CACxB,WAAW,KAAK;CAChB,sBAAsB,KAAK;CAC3B,2BAA2B,KAAK;AACjC;;;;AAIA,MAAM,mBAAmB,EAAE,aAAa;CACvC,SAAS;CACT,QAAQ;CACR,WAAW,UAAU,UAAU,KAAK,IAAI,EAAE,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,SAAS,2EAA2E,CAAC,EAAE;AACjK,EAAE;;;;;;;;AAUF,IAAI,sBAAsB,MAAM;;CAE/B,IAAI,kBAAkB;EACrB,OAAO,KAAK,iBAAiB;CAC9B;AACD;;;;;;AAQA,SAAS,OAAO,cAAc,SAAS,YAAY,YAAY;CAC9D,OAAO;EACN;EACA;EACA;EACA;CACD;AACD;;;;;;;;;;;;;;AAgBA,SAAS,gBAAgB,OAAO;CAC/B,IAAI,OAAO,UAAU,UAAU,OAAO,IAAI,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,KAAK,CAAC,CAAC,QAAQ,OAAO,KAAK,CAAC,CAAC,QAAQ,OAAO,KAAK,CAAC,CAAC,QAAQ,WAAW,SAAS,CAAC,CAAC,QAAQ,WAAW,SAAS,EAAE;CACpM,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW,OAAO,OAAO,KAAK;AACjF"}

package/dist/codec-D3GVAkR_.d.mts

@@ -0,0 +1,116 @@
+import { et as ValueSetRef, z as JsonValue } from "./domain-envelope-D6Wn9AmZ-BqZKTT9U.mjs";
+import { i as CodecDescriptor, l as CodecRef, n as Codec, s as CodecInstanceContext, t as AnyCodecDescriptor } from "./codec-types-XJO6eC9U-B_K2q0zm.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/codec.d.mts
+//#region src/shared/column-spec.d.ts
+/**
+ * Authored column-type descriptor — the data shape an authoring site (PSL or TypeScript builders) attaches to a column to identify its codec and its native database type.
+ *
+ * Lives at the framework-components layer alongside the codec types so codec-author packages (e.g. column-spec / `column()` packagers) can extend it directly without crossing layer boundaries.
+ *
+ * @template TCodecId Narrowed codec id literal for sites that thread a specific codec id through the type system.
+ */
+type ColumnTypeDescriptor<TCodecId extends string = string> = {
+  readonly codecId: TCodecId;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown> | undefined;
+  readonly typeRef?: string;
+  /**
+   * Storage-plane value-set ref, set by an authoring path that resolves a
+   * field's type against a value-set-deriving entity (e.g. a PSL entity-ref
+   * type constructor like `pg.enum(Ref)`, or a TS `enumType` handle).
+   * Threaded straight onto the storage node this descriptor builds, where it
+   * drives value-set → codec typing. Every codec's own descriptor leaves this
+   * unset.
+   */
+  readonly valueSet?: ValueSetRef;
+  readonly entityRef?: EntityRef;
+};
+/**
+ * Late-resolved pack-entity reference — a field on the type descriptor it is
+ * declared on: `entityKind`/`entityName` identify a pack entity whose final
+ * placement depends on data not yet known when the descriptor carrying this
+ * reference is built — e.g. an owning namespace resolved only once the
+ * surrounding structure is assembled.
+ */
+type EntityRef = {
+  readonly entityKind: string;
+  readonly entityName: string;
+  readonly entity: unknown;
+};
+/**
+ * Column spec carrying the codec factory closure alongside the {@link ColumnTypeDescriptor} fields. Codec authors return a `ColumnSpec` from per-codec column helpers; the runtime materializes the codec instance by calling `codecFactory(ctx)` once it knows the column's `CodecInstanceContext`.
+ *
+ * Extends {@link ColumnTypeDescriptor} so `ColumnSpec` instances flow directly into contract-authoring sites that consume the descriptor shape — no structural mirroring required.
+ */
+interface ColumnSpec<R, P extends Record<string, unknown> | undefined> extends ColumnTypeDescriptor {
+  readonly codecFactory: (ctx: CodecInstanceContext) => R;
+  readonly typeParams: P;
+}
+/**
+ * Trivial column packager. Per-codec helpers call this directly with the result of `descriptor.factory(params)` — direct method invocation binds the descriptor's method-level generic at the call site and the literal flows through `R`.
+ *
+ * `nativeType` is the column's database-native type spelling — the value the postgres adapter's migration planner, the SQL renderer's cast policy, and the emitted contract's column `nativeType` slot read. Per-codec helpers pass the literal native-type string for their codec (e.g. `'text'`, `'int4'`, `'character varying'`); for codecs whose native-type spelling depends on parameters (none today; reserved for future shapes), the helper computes the rendered string before calling `column`. The framework does not derive the value from `codecId` — that mapping is target-specific and lives at the helper.
+ */
+declare function column<R, P extends Record<string, unknown> | undefined>(codecFactory: (ctx: CodecInstanceContext) => R, codecId: string, typeParams: P, nativeType: string): ColumnSpec<R, P>;
+/**
+ * Coarse `satisfies` shape — checks the helper's typeParams record matches the descriptor's factory params. Catches "wrong typeParams shape" wiring mistakes; does NOT catch "wrong descriptor's factory" mistakes (the codec slot is left as `unknown`).
+ *
+ * Use when the codec's `ReturnType<factory>` is unstable (e.g. heavily overloaded factories where extraction widens too much).
+ */
+type ColumnHelperFor<D extends CodecDescriptor<any>> = (...args: any[]) => ColumnSpec<unknown, ColumnHelperParams<D>>;
+/**
+ * Strict `satisfies` shape — also checks the helper's codec is at least the *base* codec instance type the descriptor's factory returns. `ReturnType<ReturnType<D['factory']>>` widens method generics to their constraint, so this only sanity-checks the wiring at the base type level. Literal preservation comes from the direct `descriptor.factory(...)` call inside the helper, not from `satisfies`.
+ */
+type ColumnHelperForStrict<D extends CodecDescriptor<any>> = (...args: any[]) => ColumnSpec<ReturnType<ReturnType<D['factory']>>, ColumnHelperParams<D>>;
+/**
+ * Coerce a descriptor's `factory` first parameter into the typeParams shape `ColumnSpec` accepts. Non-parameterized descriptors (factory with no params, or `params: void`) collapse to `undefined`; parameterized descriptors keep the params record shape.
+ */
+type ColumnHelperParams<D extends CodecDescriptor<any>> = Parameters<D['factory']>[0] extends Record<string, unknown> ? Parameters<D['factory']>[0] : undefined;
+//#endregion
+//#region src/shared/render-ts-literal.d.ts
+/**
+ * Renders a codec-encoded value as a TypeScript literal (e.g. `'low'`, `1`, `true`), or `undefined`
+ * when the value isn't literal-expressible (objects, arrays, null).
+ *
+ * Valid **only for identity codecs** whose `encodeJson` output equals their decoded output type
+ * (text, int, float, bool). A non-identity codec (e.g. one that encodes to an int but decodes to a
+ * string literal) must NOT use this: it has to `decodeJson` first, then render, in its own
+ * `renderValueLiteral`.
+ *
+ * String values are fully escaped for a single-quoted `.d.ts` literal: backslash, single quote, and
+ * every character a raw single-quoted TS literal cannot contain — newline, carriage return, and the
+ * U+2028/U+2029 line/paragraph separators (which JS also treats as line terminators).
+ */
+declare function renderTsLiteral(value: JsonValue): string | undefined;
+//#endregion
+//#region src/shared/resolve-codec.d.ts
+declare const CONTRACT_CODEC_DESCRIPTOR_MISSING: "CONTRACT.CODEC_DESCRIPTOR_MISSING";
+/**
+ * Look up a descriptor for `ref.codecId` using `descriptorFor`; throw
+ * `code` if none is found. Each plane names its own error path: the control
+ * plane resolves contract-stack descriptors (`CONTRACT.*`), the execution
+ * plane resolves at query time (`RUNTIME.*`).
+ */
+declare function resolveCodecDescriptorOrThrow(descriptorFor: (codecId: string) => AnyCodecDescriptor | undefined, ref: CodecRef, code: 'CONTRACT.CODEC_DESCRIPTOR_MISSING' | 'RUNTIME.CODEC_DESCRIPTOR_MISSING'): AnyCodecDescriptor;
+/**
+ * Validates `ref.typeParams` against `descriptor.paramsSchema`.
+ *
+ * Parameterized codecs that omit `typeParams` have it normalized to `{}` before
+ * validation (mirrors `ast-codec-resolver.ts` semantics). Throws
+ * `RUNTIME.TYPE_PARAMS_INVALID` when the validator returns a `Promise` or
+ * reports issues.
+ */
+declare function validateCodecTypeParams(descriptor: AnyCodecDescriptor, ref: CodecRef): unknown;
+/**
+ * Resolves a `Codec` instance: validates `ref.typeParams` via
+ * {@link validateCodecTypeParams} then calls `descriptor.factory(validated)(ctx)`.
+ *
+ * The descriptor's `factory` is typed against its own `P`; the registry erases
+ * `P` to `any`, so the factory is narrowed to `(params: unknown) => (ctx) => Codec`
+ * at the call boundary. The `paramsSchema` validates the input above before we
+ * forward it, so the narrowing is safe by construction.
+ */
+declare function materializeCodec(descriptor: AnyCodecDescriptor, ref: CodecRef, ctx: CodecInstanceContext): Codec;
+//#endregion
+export { ColumnTypeDescriptor as a, renderTsLiteral as c, ColumnSpec as i, resolveCodecDescriptorOrThrow as l, ColumnHelperFor as n, column as o, ColumnHelperForStrict as r, materializeCodec as s, CONTRACT_CODEC_DESCRIPTOR_MISSING as t, validateCodecTypeParams as u };
+//# sourceMappingURL=codec-D3GVAkR_.d.mts.map

package/dist/codec-D3GVAkR_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-D3GVAkR_.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec.d.mts"],"mappings":";;;;;;;;;;;KAUK,qBAAqB;WACf,SAAS;WACT;WACA,aAAa;WACb;;;;;;;;;WASA,WAAW;WACX,YAAY;;;;;;;;;KASlB;WACM;WACA;WACA;;;;;;;UAOD,WAAW,GAAG,UAAU,6CAA6C;WACpE,eAAe,KAAK,yBAAyB;WAC7C,YAAY;;;;;;;iBAON,OAAO,GAAG,UAAU,qCAAqC,eAAe,KAAK,yBAAyB,GAAG,iBAAiB,YAAY,GAAG,qBAAqB,WAAW,GAAG;;;;;;KAMxL,gBAAgB,UAAU,4BAA4B,gBAAgB,oBAAoB,mBAAmB;;;;KAI7G,sBAAsB,UAAU,4BAA4B,gBAAgB,WAAW,WAAW,WAAW,gBAAgB,mBAAmB;;;;KAIhJ,mBAAmB,UAAU,wBAAwB,WAAW,yBAAyB,0BAA0B,WAAW;;;;;;;;;;;;;;;;iBAgBlH,gBAAgB,OAAO;;;cAG1B;;;;;;;iBAOG,8BAA8B,gBAAgB,oBAAoB,gCAAgC,KAAK,UAAU,iFAAiF;;;;;;;;;iBASlM,wBAAwB,YAAY,oBAAoB,KAAK;;;;;;;;;;iBAU7D,iBAAiB,YAAY,oBAAoB,KAAK,UAAU,KAAK,uBAAuB"}