@prisma/orm-framework 0.16.0 → 0.17.0-dev.2

package/dist/authoring-ljy8m56O.d.mts

@@ -0,0 +1 @@
+import "./framework-authoring--R1ZGWs1-C5F11Vhx.mjs";

package/dist/capabilities-D_lE1L0x-x4Dq0wCx.mjs

@@ -0,0 +1,119 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+import { n as isCodecTrait } from "./codec-types-DcNvNeY1-BO6kUiH0.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/capabilities-D_lE1L0x.mjs
+/**
+* Ownership key of an `(operation, input)` pair. Two descriptors sharing a key are two contributors claiming one overload, which is a composition error.
+*/
+function aggregateDescriptorKey(descriptor) {
+	switch (descriptor.input.kind) {
+		case "none": return `${descriptor.operation}:none`;
+		case "any": return `${descriptor.operation}:any`;
+		case "codec": return `${descriptor.operation}:codec:${descriptor.input.codecId}`;
+		case "trait": return `${descriptor.operation}:trait:${descriptor.input.trait}`;
+	}
+}
+/** Whether `descriptor` is the overload of an operation that consumes no value — the case whose result always names a codec outright. */
+function isNoInputAggregateDescriptor(descriptor) {
+	return descriptor.input.kind === "none";
+}
+/** Whether `descriptor` answers regardless of input — the fallback rung of resolution. */
+function isAnyInputAggregateDescriptor(descriptor) {
+	return descriptor.input.kind === "any";
+}
+function isObjectLike(value) {
+	return typeof value === "object" && value !== null;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isAggregateInputMatch(value) {
+	if (!isObjectLike(value) || !("kind" in value)) return false;
+	switch (value.kind) {
+		case "none":
+		case "any": return true;
+		case "codec": return "codecId" in value && isNonEmptyString(value.codecId);
+		case "trait": return "trait" in value && isCodecTrait(value.trait);
+		default: return false;
+	}
+}
+function isAggregateOutputCodec(value) {
+	if (!isObjectLike(value) || !("kind" in value)) return false;
+	switch (value.kind) {
+		case "self": return true;
+		case "codec": return "codecId" in value && isNonEmptyString(value.codecId) && (!("typeParams" in value) || value.typeParams === void 0 || typeof value.typeParams === "function");
+		default: return false;
+	}
+}
+/**
+* Structural validation of a contributed descriptor. Components assembled from JavaScript reach the contribution slot unchecked, so composition validates the shape once and every later read is a plain lookup.
+*/
+function isAggregateDescriptor(value) {
+	if (!isObjectLike(value)) return false;
+	if (!("operation" in value) || !isNonEmptyString(value.operation)) return false;
+	if (!("nullable" in value) || typeof value.nullable !== "boolean") return false;
+	if (!("input" in value) || !isAggregateInputMatch(value.input)) return false;
+	if (!("output" in value) || !isAggregateOutputCodec(value.output)) return false;
+	return value.input.kind === "codec" || value.input.kind === "trait" || value.output.kind === "codec";
+}
+/**
+* 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 a, isNoInputAggregateDescriptor as i, isAggregateDescriptor as n, isAnyInputAggregateDescriptor as r, aggregateDescriptorKey as t };
+
+//# sourceMappingURL=capabilities-D_lE1L0x-x4Dq0wCx.mjs.map

package/dist/capabilities-D_lE1L0x-x4Dq0wCx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities-D_lE1L0x-x4Dq0wCx.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/capabilities-D_lE1L0x.mjs"],"sourcesContent":["import { n as isCodecTrait } from \"./codec-types-DcNvNeY1.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\n//#region src/shared/aggregate-descriptor.ts\n/**\n* Ownership key of an `(operation, input)` pair. Two descriptors sharing a key are two contributors claiming one overload, which is a composition error.\n*/\nfunction aggregateDescriptorKey(descriptor) {\n\tswitch (descriptor.input.kind) {\n\t\tcase \"none\": return `${descriptor.operation}:none`;\n\t\tcase \"any\": return `${descriptor.operation}:any`;\n\t\tcase \"codec\": return `${descriptor.operation}:codec:${descriptor.input.codecId}`;\n\t\tcase \"trait\": return `${descriptor.operation}:trait:${descriptor.input.trait}`;\n\t}\n}\n/** Whether `descriptor` is the overload of an operation that consumes no value — the case whose result always names a codec outright. */\nfunction isNoInputAggregateDescriptor(descriptor) {\n\treturn descriptor.input.kind === \"none\";\n}\n/** Whether `descriptor` answers regardless of input — the fallback rung of resolution. */\nfunction isAnyInputAggregateDescriptor(descriptor) {\n\treturn descriptor.input.kind === \"any\";\n}\nfunction isObjectLike(value) {\n\treturn typeof value === \"object\" && value !== null;\n}\nfunction isNonEmptyString(value) {\n\treturn typeof value === \"string\" && value.length > 0;\n}\nfunction isAggregateInputMatch(value) {\n\tif (!isObjectLike(value) || !(\"kind\" in value)) return false;\n\tswitch (value.kind) {\n\t\tcase \"none\":\n\t\tcase \"any\": return true;\n\t\tcase \"codec\": return \"codecId\" in value && isNonEmptyString(value.codecId);\n\t\tcase \"trait\": return \"trait\" in value && isCodecTrait(value.trait);\n\t\tdefault: return false;\n\t}\n}\nfunction isAggregateOutputCodec(value) {\n\tif (!isObjectLike(value) || !(\"kind\" in value)) return false;\n\tswitch (value.kind) {\n\t\tcase \"self\": return true;\n\t\tcase \"codec\": return \"codecId\" in value && isNonEmptyString(value.codecId) && (!(\"typeParams\" in value) || value.typeParams === void 0 || typeof value.typeParams === \"function\");\n\t\tdefault: return false;\n\t}\n}\n/**\n* Structural validation of a contributed descriptor. Components assembled from JavaScript reach the contribution slot unchecked, so composition validates the shape once and every later read is a plain lookup.\n*/\nfunction isAggregateDescriptor(value) {\n\tif (!isObjectLike(value)) return false;\n\tif (!(\"operation\" in value) || !isNonEmptyString(value.operation)) return false;\n\tif (!(\"nullable\" in value) || typeof value.nullable !== \"boolean\") return false;\n\tif (!(\"input\" in value) || !isAggregateInputMatch(value.input)) return false;\n\tif (!(\"output\" in value) || !isAggregateOutputCodec(value.output)) return false;\n\treturn value.input.kind === \"codec\" || value.input.kind === \"trait\" || value.output.kind === \"codec\";\n}\n//#endregion\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 { isNoInputAggregateDescriptor as a, isAnyInputAggregateDescriptor as i, aggregateDescriptorKey as n, isAggregateDescriptor as r, mergeCapabilityMatrices as t };\n\n//# sourceMappingURL=capabilities-D_lE1L0x.mjs.map"],"mappings":";;;;;;AAMA,SAAS,uBAAuB,YAAY;CAC3C,QAAQ,WAAW,MAAM,MAAzB;EACC,KAAK,QAAQ,OAAO,GAAG,WAAW,UAAU;EAC5C,KAAK,OAAO,OAAO,GAAG,WAAW,UAAU;EAC3C,KAAK,SAAS,OAAO,GAAG,WAAW,UAAU,SAAS,WAAW,MAAM;EACvE,KAAK,SAAS,OAAO,GAAG,WAAW,UAAU,SAAS,WAAW,MAAM;CACxE;AACD;;AAEA,SAAS,6BAA6B,YAAY;CACjD,OAAO,WAAW,MAAM,SAAS;AAClC;;AAEA,SAAS,8BAA8B,YAAY;CAClD,OAAO,WAAW,MAAM,SAAS;AAClC;AACA,SAAS,aAAa,OAAO;CAC5B,OAAO,OAAO,UAAU,YAAY,UAAU;AAC/C;AACA,SAAS,iBAAiB,OAAO;CAChC,OAAO,OAAO,UAAU,YAAY,MAAM,SAAS;AACpD;AACA,SAAS,sBAAsB,OAAO;CACrC,IAAI,CAAC,aAAa,KAAK,KAAK,EAAE,UAAU,QAAQ,OAAO;CACvD,QAAQ,MAAM,MAAd;EACC,KAAK;EACL,KAAK,OAAO,OAAO;EACnB,KAAK,SAAS,OAAO,aAAa,SAAS,iBAAiB,MAAM,OAAO;EACzE,KAAK,SAAS,OAAO,WAAW,SAAS,aAAa,MAAM,KAAK;EACjE,SAAS,OAAO;CACjB;AACD;AACA,SAAS,uBAAuB,OAAO;CACtC,IAAI,CAAC,aAAa,KAAK,KAAK,EAAE,UAAU,QAAQ,OAAO;CACvD,QAAQ,MAAM,MAAd;EACC,KAAK,QAAQ,OAAO;EACpB,KAAK,SAAS,OAAO,aAAa,SAAS,iBAAiB,MAAM,OAAO,MAAM,EAAE,gBAAgB,UAAU,MAAM,eAAe,KAAK,KAAK,OAAO,MAAM,eAAe;EACtK,SAAS,OAAO;CACjB;AACD;;;;AAIA,SAAS,sBAAsB,OAAO;CACrC,IAAI,CAAC,aAAa,KAAK,GAAG,OAAO;CACjC,IAAI,EAAE,eAAe,UAAU,CAAC,iBAAiB,MAAM,SAAS,GAAG,OAAO;CAC1E,IAAI,EAAE,cAAc,UAAU,OAAO,MAAM,aAAa,WAAW,OAAO;CAC1E,IAAI,EAAE,WAAW,UAAU,CAAC,sBAAsB,MAAM,KAAK,GAAG,OAAO;CACvE,IAAI,EAAE,YAAY,UAAU,CAAC,uBAAuB,MAAM,MAAM,GAAG,OAAO;CAC1E,OAAO,MAAM,MAAM,SAAS,WAAW,MAAM,MAAM,SAAS,WAAW,MAAM,OAAO,SAAS;AAC9F;;;;;;;;;AAWA,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/{codec-Cly9VPoA.mjs → codec-BgOWqkHY.mjs}

@@ -1,3 +1,4 @@
+import { r as voidParamsSchema } from "./codec-types-DcNvNeY1-BO6kUiH0.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/codec.mjs
 /**
 * Abstract base class for concrete codec implementations.
@@ -16,19 +17,6 @@ var CodecImpl = class {
 		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.
 *
@@ -73,6 +61,6 @@ function renderTsLiteral(value) {
 	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 };
+export { renderTsLiteral as i, CodecImpl as n, column as r, CodecDescriptorImpl as t };
 
-//# sourceMappingURL=codec-Cly9VPoA.mjs.map
+//# sourceMappingURL=codec-BgOWqkHY.mjs.map

package/dist/codec-BgOWqkHY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-BgOWqkHY.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec.mjs"],"sourcesContent":["import { r as voidParamsSchema, t as emptyCodecLookup } from \"./codec-types-DcNvNeY1.mjs\";\nimport { 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-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":";;;;;;;AAQA,IAAI,YAAY,MAAM;CACrB;;;;CAIA,YAAY,YAAY;EACvB,KAAK,aAAa;CACnB;CACA,IAAI,KAAK;EACR,OAAO,KAAK,WAAW;CACxB;AACD;;;;;;;;AAUA,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 → codec-CA00Ry1D.d.mts}

@@ -1,5 +1,5 @@
 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";
+import { i as CodecDescriptor, l as CodecRef, n as Codec, s as CodecInstanceContext, t as AnyCodecDescriptor } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/codec.d.mts
 //#region src/shared/column-spec.d.ts
 /**
@@ -113,4 +113,4 @@ declare function validateCodecTypeParams(descriptor: AnyCodecDescriptor, ref: Co
 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
+//# sourceMappingURL=codec-CA00Ry1D.d.mts.map

package/dist/{codec-D3GVAkR_.d.mts.map → codec-CA00Ry1D.d.mts.map}

@@ -1 +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"}
+{"version":3,"file":"codec-CA00Ry1D.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"}

package/dist/{codec-types-XJO6eC9U-B_K2q0zm.d.mts → codec-types-720XoDZ0-Br-QaYK3.d.mts}

@@ -1,6 +1,6 @@
 import { z as JsonValue } from "./domain-envelope-D6Wn9AmZ-BqZKTT9U.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region ../../../1-framework/1-core/framework-components/dist/codec-types-XJO6eC9U.d.mts
+//#region ../../../1-framework/1-core/framework-components/dist/codec-types-720XoDZ0.d.mts
 //#region src/shared/codec-descriptor.d.ts
 /**
  * Unified codec descriptor. Every codec in the framework registers through this shape — non-parameterized codecs use `P = void` and a constant factory that returns the same shared codec instance for every column; parameterized codecs use a non-empty `P` and a curried higher-order factory that returns a per-instance codec.
@@ -127,7 +127,9 @@ declare abstract class CodecImpl<Id extends string = string, TTraits extends rea
 }
 //#endregion
 //#region src/shared/codec-types.d.ts
-type CodecTrait = 'equality' | 'order' | 'boolean' | 'numeric' | 'textual';
+/** Every semantic trait a codec may advertise. The runtime tuple backs validation of trait-keyed contributions arriving from JavaScript. */
+declare const CODEC_TRAITS: readonly ["equality", "order", "boolean", "numeric", "textual"];
+type CodecTrait = (typeof CODEC_TRAITS)[number];
 /**
  * Serializable codec identity carried by every codec-bearing AST node.
  *
@@ -218,4 +220,4 @@ interface CodecInstanceContext {
 declare const voidParamsSchema: StandardSchemaV1<void>;
 //#endregion
 export { CodecDescriptorImpl as a, CodecLookup as c, CodecTrait as d, emptyCodecLookup as f, CodecDescriptor as i, CodecRef as l, Codec as n, CodecImpl as o, voidParamsSchema as p, CodecCallContext as r, CodecInstanceContext as s, AnyCodecDescriptor as t, CodecRegistry as u };
-//# sourceMappingURL=codec-types-XJO6eC9U-B_K2q0zm.d.mts.map
+//# sourceMappingURL=codec-types-720XoDZ0-Br-QaYK3.d.mts.map

package/dist/{codec-types-XJO6eC9U-B_K2q0zm.d.mts.map → codec-types-720XoDZ0-Br-QaYK3.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"codec-types-XJO6eC9U-B_K2q0zm.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec-types-XJO6eC9U.d.mts"],"mappings":";;;;;;;;;;;;;;;UAcU,gBAAgB;;WAEf;;WAEA,iBAAiB;;WAEjB;;WAEA,cAAc,iBAAiB;;WAE/B;;WAEA,oBAAoB,QAAQ;;WAE5B,mBAAmB,QAAQ;;;;;;;;;;;WAW3B,sBAAsB,OAAO,WAAW;;WAExC,UAAU,QAAQ,OAAO,KAAK,yBAAyB;;;;;;;KAO7D,qBAAqB;;;;;;;;uBAQH,oBAAoB,2BAA2B,gBAAgB;oBAClE;oBACA,iBAAiB;oBACjB;oBACA,cAAc,iBAAiB;;MAE7C;;EAEJ,kBAAkB,QAAQ;;EAE1B,iBAAiB,QAAQ;;EAEzB,oBAAoB,OAAO,WAAW;;;;WAI7B,QAAQ,QAAQ,WAAW,KAAK,yBAAyB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;UAuBjF,MAAM,4BAA4B,yBAAyB,wBAAwB,cAAc,iBAAiB;;WAEjH,IAAI;;WAEJ,gBAAgB;;EAEzB,OAAO,OAAO,QAAQ,KAAK,mBAAmB,QAAQ;;EAEtD,OAAO,MAAM,OAAO,KAAK,mBAAmB,QAAQ;;EAEpD,WAAW,OAAO,SAAS;;EAE3B,WAAW,MAAM,YAAY;;;;;;;uBAOR,UAAU,4BAA4B,yBAAyB,wBAAwB,cAAc,iBAAiB,6BAA6B,MAAM,IAAI,SAAS,OAAO;WACzL,YAAY;;;;EAIrB,YAAY,YAAY;MACpB,MAAM;WACD,OAAO,OAAO,QAAQ,KAAK,mBAAmB,QAAQ;WACtD,OAAO,MAAM,OAAO,KAAK,mBAAmB,QAAQ;WACpD,WAAW,OAAO,SAAS;WAC3B,WAAW,MAAM,YAAY;;;;KAInC;;;;;;;;;;;;UAYK;WACC;WACA,aAAa;WACb;;;;;;;;;;;;;UAaD;WACC,SAAS;;;;;;;;;UASV;EACR,IAAI,aAAa;EACjB,eAAe;EACf,oBAAoB,YAAY,QAAQ;;EAExC,oBAAoB,YAAY,QAAQ;;EAExC,uBAAuB,YAAY,OAAO,WAAW;;;;;;;;;;EAUrD,eAAe,aAAa;;;;;;;;;;;;;;;UAepB,sBAAsB;EAC9B,YAAY,KAAK,WAAW;EAC5B,UAAU,qBAAqB,eAAe,iBAAiB;;cAEnD,kBAAkB;;;;;;;;UAQtB;WACC;;;;;cAKG,kBAAkB"}
+{"version":3,"file":"codec-types-720XoDZ0-Br-QaYK3.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec-types-720XoDZ0.d.mts"],"mappings":";;;;;;;;;;;;;;;UAcU,gBAAgB;;WAEf;;WAEA,iBAAiB;;WAEjB;;WAEA,cAAc,iBAAiB;;WAE/B;;WAEA,oBAAoB,QAAQ;;WAE5B,mBAAmB,QAAQ;;;;;;;;;;;WAW3B,sBAAsB,OAAO,WAAW;;WAExC,UAAU,QAAQ,OAAO,KAAK,yBAAyB;;;;;;;KAO7D,qBAAqB;;;;;;;;uBAQH,oBAAoB,2BAA2B,gBAAgB;oBAClE;oBACA,iBAAiB;oBACjB;oBACA,cAAc,iBAAiB;;MAE7C;;EAEJ,kBAAkB,QAAQ;;EAE1B,iBAAiB,QAAQ;;EAEzB,oBAAoB,OAAO,WAAW;;;;WAI7B,QAAQ,QAAQ,WAAW,KAAK,yBAAyB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;UAuBjF,MAAM,4BAA4B,yBAAyB,wBAAwB,cAAc,iBAAiB;;WAEjH,IAAI;;WAEJ,gBAAgB;;EAEzB,OAAO,OAAO,QAAQ,KAAK,mBAAmB,QAAQ;;EAEtD,OAAO,MAAM,OAAO,KAAK,mBAAmB,QAAQ;;EAEpD,WAAW,OAAO,SAAS;;EAE3B,WAAW,MAAM,YAAY;;;;;;;uBAOR,UAAU,4BAA4B,yBAAyB,wBAAwB,cAAc,iBAAiB,6BAA6B,MAAM,IAAI,SAAS,OAAO;WACzL,YAAY;;;;EAIrB,YAAY,YAAY;MACpB,MAAM;WACD,OAAO,OAAO,QAAQ,KAAK,mBAAmB,QAAQ;WACtD,OAAO,MAAM,OAAO,KAAK,mBAAmB,QAAQ;WACpD,WAAW,OAAO,SAAS;WAC3B,WAAW,MAAM,YAAY;;;;;cAK1B;KACT,qBAAqB;;;;;;;;;;;;UAYhB;WACC;WACA,aAAa;WACb;;;;;;;;;;;;;UAaD;WACC,SAAS;;;;;;;;;UASV;EACR,IAAI,aAAa;EACjB,eAAe;EACf,oBAAoB,YAAY,QAAQ;;EAExC,oBAAoB,YAAY,QAAQ;;EAExC,uBAAuB,YAAY,OAAO,WAAW;;;;;;;;;;EAUrD,eAAe,aAAa;;;;;;;;;;;;;;;UAepB,sBAAsB;EAC9B,YAAY,KAAK,WAAW;EAC5B,UAAU,qBAAqB,eAAe,iBAAiB;;cAEnD,kBAAkB;;;;;;;;UAQtB;WACC;;;;;cAKG,kBAAkB"}

package/dist/codec-types-DcNvNeY1-BO6kUiH0.mjs

@@ -0,0 +1,30 @@
+//#region ../../../1-framework/1-core/framework-components/dist/codec-types-DcNvNeY1.mjs
+/** Every semantic trait a codec may advertise. The runtime tuple backs validation of trait-keyed contributions arriving from JavaScript. */
+const CODEC_TRAITS = [
+	"equality",
+	"order",
+	"boolean",
+	"numeric",
+	"textual"
+];
+/** Whether `value` names one of the {@link CODEC_TRAITS}. */
+function isCodecTrait(value) {
+	return CODEC_TRAITS.some((trait) => trait === value);
+}
+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)" }] }
+} };
+//#endregion
+export { isCodecTrait as n, voidParamsSchema as r, emptyCodecLookup as t };
+
+//# sourceMappingURL=codec-types-DcNvNeY1-BO6kUiH0.mjs.map

package/dist/codec-types-DcNvNeY1-BO6kUiH0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-DcNvNeY1-BO6kUiH0.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec-types-DcNvNeY1.mjs"],"sourcesContent":["//#region src/shared/codec-types.ts\n/** Every semantic trait a codec may advertise. The runtime tuple backs validation of trait-keyed contributions arriving from JavaScript. */\nconst CODEC_TRAITS = [\n\t\"equality\",\n\t\"order\",\n\t\"boolean\",\n\t\"numeric\",\n\t\"textual\"\n];\n/** Whether `value` names one of the {@link CODEC_TRAITS}. */\nfunction isCodecTrait(value) {\n\treturn CODEC_TRAITS.some((trait) => trait === value);\n}\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\nexport { isCodecTrait as n, voidParamsSchema as r, emptyCodecLookup as t };\n\n//# sourceMappingURL=codec-types-DcNvNeY1.mjs.map"],"mappings":";;AAEA,MAAM,eAAe;CACpB;CACA;CACA;CACA;CACA;AACD;;AAEA,SAAS,aAAa,OAAO;CAC5B,OAAO,aAAa,MAAM,UAAU,UAAU,KAAK;AACpD;AACA,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"}

package/dist/components-D7bixOE0.d.mts

@@ -0,0 +1,50 @@
+import { d as CodecTrait } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
+import { t as AggregateDescriptor } from "./types-import-spec-B4hKOPE9-BwQGG38j.mjs";
+import "./framework-components-BQ_fYHtC-Co52pfO-.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/components.d.mts
+//#region src/shared/aggregate-overloads.d.ts
+/** What settling needs to know about a codec: its id, and the traits an overload can claim it by. */
+interface AggregateCodecTraits {
+  readonly codecId: string;
+  readonly traits: readonly CodecTrait[];
+}
+/** The overloads of one operation, settled: one per codec, plus the two that answer without a specific input. */
+interface SettledAggregateOperation<TDescriptor extends AggregateDescriptor> {
+  /** The overload that serves each codec — its exact one where it has one, otherwise the single trait overload whose trait it carries. */
+  readonly byCodecId: ReadonlyMap<string, TDescriptor>;
+  /** The overload for a call that carries no input at all. */
+  readonly noInput: TDescriptor | undefined;
+  /** The overload for any input no exact or trait overload claims. */
+  readonly anyInput: TDescriptor | undefined;
+}
+/** A codec that two trait overloads of one operation both claim, leaving its result codec undetermined. */
+interface AggregateOverloadAmbiguity {
+  readonly operation: string;
+  readonly codecId: string;
+  readonly traits: readonly CodecTrait[];
+}
+/** An `(operation, input)` key two overloads both claim. The first claim is the one settled; the second is reported here. */
+interface AggregateOverloadDuplicate<TDescriptor extends AggregateDescriptor> {
+  readonly operation: string;
+  readonly key: string;
+  readonly first: TDescriptor;
+  readonly second: TDescriptor;
+}
+interface SettledAggregateOverloads<TDescriptor extends AggregateDescriptor> {
+  readonly operations: ReadonlyMap<string, SettledAggregateOperation<TDescriptor>>;
+  readonly ambiguities: readonly AggregateOverloadAmbiguity[];
+  readonly duplicates: readonly AggregateOverloadDuplicate<TDescriptor>[];
+}
+/**
+ * Settle every contributed overload against `codecs`.
+ *
+ * Exact codec overloads win over trait overloads, and trait overloads are expanded only over the codecs given — so a caller that passes the codecs a stack actually composes cannot end up with a row for one it does not. An exact overload survives even for a codec outside that set, because naming a codec id is a claim that stands on its own.
+ *
+ * The input-agnostic overload is left unexpanded: it answers whatever the other two rungs do not, so materializing it per codec would say the same thing once per codec.
+ *
+ * A second claim on one `(operation, input)` key is reported as a duplicate and does not unseat the first; both production callers reject duplicates before settling, so the report guards a consumer that calls this directly.
+ */
+declare function settleAggregateOverloads<TDescriptor extends AggregateDescriptor>(descriptors: readonly TDescriptor[], codecs: Iterable<AggregateCodecTraits>): SettledAggregateOverloads<TDescriptor>;
+//#endregion
+export { SettledAggregateOverloads as a, SettledAggregateOperation as i, AggregateOverloadAmbiguity as n, settleAggregateOverloads as o, AggregateOverloadDuplicate as r, AggregateCodecTraits as t };
+//# sourceMappingURL=components-D7bixOE0.d.mts.map

package/dist/components-D7bixOE0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components-D7bixOE0.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/components.d.mts"],"mappings":";;;;;;UAMU;WACC;WACA,iBAAiB;;;UAGlB,0BAA0B,oBAAoB;;WAE7C,WAAW,oBAAoB;;WAE/B,SAAS;;WAET,UAAU;;;UAGX;WACC;WACA;WACA,iBAAiB;;;UAGlB,2BAA2B,oBAAoB;WAC9C;WACA;WACA,OAAO;WACP,QAAQ;;UAET,0BAA0B,oBAAoB;WAC7C,YAAY,oBAAoB,0BAA0B;WAC1D,sBAAsB;WACtB,qBAAqB,2BAA2B;;;;;;;;;;;iBAW1C,yBAAyB,oBAAoB,qBAAqB,sBAAsB,eAAe,QAAQ,SAAS,wBAAwB,0BAA0B"}

package/dist/components-ifbUGzY-.mjs

@@ -0,0 +1,88 @@
+import { t as aggregateDescriptorKey } from "./capabilities-D_lE1L0x-x4Dq0wCx.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/components.mjs
+/**
+* Settle every contributed overload against `codecs`.
+*
+* Exact codec overloads win over trait overloads, and trait overloads are expanded only over the codecs given — so a caller that passes the codecs a stack actually composes cannot end up with a row for one it does not. An exact overload survives even for a codec outside that set, because naming a codec id is a claim that stands on its own.
+*
+* The input-agnostic overload is left unexpanded: it answers whatever the other two rungs do not, so materializing it per codec would say the same thing once per codec.
+*
+* A second claim on one `(operation, input)` key is reported as a duplicate and does not unseat the first; both production callers reject duplicates before settling, so the report guards a consumer that calls this directly.
+*/
+function settleAggregateOverloads(descriptors, codecs) {
+	const byOperation = /* @__PURE__ */ new Map();
+	const firstClaims = /* @__PURE__ */ new Map();
+	const duplicates = [];
+	for (const descriptor of descriptors) {
+		const key = aggregateDescriptorKey(descriptor);
+		const first = firstClaims.get(key);
+		if (first !== void 0) {
+			duplicates.push({
+				operation: descriptor.operation,
+				key,
+				first,
+				second: descriptor
+			});
+			continue;
+		}
+		firstClaims.set(key, descriptor);
+		const entry = byOperation.get(descriptor.operation) ?? {
+			exact: /* @__PURE__ */ new Map(),
+			traits: [],
+			noInput: void 0,
+			anyInput: void 0
+		};
+		switch (descriptor.input.kind) {
+			case "none":
+				entry.noInput = descriptor;
+				break;
+			case "any":
+				entry.anyInput = descriptor;
+				break;
+			case "codec":
+				entry.exact.set(descriptor.input.codecId, descriptor);
+				break;
+			case "trait":
+				entry.traits.push({
+					descriptor,
+					trait: descriptor.input.trait
+				});
+				break;
+		}
+		byOperation.set(descriptor.operation, entry);
+	}
+	const codecList = [...codecs];
+	const operations = /* @__PURE__ */ new Map();
+	const ambiguities = [];
+	for (const [operation, entry] of byOperation) {
+		const byCodecId = new Map(entry.exact);
+		for (const codec of codecList) {
+			if (byCodecId.has(codec.codecId)) continue;
+			const claims = entry.traits.filter((candidate) => codec.traits.includes(candidate.trait));
+			if (claims.length > 1) {
+				ambiguities.push({
+					operation,
+					codecId: codec.codecId,
+					traits: claims.map((claim) => claim.trait)
+				});
+				continue;
+			}
+			const claim = claims[0];
+			if (claim !== void 0) byCodecId.set(codec.codecId, claim.descriptor);
+		}
+		operations.set(operation, {
+			byCodecId,
+			noInput: entry.noInput,
+			anyInput: entry.anyInput
+		});
+	}
+	return {
+		operations,
+		ambiguities,
+		duplicates
+	};
+}
+//#endregion
+export { settleAggregateOverloads as t };
+
+//# sourceMappingURL=components-ifbUGzY-.mjs.map

package/dist/components-ifbUGzY-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"components-ifbUGzY-.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/components.mjs"],"sourcesContent":["import { a as isNoInputAggregateDescriptor, i as isAnyInputAggregateDescriptor, n as aggregateDescriptorKey, r as isAggregateDescriptor, t as mergeCapabilityMatrices } from \"./capabilities-D_lE1L0x.mjs\";\nimport { t as checkContractComponentRequirements } from \"./framework-components-D6j4Y5K7.mjs\";\n//#region src/shared/aggregate-overloads.ts\n/**\n* Settle every contributed overload against `codecs`.\n*\n* Exact codec overloads win over trait overloads, and trait overloads are expanded only over the codecs given — so a caller that passes the codecs a stack actually composes cannot end up with a row for one it does not. An exact overload survives even for a codec outside that set, because naming a codec id is a claim that stands on its own.\n*\n* The input-agnostic overload is left unexpanded: it answers whatever the other two rungs do not, so materializing it per codec would say the same thing once per codec.\n*\n* A second claim on one `(operation, input)` key is reported as a duplicate and does not unseat the first; both production callers reject duplicates before settling, so the report guards a consumer that calls this directly.\n*/\nfunction settleAggregateOverloads(descriptors, codecs) {\n\tconst byOperation = /* @__PURE__ */ new Map();\n\tconst firstClaims = /* @__PURE__ */ new Map();\n\tconst duplicates = [];\n\tfor (const descriptor of descriptors) {\n\t\tconst key = aggregateDescriptorKey(descriptor);\n\t\tconst first = firstClaims.get(key);\n\t\tif (first !== void 0) {\n\t\t\tduplicates.push({\n\t\t\t\toperation: descriptor.operation,\n\t\t\t\tkey,\n\t\t\t\tfirst,\n\t\t\t\tsecond: descriptor\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tfirstClaims.set(key, descriptor);\n\t\tconst entry = byOperation.get(descriptor.operation) ?? {\n\t\t\texact: /* @__PURE__ */ new Map(),\n\t\t\ttraits: [],\n\t\t\tnoInput: void 0,\n\t\t\tanyInput: void 0\n\t\t};\n\t\tswitch (descriptor.input.kind) {\n\t\t\tcase \"none\":\n\t\t\t\tentry.noInput = descriptor;\n\t\t\t\tbreak;\n\t\t\tcase \"any\":\n\t\t\t\tentry.anyInput = descriptor;\n\t\t\t\tbreak;\n\t\t\tcase \"codec\":\n\t\t\t\tentry.exact.set(descriptor.input.codecId, descriptor);\n\t\t\t\tbreak;\n\t\t\tcase \"trait\":\n\t\t\t\tentry.traits.push({\n\t\t\t\t\tdescriptor,\n\t\t\t\t\ttrait: descriptor.input.trait\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t}\n\t\tbyOperation.set(descriptor.operation, entry);\n\t}\n\tconst codecList = [...codecs];\n\tconst operations = /* @__PURE__ */ new Map();\n\tconst ambiguities = [];\n\tfor (const [operation, entry] of byOperation) {\n\t\tconst byCodecId = new Map(entry.exact);\n\t\tfor (const codec of codecList) {\n\t\t\tif (byCodecId.has(codec.codecId)) continue;\n\t\t\tconst claims = entry.traits.filter((candidate) => codec.traits.includes(candidate.trait));\n\t\t\tif (claims.length > 1) {\n\t\t\t\tambiguities.push({\n\t\t\t\t\toperation,\n\t\t\t\t\tcodecId: codec.codecId,\n\t\t\t\t\ttraits: claims.map((claim) => claim.trait)\n\t\t\t\t});\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst claim = claims[0];\n\t\t\tif (claim !== void 0) byCodecId.set(codec.codecId, claim.descriptor);\n\t\t}\n\t\toperations.set(operation, {\n\t\t\tbyCodecId,\n\t\t\tnoInput: entry.noInput,\n\t\t\tanyInput: entry.anyInput\n\t\t});\n\t}\n\treturn {\n\t\toperations,\n\t\tambiguities,\n\t\tduplicates\n\t};\n}\n//#endregion\nexport { aggregateDescriptorKey, checkContractComponentRequirements, isAggregateDescriptor, isAnyInputAggregateDescriptor, isNoInputAggregateDescriptor, mergeCapabilityMatrices, settleAggregateOverloads };\n\n//# sourceMappingURL=components.mjs.map"],"mappings":";;;;;;;;;;;AAYA,SAAS,yBAAyB,aAAa,QAAQ;CACtD,MAAM,8BAA8B,IAAI,IAAI;CAC5C,MAAM,8BAA8B,IAAI,IAAI;CAC5C,MAAM,aAAa,CAAC;CACpB,KAAK,MAAM,cAAc,aAAa;EACrC,MAAM,MAAM,uBAAuB,UAAU;EAC7C,MAAM,QAAQ,YAAY,IAAI,GAAG;EACjC,IAAI,UAAU,KAAK,GAAG;GACrB,WAAW,KAAK;IACf,WAAW,WAAW;IACtB;IACA;IACA,QAAQ;GACT,CAAC;GACD;EACD;EACA,YAAY,IAAI,KAAK,UAAU;EAC/B,MAAM,QAAQ,YAAY,IAAI,WAAW,SAAS,KAAK;GACtD,uBAAuB,IAAI,IAAI;GAC/B,QAAQ,CAAC;GACT,SAAS,KAAK;GACd,UAAU,KAAK;EAChB;EACA,QAAQ,WAAW,MAAM,MAAzB;GACC,KAAK;IACJ,MAAM,UAAU;IAChB;GACD,KAAK;IACJ,MAAM,WAAW;IACjB;GACD,KAAK;IACJ,MAAM,MAAM,IAAI,WAAW,MAAM,SAAS,UAAU;IACpD;GACD,KAAK;IACJ,MAAM,OAAO,KAAK;KACjB;KACA,OAAO,WAAW,MAAM;IACzB,CAAC;IACD;EACF;EACA,YAAY,IAAI,WAAW,WAAW,KAAK;CAC5C;CACA,MAAM,YAAY,CAAC,GAAG,MAAM;CAC5B,MAAM,6BAA6B,IAAI,IAAI;CAC3C,MAAM,cAAc,CAAC;CACrB,KAAK,MAAM,CAAC,WAAW,UAAU,aAAa;EAC7C,MAAM,YAAY,IAAI,IAAI,MAAM,KAAK;EACrC,KAAK,MAAM,SAAS,WAAW;GAC9B,IAAI,UAAU,IAAI,MAAM,OAAO,GAAG;GAClC,MAAM,SAAS,MAAM,OAAO,QAAQ,cAAc,MAAM,OAAO,SAAS,UAAU,KAAK,CAAC;GACxF,IAAI,OAAO,SAAS,GAAG;IACtB,YAAY,KAAK;KAChB;KACA,SAAS,MAAM;KACf,QAAQ,OAAO,KAAK,UAAU,MAAM,KAAK;IAC1C,CAAC;IACD;GACD;GACA,MAAM,QAAQ,OAAO;GACrB,IAAI,UAAU,KAAK,GAAG,UAAU,IAAI,MAAM,SAAS,MAAM,UAAU;EACpE;EACA,WAAW,IAAI,WAAW;GACzB;GACA,SAAS,MAAM;GACf,UAAU,MAAM;EACjB,CAAC;CACF;CACA,OAAO;EACN;EACA;EACA;CACD;AACD"}

package/dist/components.d.mts

@@ -1,20 +1,20 @@
-import { a as CodecDescriptorImpl, c as CodecLookup, d as CodecTrait, f as emptyCodecLookup, i as CodecDescriptor, l as CodecRef, n as Codec, o as CodecImpl, p as voidParamsSchema, r as CodecCallContext, s as CodecInstanceContext, t as AnyCodecDescriptor, u as CodecRegistry } from "./codec-types-XJO6eC9U-B_K2q0zm.mjs";
-import { $ as hasRegisteredFieldNamespace, A as PslBlockParam, B as PslExtensionBlockParamList, C as AuthoringTemplateValue, D as AuthoringWarning, E as AuthoringTypeNamespace, F as PslDiagnosticCode, G as PslPosition, H as PslExtensionBlockParamRef, I as PslExtensionBlock, J as assertNoCrossRegistryCollisions, K as PslSpan, L as PslExtensionBlockAttribute, M as PslBlockParamOption, N as PslBlockParamRef, O as AuthoringWarningSink, P as PslBlockParamValue, Q as flushAuthoringWarnings, R as PslExtensionBlockAttributeArg, S as AuthoringStorageTypeTemplate, T as AuthoringTypeConstructorEntityRef, U as PslExtensionBlockParamScalarValue, V as PslExtensionBlockParamOption, W as PslExtensionBlockParamValue, X as classifyEnumMemberType, Y as assertResolvableTypeConstructorTemplates, Z as collectScalarTypeConstructors, _ as AuthoringModelAttributeLoweringOutput, a as AuthoringDiagnosticSink, at as isAuthoringFieldPresetDescriptor, b as AuthoringPslBlockDescriptorNamespace, c as AuthoringEntityTypeFactoryOutput, ct as isAuthoringTypeConstructorDescriptor, d as AuthoringFieldNamespace, dt as resolveEnumCodecId, et as instantiateAuthoringEntityType, f as AuthoringFieldPresetDescriptor, ft as validateAuthoringHelperArguments, g as AuthoringModelAttributeDescriptorNamespace, h as AuthoringModelAttributeDescriptor, i as AuthoringContributions, it as isAuthoringEntityTypeDescriptor, j as PslBlockParamList, k as ContributedPslDiagnosticCode, l as AuthoringEntityTypeNamespace, lt as mergeAuthoringNamespaces, m as AuthoringModelAttributeContext, n as AuthoringArgumentDescriptor, nt as instantiateAuthoringTypeConstructor, o as AuthoringEntityContext, ot as isAuthoringModelAttributeDescriptor, p as AuthoringFieldPresetOutput, q as ScalarTypeConstructorOutput, r as AuthoringColumnDefaultTemplate, rt as isAuthoringArgRef, s as AuthoringEntityTypeDescriptor, st as isAuthoringPslBlockDescriptor, t as AuthoringArgRef, tt as instantiateAuthoringFieldPreset, u as AuthoringEntityTypeTemplateOutput, ut as resolveAuthoringTemplateValue, v as AuthoringOption, w as AuthoringTypeConstructorDescriptor, x as AuthoringSelectRef, y as AuthoringPslBlockDescriptor, z as PslExtensionBlockParamBare } from "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";
-import "./authoring-Dd7p6pTS.mjs";
-import { a as ColumnTypeDescriptor, c as renderTsLiteral, i as ColumnSpec, l as resolveCodecDescriptorOrThrow, n as ColumnHelperFor, o as column, r as ColumnHelperForStrict, s as materializeCodec, t as CONTRACT_CODEC_DESCRIPTOR_MISSING, u as validateCodecTypeParams } from "./codec-D3GVAkR_.mjs";
+import { a as CodecDescriptorImpl, c as CodecLookup, d as CodecTrait, f as emptyCodecLookup, i as CodecDescriptor, l as CodecRef, n as Codec, o as CodecImpl, p as voidParamsSchema, r as CodecCallContext, s as CodecInstanceContext, t as AnyCodecDescriptor, u as CodecRegistry } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
+import { $ as hasRegisteredFieldNamespace, A as PslBlockParam, B as PslExtensionBlockParamList, C as AuthoringTemplateValue, D as AuthoringWarning, E as AuthoringTypeNamespace, F as PslDiagnosticCode, G as PslPosition, H as PslExtensionBlockParamRef, I as PslExtensionBlock, J as assertNoCrossRegistryCollisions, K as PslSpan, L as PslExtensionBlockAttribute, M as PslBlockParamOption, N as PslBlockParamRef, O as AuthoringWarningSink, P as PslBlockParamValue, Q as flushAuthoringWarnings, R as PslExtensionBlockAttributeArg, S as AuthoringStorageTypeTemplate, T as AuthoringTypeConstructorEntityRef, U as PslExtensionBlockParamScalarValue, V as PslExtensionBlockParamOption, W as PslExtensionBlockParamValue, X as classifyEnumMemberType, Y as assertResolvableTypeConstructorTemplates, Z as collectScalarTypeConstructors, _ as AuthoringModelAttributeLoweringOutput, a as AuthoringDiagnosticSink, at as isAuthoringFieldPresetDescriptor, b as AuthoringPslBlockDescriptorNamespace, c as AuthoringEntityTypeFactoryOutput, ct as isAuthoringTypeConstructorDescriptor, d as AuthoringFieldNamespace, dt as resolveEnumCodecId, et as instantiateAuthoringEntityType, f as AuthoringFieldPresetDescriptor, ft as validateAuthoringHelperArguments, g as AuthoringModelAttributeDescriptorNamespace, h as AuthoringModelAttributeDescriptor, i as AuthoringContributions, it as isAuthoringEntityTypeDescriptor, j as PslBlockParamList, k as ContributedPslDiagnosticCode, l as AuthoringEntityTypeNamespace, lt as mergeAuthoringNamespaces, m as AuthoringModelAttributeContext, n as AuthoringArgumentDescriptor, nt as instantiateAuthoringTypeConstructor, o as AuthoringEntityContext, ot as isAuthoringModelAttributeDescriptor, p as AuthoringFieldPresetOutput, q as ScalarTypeConstructorOutput, r as AuthoringColumnDefaultTemplate, rt as isAuthoringArgRef, s as AuthoringEntityTypeDescriptor, st as isAuthoringPslBlockDescriptor, t as AuthoringArgRef, tt as instantiateAuthoringFieldPreset, u as AuthoringEntityTypeTemplateOutput, ut as resolveAuthoringTemplateValue, v as AuthoringOption, w as AuthoringTypeConstructorDescriptor, x as AuthoringSelectRef, y as AuthoringPslBlockDescriptor, z as PslExtensionBlockParamBare } from "./framework-authoring--R1ZGWs1-C5F11Vhx.mjs";
+import "./authoring-ljy8m56O.mjs";
+import { a as ColumnTypeDescriptor, c as renderTsLiteral, i as ColumnSpec, l as resolveCodecDescriptorOrThrow, n as ColumnHelperFor, o as column, r as ColumnHelperForStrict, s as materializeCodec, t as CONTRACT_CODEC_DESCRIPTOR_MISSING, u as validateCodecTypeParams } from "./codec-CA00Ry1D.mjs";
+import { a as NamedAggregateOutput, c as TypesImportSpec, d as isAggregateDescriptor, f as isAnyInputAggregateDescriptor, i as AnyInputAggregateDescriptor, l as ValueInputAggregateDescriptor, n as AggregateInputMatch, o as NoInputAggregateDescriptor, p as isNoInputAggregateDescriptor, r as AggregateOutputCodec, s as SelfAggregateOutput, t as AggregateDescriptor, u as aggregateDescriptorKey } from "./types-import-spec-B4hKOPE9-BwQGG38j.mjs";
 import { n as mergeCapabilityMatrices, t as CapabilityMatrix } from "./capabilities-Cupq4-1--C71ORI3N.mjs";
-import { t as TypesImportSpec } from "./types-import-spec-DRKzrJ20-WYwyCtil.mjs";
-import { A as TargetPackRef, C as MutationDefaultGeneratorDescriptor, D as TargetBoundComponentDescriptor, E as SourceSpan, M as checkContractComponentRequirements, O as TargetDescriptor, S as LoweredDefaultValue, T as SourceDiagnostic, _ as ExtensionPackRef, a as ComponentMetadata, b as FamilyPackRef, c as ControlMutationDefaultEntry, d as DefaultFunctionLoweringContext, f as DriverDescriptor, g as ExtensionInstance, h as ExtensionDescriptor, i as ComponentDescriptor, j as TypedDefaultFunctionCall, k as TargetInstance, l as ControlMutationDefaultRegistry, m as DriverPackRef, n as AdapterInstance, o as ContractComponentRequirementsCheckInput, p as DriverInstance, r as AdapterPackRef, s as ContractComponentRequirementsCheckResult, t as AdapterDescriptor, u as ControlMutationDefaults, v as FamilyDescriptor, w as PackRefBase, x as LoweredDefaultResult, y as FamilyInstance } from "./framework-components-MFoo0sYx-G_6k9jt4.mjs";
-import "./components-CawuxTia.mjs";
-import { a as keepInternalSpecifiers, i as ValidationContext, n as GenerateContractTypesOptions, o as resolveRequirementSpecifiers, r as ImportSpecifierResolver, t as EmissionSpi } from "./emission-types-hfRVB_Yw-DpQ3hISB.mjs";
-import { A as makePslNamespace, C as PslReferentialAction, D as UNSPECIFIED_PSL_NAMESPACE_ID, E as PslUniqueConstraint, M as namespacePslExtensionBlocks, O as flatPslCompositeTypes, S as PslNamespaceEntry, T as PslTypesBlock, _ as PslIndexConstraint, a as PslAttributeArgument, b as PslNamedTypeDeclaration, c as PslAttributeTarget, d as PslDefaultLiteralValue, f as PslDefaultValue, g as PslFieldAttribute, h as PslField, i as PslAttribute, j as makePslNamespaceEntries, k as flatPslModels, l as PslCompositeType, m as PslDocumentAst, n as ParsePslDocumentInput, o as PslAttributeNamedArgument, p as PslDiagnostic, r as ParsePslDocumentResult, s as PslAttributePositionalArgument, t as BUILTIN_PSL_KIND_KEYS, u as PslDefaultFunctionValue, v as PslModel, w as PslTypeConstructorCall, x as PslNamespace, y as PslModelAttribute } from "./psl-ast-Chgi8e4o-rSlBk1UV.mjs";
+import { A as TargetPackRef, C as MutationDefaultGeneratorDescriptor, D as TargetBoundComponentDescriptor, E as SourceSpan, M as checkContractComponentRequirements, O as TargetDescriptor, S as LoweredDefaultValue, T as SourceDiagnostic, _ as ExtensionPackRef, a as ComponentMetadata, b as FamilyPackRef, c as ControlMutationDefaultEntry, d as DefaultFunctionLoweringContext, f as DriverDescriptor, g as ExtensionInstance, h as ExtensionDescriptor, i as ComponentDescriptor, j as TypedDefaultFunctionCall, k as TargetInstance, l as ControlMutationDefaultRegistry, m as DriverPackRef, n as AdapterInstance, o as ContractComponentRequirementsCheckInput, p as DriverInstance, r as AdapterPackRef, s as ContractComponentRequirementsCheckResult, t as AdapterDescriptor, u as ControlMutationDefaults, v as FamilyDescriptor, w as PackRefBase, x as LoweredDefaultResult, y as FamilyInstance } from "./framework-components-BQ_fYHtC-Co52pfO-.mjs";
+import { a as SettledAggregateOverloads, i as SettledAggregateOperation, n as AggregateOverloadAmbiguity, o as settleAggregateOverloads, r as AggregateOverloadDuplicate, t as AggregateCodecTraits } from "./components-D7bixOE0.mjs";
+import { a as keepInternalSpecifiers, i as ValidationContext, n as GenerateContractTypesOptions, o as resolveRequirementSpecifiers, r as ImportSpecifierResolver, t as EmissionSpi } from "./emission-types-6jLF1pS8-BZlRi3Ma.mjs";
+import { A as makePslNamespace, C as PslReferentialAction, D as UNSPECIFIED_PSL_NAMESPACE_ID, E as PslUniqueConstraint, M as namespacePslExtensionBlocks, O as flatPslCompositeTypes, S as PslNamespaceEntry, T as PslTypesBlock, _ as PslIndexConstraint, a as PslAttributeArgument, b as PslNamedTypeDeclaration, c as PslAttributeTarget, d as PslDefaultLiteralValue, f as PslDefaultValue, g as PslFieldAttribute, h as PslField, i as PslAttribute, j as makePslNamespaceEntries, k as flatPslModels, l as PslCompositeType, m as PslDocumentAst, n as ParsePslDocumentInput, o as PslAttributeNamedArgument, p as PslDiagnostic, r as ParsePslDocumentResult, s as PslAttributePositionalArgument, t as BUILTIN_PSL_KIND_KEYS, u as PslDefaultFunctionValue, v as PslModel, w as PslTypeConstructorCall, x as PslNamespace, y as PslModelAttribute } from "./psl-ast-C4IAv2T_-CO0jh_VK.mjs";
 import { t as ImportRequirement } from "./index-GY2oGH9L.mjs";
-import { $ as SchemaDiffIssue, A as MigrationPlan, At as diffSchemas, B as MigrationRunnerFailure, Bt as hasSchemaView, C as ExpectationFailureReason, Ct as assembleAuthoringContributions, D as MigrationOperationClass, Dt as contractSnapshotJsonSpecifier, E as MigrationMetadata, Et as buildExtensionLoadOrder, F as MigrationPlannerFailureResult, Ft as extractQueryOperationTypeImports, G as MigrationScaffoldContext, H as MigrationRunnerPerSpaceSuccessValue, Ht as orderIssuesByDependencies, I as MigrationPlannerResult, It as hasMigrations, J as OperationPreview, K as OpFactoryCall, L as MigrationPlannerSuccessResult, Lt as hasOperationPreview, M as MigrationPlanWithAuthoringSurface, Mt as extractCodecLookup, N as MigrationPlanner, Nt as extractCodecTypeImports, O as MigrationOperationPolicy, Ot as contractSnapshotTypesSpecifier, P as MigrationPlannerConflict, Pt as extractComponentIds, Q as SchemaDiff, R as MigrationRunner, Rt as hasPslContractInfer, S as EmitContractResult, St as VerifyDatabaseSchemaResult, T as MigratableTargetDescriptor, Tt as assertUniqueCodecOwner, U as MigrationRunnerResult, Ut as storageHashHex, V as MigrationRunnerPerSpaceOptions, Vt as issueOutcome, W as MigrationRunnerSuccessValue, X as OperationPreviewStatement, Y as OperationPreviewCapable, Z as PslContractInferCapable, _ as ControlTargetInstance, _t as VERIFY_CODE_TARGET_MISMATCH, a as ContractSpace, at as SchemaTreeNodeOptions, b as DiffSubjectGranularity, bt as VerifierOutcome, c as ControlAdapterInstance, ct as SchemaVerifyOptions, d as ControlExtensionDescriptor, dt as SchemaViewNodeKind, et as SchemaEntityCoordinate, f as ControlExtensionInstance, ft as SignDatabaseResult, g as ControlTargetDescriptor, gt as VERIFY_CODE_SCHEMA_FAILURE, h as ControlStack, ht as VERIFY_CODE_MARKER_MISSING, i as ContractSerializer, it as SchemaTreeNode, j as MigrationPlanOperation, jt as dispositionForCategory, k as MigrationPackage, kt as createControlStack, l as ControlDriverDescriptor, lt as SchemaVerifyResult, m as ControlFamilyInstance, mt as VERIFY_CODE_HASH_MISMATCH, n as AssembledAuthoringContributions, nt as SchemaOwnership, o as ContractSpaceHeadRef, ot as SchemaTreeVisitor, p as ControlFamilyDescriptor, pt as TargetMigrationsCapability, q as OperationContext, r as CONTRACT_SNAPSHOTS_DIRNAME, rt as SchemaSubjectClassifierCapable, s as ControlAdapterDescriptor, st as SchemaVerifier, t as APP_SPACE_ID, tt as SchemaNodeRef, u as ControlDriverInstance, ut as SchemaViewCapable, v as CoreSchemaView, vt as VerificationStatus, w as IntrospectSchemaResult, wt as assembleControlMutationDefaults, x as DiffableNode, xt as VerifyDatabaseResult, y as CreateControlStackInput, yt as VerifierIssueCategory, z as MigrationRunnerExecutionChecks, zt as hasSchemaSubjectClassifier } from "./control-CBvTj7Ia.mjs";
-import "./emission-DeoQufVd.mjs";
-import { a as RuntimeDriverDescriptor, c as RuntimeExtensionInstance, d as RuntimeTargetDescriptor, f as RuntimeTargetInstance, h as instantiateExecutionStack, i as RuntimeAdapterInstance, l as RuntimeFamilyDescriptor, m as createExecutionStack, n as ExecutionStackInstance, o as RuntimeDriverInstance, p as assertRuntimeContractRequirementsSatisfied, r as RuntimeAdapterDescriptor, s as RuntimeExtensionDescriptor, t as ExecutionStack, u as RuntimeFamilyInstance } from "./execution-Bo5Bu2Ys.mjs";
+import { $ as SchemaDiffIssue, A as MigrationPlan, At as diffSchemas, B as MigrationRunnerFailure, Bt as hasSchemaView, C as ExpectationFailureReason, Ct as assembleAuthoringContributions, D as MigrationOperationClass, Dt as contractSnapshotJsonSpecifier, E as MigrationMetadata, Et as buildExtensionLoadOrder, F as MigrationPlannerFailureResult, Ft as extractQueryOperationTypeImports, G as MigrationScaffoldContext, H as MigrationRunnerPerSpaceSuccessValue, Ht as orderIssuesByDependencies, I as MigrationPlannerResult, It as hasMigrations, J as OperationPreview, K as OpFactoryCall, L as MigrationPlannerSuccessResult, Lt as hasOperationPreview, M as MigrationPlanWithAuthoringSurface, Mt as extractCodecLookup, N as MigrationPlanner, Nt as extractCodecTypeImports, O as MigrationOperationPolicy, Ot as contractSnapshotTypesSpecifier, P as MigrationPlannerConflict, Pt as extractComponentIds, Q as SchemaDiff, R as MigrationRunner, Rt as hasPslContractInfer, S as EmitContractResult, St as VerifyDatabaseSchemaResult, T as MigratableTargetDescriptor, Tt as assertUniqueCodecOwner, U as MigrationRunnerResult, Ut as storageHashHex, V as MigrationRunnerPerSpaceOptions, Vt as issueOutcome, W as MigrationRunnerSuccessValue, X as OperationPreviewStatement, Y as OperationPreviewCapable, Z as PslContractInferCapable, _ as ControlTargetInstance, _t as VERIFY_CODE_TARGET_MISMATCH, a as ContractSpace, at as SchemaTreeNodeOptions, b as DiffSubjectGranularity, bt as VerifierOutcome, c as ControlAdapterInstance, ct as SchemaVerifyOptions, d as ControlExtensionDescriptor, dt as SchemaViewNodeKind, et as SchemaEntityCoordinate, f as ControlExtensionInstance, ft as SignDatabaseResult, g as ControlTargetDescriptor, gt as VERIFY_CODE_SCHEMA_FAILURE, h as ControlStack, ht as VERIFY_CODE_MARKER_MISSING, i as ContractSerializer, it as SchemaTreeNode, j as MigrationPlanOperation, jt as dispositionForCategory, k as MigrationPackage, kt as createControlStack, l as ControlDriverDescriptor, lt as SchemaVerifyResult, m as ControlFamilyInstance, mt as VERIFY_CODE_HASH_MISMATCH, n as AssembledAuthoringContributions, nt as SchemaOwnership, o as ContractSpaceHeadRef, ot as SchemaTreeVisitor, p as ControlFamilyDescriptor, pt as TargetMigrationsCapability, q as OperationContext, r as CONTRACT_SNAPSHOTS_DIRNAME, rt as SchemaSubjectClassifierCapable, s as ControlAdapterDescriptor, st as SchemaVerifier, t as APP_SPACE_ID, tt as SchemaNodeRef, u as ControlDriverInstance, ut as SchemaViewCapable, v as CoreSchemaView, vt as VerificationStatus, w as IntrospectSchemaResult, wt as assembleControlMutationDefaults, x as DiffableNode, xt as VerifyDatabaseResult, y as CreateControlStackInput, yt as VerifierIssueCategory, z as MigrationRunnerExecutionChecks, zt as hasSchemaSubjectClassifier } from "./control-BqePKqXl.mjs";
+import "./emission-PUUc-DK4.mjs";
+import { a as RuntimeDriverDescriptor, c as RuntimeExtensionInstance, d as RuntimeTargetDescriptor, f as RuntimeTargetInstance, h as instantiateExecutionStack, i as RuntimeAdapterInstance, l as RuntimeFamilyDescriptor, m as createExecutionStack, n as ExecutionStackInstance, o as RuntimeDriverInstance, p as assertRuntimeContractRequirementsSatisfied, r as RuntimeAdapterDescriptor, s as RuntimeExtensionDescriptor, t as ExecutionStack, u as RuntimeFamilyInstance } from "./execution-BZIwXeq-.mjs";
 import { t as isPlainRecord } from "./is-plain-record-C9BWiqcw.mjs";
 import { S as promoteBuiltinKinds, _ as domainElementCoordinates, a as IRNode, b as freezeNode, c as NamespaceBase, d as Storage, f as StorageType, g as coordinateKey, h as buildSingleNamespaceView, i as EntityKindDescriptor, l as NamespacedEntities, m as buildNamespacedEntities, n as DefaultNamespaceEntries, o as IRNodeBase, p as UNBOUND_NAMESPACE_ID, r as EntityCoordinate, s as Namespace, t as AnyEntityKindDescriptor, u as SingleNamespaceView, v as elementCoordinates, x as hydrateNamespaceEntities, y as entityAt } from "./ir-BvE7L9FK.mjs";
-import { n as validateExtensionBlock, t as ExtensionBlockRefResolutionContext } from "./psl-ast-BEwO80EH.mjs";
-import { A as defineAnnotation, C as RuntimeMiddleware, D as checkAborted, E as assertAnnotationsApplicable, F as runtimeAborted, I as runtimeError, M as raceAgainstAbort, N as runBeforeExecuteChain, O as checkMiddlewareCompatibility, P as runWithMiddleware, S as RuntimeLog, T as ValidAnnotations, _ as RuntimeCore, a as CrossFamilyMiddleware, b as RuntimeExecuteOptions, c as InterceptResult, d as OperationKind, f as ParamRefMutator, g as RuntimeAbortedPhase, h as ResultType, i as AsyncIterableResult, j as isRuntimeError, k as createMetaBuilder, l as LaneMetaBuilder, m as RUNTIME_ABORTED, n as AnnotationHandle, o as DefineAnnotationOptions, p as QueryPlan, r as AnnotationValue, s as ExecutionPlan, t as AfterExecuteResult, u as MetaBuilder, v as RuntimeCoreOptions, w as RuntimeMiddlewareContext, x as RuntimeExecutor, y as RuntimeErrorEnvelope } from "./runtime--RZXG1zP.mjs";
+import { n as validateExtensionBlock, t as ExtensionBlockRefResolutionContext } from "./psl-ast-DAMpjVOP.mjs";
+import { A as defineAnnotation, C as RuntimeMiddleware, D as checkAborted, E as assertAnnotationsApplicable, F as runtimeAborted, I as runtimeError, M as raceAgainstAbort, N as runBeforeExecuteChain, O as checkMiddlewareCompatibility, P as runWithMiddleware, S as RuntimeLog, T as ValidAnnotations, _ as RuntimeCore, a as CrossFamilyMiddleware, b as RuntimeExecuteOptions, c as InterceptResult, d as OperationKind, f as ParamRefMutator, g as RuntimeAbortedPhase, h as ResultType, i as AsyncIterableResult, j as isRuntimeError, k as createMetaBuilder, l as LaneMetaBuilder, m as RUNTIME_ABORTED, n as AnnotationHandle, o as DefineAnnotationOptions, p as QueryPlan, r as AnnotationValue, s as ExecutionPlan, t as AfterExecuteResult, u as MetaBuilder, v as RuntimeCoreOptions, w as RuntimeMiddlewareContext, x as RuntimeExecutor, y as RuntimeErrorEnvelope } from "./runtime-Cne6hBaG.mjs";
 import { t as canonicalizeJson } from "./utils-DeWL_zD9.mjs";
-export { APP_SPACE_ID, type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type AfterExecuteResult, type AnnotationHandle, type AnnotationValue, type AnyCodecDescriptor, type AnyEntityKindDescriptor, type AssembledAuthoringContributions, AsyncIterableResult, type AuthoringArgRef, type AuthoringArgumentDescriptor, type AuthoringColumnDefaultTemplate, type AuthoringContributions, type AuthoringDiagnosticSink, type AuthoringEntityContext, type AuthoringEntityTypeDescriptor, type AuthoringEntityTypeFactoryOutput, type AuthoringEntityTypeNamespace, type AuthoringEntityTypeTemplateOutput, type AuthoringFieldNamespace, type AuthoringFieldPresetDescriptor, type AuthoringFieldPresetOutput, type AuthoringModelAttributeContext, type AuthoringModelAttributeDescriptor, type AuthoringModelAttributeDescriptorNamespace, type AuthoringModelAttributeLoweringOutput, type AuthoringOption, type AuthoringPslBlockDescriptor, type AuthoringPslBlockDescriptorNamespace, type AuthoringSelectRef, type AuthoringStorageTypeTemplate, type AuthoringTemplateValue, type AuthoringTypeConstructorDescriptor, type AuthoringTypeConstructorEntityRef, type AuthoringTypeNamespace, type AuthoringWarning, type AuthoringWarningSink, BUILTIN_PSL_KIND_KEYS, CONTRACT_CODEC_DESCRIPTOR_MISSING, CONTRACT_SNAPSHOTS_DIRNAME, type CapabilityMatrix, type Codec, type CodecCallContext, type CodecDescriptor, CodecDescriptorImpl, CodecImpl, type CodecInstanceContext, type CodecLookup, type CodecRef, type CodecRegistry, type CodecTrait, type ColumnHelperFor, type ColumnHelperForStrict, type ColumnSpec, type ColumnTypeDescriptor, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type ContractSerializer, type ContractSpace, type ContractSpaceHeadRef, type ContributedPslDiagnosticCode, type ControlAdapterDescriptor, type ControlAdapterInstance, type ControlDriverDescriptor, type ControlDriverInstance, type ControlExtensionDescriptor, type ControlExtensionInstance, type ControlFamilyDescriptor, type ControlFamilyInstance, type ControlMutationDefaultEntry, type ControlMutationDefaultRegistry, type ControlMutationDefaults, type ControlStack, type ControlTargetDescriptor, type ControlTargetInstance, type CoreSchemaView, type CreateControlStackInput, type CrossFamilyMiddleware, type DefaultFunctionLoweringContext, type DefaultNamespaceEntries, type DefineAnnotationOptions, type DiffSubjectGranularity, type DiffableNode, type DriverDescriptor, type DriverInstance, type DriverPackRef, type EmissionSpi, type EmitContractResult, type EntityCoordinate, type EntityKindDescriptor, type ExecutionPlan, type ExecutionStack, type ExecutionStackInstance, type ExpectationFailureReason, type ExtensionBlockRefResolutionContext, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type FamilyPackRef, type GenerateContractTypesOptions, type IRNode, IRNodeBase, type ImportRequirement, type ImportSpecifierResolver, type InterceptResult, type IntrospectSchemaResult, type LaneMetaBuilder, type LoweredDefaultResult, type LoweredDefaultValue, type MetaBuilder, type MigratableTargetDescriptor, type MigrationMetadata, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPackage, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanWithAuthoringSurface, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerFailureResult, type MigrationPlannerResult, type MigrationPlannerSuccessResult, type MigrationRunner, type MigrationRunnerExecutionChecks, type MigrationRunnerFailure, type MigrationRunnerPerSpaceOptions, type MigrationRunnerPerSpaceSuccessValue, type MigrationRunnerResult, type MigrationRunnerSuccessValue, type MigrationScaffoldContext, type MutationDefaultGeneratorDescriptor, type Namespace, NamespaceBase, type NamespacedEntities, type OpFactoryCall, type OperationContext, type OperationKind, type OperationPreview, type OperationPreviewCapable, type OperationPreviewStatement, type PackRefBase, type ParamRefMutator, ParsePslDocumentInput, ParsePslDocumentResult, PslAttribute, PslAttributeArgument, PslAttributeNamedArgument, PslAttributePositionalArgument, PslAttributeTarget, type PslBlockParam, type PslBlockParamList, type PslBlockParamOption, type PslBlockParamRef, type PslBlockParamValue, PslCompositeType, type PslContractInferCapable, PslDefaultFunctionValue, PslDefaultLiteralValue, PslDefaultValue, PslDiagnostic, type PslDiagnosticCode, PslDocumentAst, type PslExtensionBlock, type PslExtensionBlockAttribute, type PslExtensionBlockAttributeArg, type PslExtensionBlockParamBare, type PslExtensionBlockParamList, type PslExtensionBlockParamOption, type PslExtensionBlockParamRef, type PslExtensionBlockParamScalarValue, type PslExtensionBlockParamValue, PslField, PslFieldAttribute, PslIndexConstraint, PslModel, PslModelAttribute, PslNamedTypeDeclaration, PslNamespace, PslNamespaceEntry, type PslPosition, PslReferentialAction, type PslSpan, PslTypeConstructorCall, PslTypesBlock, PslUniqueConstraint, type QueryPlan, RUNTIME_ABORTED, type ResultType, type RuntimeAbortedPhase, type RuntimeAdapterDescriptor, type RuntimeAdapterInstance, RuntimeCore, type RuntimeCoreOptions, type RuntimeDriverDescriptor, type RuntimeDriverInstance, type RuntimeErrorEnvelope, type RuntimeExecuteOptions, type RuntimeExecutor, type RuntimeExtensionDescriptor, type RuntimeExtensionInstance, type RuntimeFamilyDescriptor, type RuntimeFamilyInstance, type RuntimeLog, type RuntimeMiddleware, type RuntimeMiddlewareContext, type RuntimeTargetDescriptor, type RuntimeTargetInstance, type ScalarTypeConstructorOutput, SchemaDiff, type SchemaDiffIssue, type SchemaEntityCoordinate, type SchemaNodeRef, type SchemaOwnership, type SchemaSubjectClassifierCapable, SchemaTreeNode, type SchemaTreeNodeOptions, type SchemaTreeVisitor, type SchemaVerifier, type SchemaVerifyOptions, type SchemaVerifyResult, type SchemaViewCapable, type SchemaViewNodeKind, type SignDatabaseResult, type SingleNamespaceView, type SourceDiagnostic, type SourceSpan, type Storage, type StorageType, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetMigrationsCapability, type TargetPackRef, type TypedDefaultFunctionCall, type TypesImportSpec, UNBOUND_NAMESPACE_ID, UNSPECIFIED_PSL_NAMESPACE_ID, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH, type ValidAnnotations, type ValidationContext, type VerificationStatus, type VerifierIssueCategory, type VerifierOutcome, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, assembleAuthoringContributions, assembleControlMutationDefaults, assertAnnotationsApplicable, assertNoCrossRegistryCollisions, assertResolvableTypeConstructorTemplates, assertRuntimeContractRequirementsSatisfied, assertUniqueCodecOwner, buildExtensionLoadOrder, buildNamespacedEntities, buildSingleNamespaceView, canonicalizeJson, checkAborted, checkContractComponentRequirements, checkMiddlewareCompatibility, classifyEnumMemberType, collectScalarTypeConstructors, column, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, coordinateKey, createControlStack, createExecutionStack, createMetaBuilder, defineAnnotation, diffSchemas, dispositionForCategory, domainElementCoordinates, elementCoordinates, emptyCodecLookup, entityAt, extractCodecLookup, extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports, flatPslCompositeTypes, flatPslModels, flushAuthoringWarnings, freezeNode, hasMigrations, hasOperationPreview, hasPslContractInfer, hasRegisteredFieldNamespace, hasSchemaSubjectClassifier, hasSchemaView, hydrateNamespaceEntities, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, instantiateExecutionStack, isAuthoringArgRef, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, isPlainRecord, isRuntimeError, issueOutcome, keepInternalSpecifiers, makePslNamespace, makePslNamespaceEntries, materializeCodec, mergeAuthoringNamespaces, mergeCapabilityMatrices, namespacePslExtensionBlocks, orderIssuesByDependencies, promoteBuiltinKinds, raceAgainstAbort, renderTsLiteral, resolveAuthoringTemplateValue, resolveCodecDescriptorOrThrow, resolveEnumCodecId, resolveRequirementSpecifiers, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError, storageHashHex, validateAuthoringHelperArguments, validateCodecTypeParams, validateExtensionBlock, voidParamsSchema };
+export { APP_SPACE_ID, type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type AfterExecuteResult, type AggregateCodecTraits, type AggregateDescriptor, type AggregateInputMatch, type AggregateOutputCodec, type AggregateOverloadAmbiguity, type AggregateOverloadDuplicate, type AnnotationHandle, type AnnotationValue, type AnyCodecDescriptor, type AnyEntityKindDescriptor, type AnyInputAggregateDescriptor, type AssembledAuthoringContributions, AsyncIterableResult, type AuthoringArgRef, type AuthoringArgumentDescriptor, type AuthoringColumnDefaultTemplate, type AuthoringContributions, type AuthoringDiagnosticSink, type AuthoringEntityContext, type AuthoringEntityTypeDescriptor, type AuthoringEntityTypeFactoryOutput, type AuthoringEntityTypeNamespace, type AuthoringEntityTypeTemplateOutput, type AuthoringFieldNamespace, type AuthoringFieldPresetDescriptor, type AuthoringFieldPresetOutput, type AuthoringModelAttributeContext, type AuthoringModelAttributeDescriptor, type AuthoringModelAttributeDescriptorNamespace, type AuthoringModelAttributeLoweringOutput, type AuthoringOption, type AuthoringPslBlockDescriptor, type AuthoringPslBlockDescriptorNamespace, type AuthoringSelectRef, type AuthoringStorageTypeTemplate, type AuthoringTemplateValue, type AuthoringTypeConstructorDescriptor, type AuthoringTypeConstructorEntityRef, type AuthoringTypeNamespace, type AuthoringWarning, type AuthoringWarningSink, BUILTIN_PSL_KIND_KEYS, CONTRACT_CODEC_DESCRIPTOR_MISSING, CONTRACT_SNAPSHOTS_DIRNAME, type CapabilityMatrix, type Codec, type CodecCallContext, type CodecDescriptor, CodecDescriptorImpl, CodecImpl, type CodecInstanceContext, type CodecLookup, type CodecRef, type CodecRegistry, type CodecTrait, type ColumnHelperFor, type ColumnHelperForStrict, type ColumnSpec, type ColumnTypeDescriptor, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type ContractSerializer, type ContractSpace, type ContractSpaceHeadRef, type ContributedPslDiagnosticCode, type ControlAdapterDescriptor, type ControlAdapterInstance, type ControlDriverDescriptor, type ControlDriverInstance, type ControlExtensionDescriptor, type ControlExtensionInstance, type ControlFamilyDescriptor, type ControlFamilyInstance, type ControlMutationDefaultEntry, type ControlMutationDefaultRegistry, type ControlMutationDefaults, type ControlStack, type ControlTargetDescriptor, type ControlTargetInstance, type CoreSchemaView, type CreateControlStackInput, type CrossFamilyMiddleware, type DefaultFunctionLoweringContext, type DefaultNamespaceEntries, type DefineAnnotationOptions, type DiffSubjectGranularity, type DiffableNode, type DriverDescriptor, type DriverInstance, type DriverPackRef, type EmissionSpi, type EmitContractResult, type EntityCoordinate, type EntityKindDescriptor, type ExecutionPlan, type ExecutionStack, type ExecutionStackInstance, type ExpectationFailureReason, type ExtensionBlockRefResolutionContext, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type FamilyPackRef, type GenerateContractTypesOptions, type IRNode, IRNodeBase, type ImportRequirement, type ImportSpecifierResolver, type InterceptResult, type IntrospectSchemaResult, type LaneMetaBuilder, type LoweredDefaultResult, type LoweredDefaultValue, type MetaBuilder, type MigratableTargetDescriptor, type MigrationMetadata, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPackage, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanWithAuthoringSurface, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerFailureResult, type MigrationPlannerResult, type MigrationPlannerSuccessResult, type MigrationRunner, type MigrationRunnerExecutionChecks, type MigrationRunnerFailure, type MigrationRunnerPerSpaceOptions, type MigrationRunnerPerSpaceSuccessValue, type MigrationRunnerResult, type MigrationRunnerSuccessValue, type MigrationScaffoldContext, type MutationDefaultGeneratorDescriptor, type NamedAggregateOutput, type Namespace, NamespaceBase, type NamespacedEntities, type NoInputAggregateDescriptor, type OpFactoryCall, type OperationContext, type OperationKind, type OperationPreview, type OperationPreviewCapable, type OperationPreviewStatement, type PackRefBase, type ParamRefMutator, ParsePslDocumentInput, ParsePslDocumentResult, PslAttribute, PslAttributeArgument, PslAttributeNamedArgument, PslAttributePositionalArgument, PslAttributeTarget, type PslBlockParam, type PslBlockParamList, type PslBlockParamOption, type PslBlockParamRef, type PslBlockParamValue, PslCompositeType, type PslContractInferCapable, PslDefaultFunctionValue, PslDefaultLiteralValue, PslDefaultValue, PslDiagnostic, type PslDiagnosticCode, PslDocumentAst, type PslExtensionBlock, type PslExtensionBlockAttribute, type PslExtensionBlockAttributeArg, type PslExtensionBlockParamBare, type PslExtensionBlockParamList, type PslExtensionBlockParamOption, type PslExtensionBlockParamRef, type PslExtensionBlockParamScalarValue, type PslExtensionBlockParamValue, PslField, PslFieldAttribute, PslIndexConstraint, PslModel, PslModelAttribute, PslNamedTypeDeclaration, PslNamespace, PslNamespaceEntry, type PslPosition, PslReferentialAction, type PslSpan, PslTypeConstructorCall, PslTypesBlock, PslUniqueConstraint, type QueryPlan, RUNTIME_ABORTED, type ResultType, type RuntimeAbortedPhase, type RuntimeAdapterDescriptor, type RuntimeAdapterInstance, RuntimeCore, type RuntimeCoreOptions, type RuntimeDriverDescriptor, type RuntimeDriverInstance, type RuntimeErrorEnvelope, type RuntimeExecuteOptions, type RuntimeExecutor, type RuntimeExtensionDescriptor, type RuntimeExtensionInstance, type RuntimeFamilyDescriptor, type RuntimeFamilyInstance, type RuntimeLog, type RuntimeMiddleware, type RuntimeMiddlewareContext, type RuntimeTargetDescriptor, type RuntimeTargetInstance, type ScalarTypeConstructorOutput, SchemaDiff, type SchemaDiffIssue, type SchemaEntityCoordinate, type SchemaNodeRef, type SchemaOwnership, type SchemaSubjectClassifierCapable, SchemaTreeNode, type SchemaTreeNodeOptions, type SchemaTreeVisitor, type SchemaVerifier, type SchemaVerifyOptions, type SchemaVerifyResult, type SchemaViewCapable, type SchemaViewNodeKind, type SelfAggregateOutput, type SettledAggregateOperation, type SettledAggregateOverloads, type SignDatabaseResult, type SingleNamespaceView, type SourceDiagnostic, type SourceSpan, type Storage, type StorageType, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetMigrationsCapability, type TargetPackRef, type TypedDefaultFunctionCall, type TypesImportSpec, UNBOUND_NAMESPACE_ID, UNSPECIFIED_PSL_NAMESPACE_ID, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH, type ValidAnnotations, type ValidationContext, type ValueInputAggregateDescriptor, type VerificationStatus, type VerifierIssueCategory, type VerifierOutcome, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, aggregateDescriptorKey, assembleAuthoringContributions, assembleControlMutationDefaults, assertAnnotationsApplicable, assertNoCrossRegistryCollisions, assertResolvableTypeConstructorTemplates, assertRuntimeContractRequirementsSatisfied, assertUniqueCodecOwner, buildExtensionLoadOrder, buildNamespacedEntities, buildSingleNamespaceView, canonicalizeJson, checkAborted, checkContractComponentRequirements, checkMiddlewareCompatibility, classifyEnumMemberType, collectScalarTypeConstructors, column, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, coordinateKey, createControlStack, createExecutionStack, createMetaBuilder, defineAnnotation, diffSchemas, dispositionForCategory, domainElementCoordinates, elementCoordinates, emptyCodecLookup, entityAt, extractCodecLookup, extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports, flatPslCompositeTypes, flatPslModels, flushAuthoringWarnings, freezeNode, hasMigrations, hasOperationPreview, hasPslContractInfer, hasRegisteredFieldNamespace, hasSchemaSubjectClassifier, hasSchemaView, hydrateNamespaceEntities, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, instantiateExecutionStack, isAggregateDescriptor, isAnyInputAggregateDescriptor, isAuthoringArgRef, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, isNoInputAggregateDescriptor, isPlainRecord, isRuntimeError, issueOutcome, keepInternalSpecifiers, makePslNamespace, makePslNamespaceEntries, materializeCodec, mergeAuthoringNamespaces, mergeCapabilityMatrices, namespacePslExtensionBlocks, orderIssuesByDependencies, promoteBuiltinKinds, raceAgainstAbort, renderTsLiteral, resolveAuthoringTemplateValue, resolveCodecDescriptorOrThrow, resolveEnumCodecId, resolveRequirementSpecifiers, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError, settleAggregateOverloads, storageHashHex, validateAuthoringHelperArguments, validateCodecTypeParams, validateExtensionBlock, voidParamsSchema };

package/dist/components.mjs

@@ -1,15 +1,17 @@
 import { t as isPlainRecord } from "./is-plain-record-CUofyVQ7-DWEzdhIx.mjs";
 import { n as runtimeError, t as isRuntimeError } from "./runtime-error-BA9d7XjZ-BlT8t6LB.mjs";
 import { _ as mergeAuthoringNamespaces, a as collectScalarTypeConstructors, b as validateAuthoringHelperArguments, c as instantiateAuthoringEntityType, d as isAuthoringArgRef, f as isAuthoringEntityTypeDescriptor, g as isAuthoringTypeConstructorDescriptor, h as isAuthoringPslBlockDescriptor, l as instantiateAuthoringFieldPreset, m as isAuthoringModelAttributeDescriptor, n as assertResolvableTypeConstructorTemplates, o as flushAuthoringWarnings, p as isAuthoringFieldPresetDescriptor, r as classifyEnumMemberType, s as hasRegisteredFieldNamespace, t as assertNoCrossRegistryCollisions, u as instantiateAuthoringTypeConstructor, v as resolveAuthoringTemplateValue, y as resolveEnumCodecId } from "./framework-authoring-CDEvlouU-mlMWSksD.mjs";
+import { r as voidParamsSchema, t as emptyCodecLookup } from "./codec-types-DcNvNeY1-BO6kUiH0.mjs";
 import { i as validateCodecTypeParams, n as materializeCodec, r as resolveCodecDescriptorOrThrow, t as CONTRACT_CODEC_DESCRIPTOR_MISSING } from "./resolve-codec-BZF8TZh_-D-xORT9Q.mjs";
-import { a as renderTsLiteral, i as emptyCodecLookup, n as CodecImpl, o as voidParamsSchema, r as column, t as CodecDescriptorImpl } from "./codec-Cly9VPoA.mjs";
-import { t as mergeCapabilityMatrices } from "./capabilities-CPj7MfXO-GRkp0Q_D.mjs";
+import { i as renderTsLiteral, n as CodecImpl, r as column, t as CodecDescriptorImpl } from "./codec-BgOWqkHY.mjs";
+import { a as mergeCapabilityMatrices, i as isNoInputAggregateDescriptor, n as isAggregateDescriptor, r as isAnyInputAggregateDescriptor, t as aggregateDescriptorKey } from "./capabilities-D_lE1L0x-x4Dq0wCx.mjs";
 import { t as checkContractComponentRequirements } from "./framework-components-D6j4Y5K7-RW9H184y.mjs";
-import { C as hasOperationPreview, D as issueOutcome, E as hasSchemaView, O as orderIssuesByDependencies, S as hasMigrations, T as hasSchemaSubjectClassifier, _ as dispositionForCategory, a as VERIFY_CODE_HASH_MISMATCH, b as extractComponentIds, c as VERIFY_CODE_TARGET_MISMATCH, d as assertUniqueCodecOwner, f as buildExtensionLoadOrder, g as diffSchemas, h as createControlStack, i as SchemaTreeNode, k as storageHashHex, l as assembleAuthoringContributions, m as contractSnapshotTypesSpecifier, n as CONTRACT_SNAPSHOTS_DIRNAME, o as VERIFY_CODE_MARKER_MISSING, p as contractSnapshotJsonSpecifier, r as SchemaDiff, s as VERIFY_CODE_SCHEMA_FAILURE, t as APP_SPACE_ID, u as assembleControlMutationDefaults, v as extractCodecLookup, w as hasPslContractInfer, x as extractQueryOperationTypeImports, y as extractCodecTypeImports } from "./control-DTouE89s.mjs";
+import { t as settleAggregateOverloads } from "./components-ifbUGzY-.mjs";
+import { C as hasOperationPreview, D as issueOutcome, E as hasSchemaView, O as orderIssuesByDependencies, S as hasMigrations, T as hasSchemaSubjectClassifier, _ as dispositionForCategory, a as VERIFY_CODE_HASH_MISMATCH, b as extractComponentIds, c as VERIFY_CODE_TARGET_MISMATCH, d as assertUniqueCodecOwner, f as buildExtensionLoadOrder, g as diffSchemas, h as createControlStack, i as SchemaTreeNode, k as storageHashHex, l as assembleAuthoringContributions, m as contractSnapshotTypesSpecifier, n as CONTRACT_SNAPSHOTS_DIRNAME, o as VERIFY_CODE_MARKER_MISSING, p as contractSnapshotJsonSpecifier, r as SchemaDiff, s as VERIFY_CODE_SCHEMA_FAILURE, t as APP_SPACE_ID, u as assembleControlMutationDefaults, v as extractCodecLookup, w as hasPslContractInfer, x as extractQueryOperationTypeImports, y as extractCodecTypeImports } from "./control-Clpi3725.mjs";
 import { n as resolveRequirementSpecifiers, t as keepInternalSpecifiers } from "./emission-CeoAV9mj.mjs";
 import { n as createExecutionStack, r as instantiateExecutionStack, t as assertRuntimeContractRequirementsSatisfied } from "./execution-BNwBzmRd.mjs";
 import { a as buildSingleNamespaceView, c as elementCoordinates, d as hydrateNamespaceEntities, f as promoteBuiltinKinds, i as buildNamespacedEntities, l as entityAt, n as NamespaceBase, o as coordinateKey, r as UNBOUND_NAMESPACE_ID, s as domainElementCoordinates, t as IRNodeBase, u as freezeNode } from "./ir-ChmSSAhX.mjs";
 import { a as makePslNamespace, c as validateExtensionBlock, i as flatPslModels, n as UNSPECIFIED_PSL_NAMESPACE_ID, o as makePslNamespaceEntries, r as flatPslCompositeTypes, s as namespacePslExtensionBlocks, t as BUILTIN_PSL_KIND_KEYS } from "./psl-ast-DUCvVXbB.mjs";
 import { a as checkAborted, c as defineAnnotation, d as runWithMiddleware, f as runtimeAborted, i as assertAnnotationsApplicable, l as raceAgainstAbort, n as RUNTIME_ABORTED, o as checkMiddlewareCompatibility, r as RuntimeCore, s as createMetaBuilder, t as AsyncIterableResult, u as runBeforeExecuteChain } from "./runtime-DYTFHGwh.mjs";
 import { t as canonicalizeJson } from "./utils-DMAM0unR.mjs";
-export { APP_SPACE_ID, AsyncIterableResult, BUILTIN_PSL_KIND_KEYS, CONTRACT_CODEC_DESCRIPTOR_MISSING, CONTRACT_SNAPSHOTS_DIRNAME, CodecDescriptorImpl, CodecImpl, IRNodeBase, NamespaceBase, RUNTIME_ABORTED, RuntimeCore, SchemaDiff, SchemaTreeNode, UNBOUND_NAMESPACE_ID, UNSPECIFIED_PSL_NAMESPACE_ID, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, assembleControlMutationDefaults, assertAnnotationsApplicable, assertNoCrossRegistryCollisions, assertResolvableTypeConstructorTemplates, assertRuntimeContractRequirementsSatisfied, assertUniqueCodecOwner, buildExtensionLoadOrder, buildNamespacedEntities, buildSingleNamespaceView, canonicalizeJson, checkAborted, checkContractComponentRequirements, checkMiddlewareCompatibility, classifyEnumMemberType, collectScalarTypeConstructors, column, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, coordinateKey, createControlStack, createExecutionStack, createMetaBuilder, defineAnnotation, diffSchemas, dispositionForCategory, domainElementCoordinates, elementCoordinates, emptyCodecLookup, entityAt, extractCodecLookup, extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports, flatPslCompositeTypes, flatPslModels, flushAuthoringWarnings, freezeNode, hasMigrations, hasOperationPreview, hasPslContractInfer, hasRegisteredFieldNamespace, hasSchemaSubjectClassifier, hasSchemaView, hydrateNamespaceEntities, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, instantiateExecutionStack, isAuthoringArgRef, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, isPlainRecord, isRuntimeError, issueOutcome, keepInternalSpecifiers, makePslNamespace, makePslNamespaceEntries, materializeCodec, mergeAuthoringNamespaces, mergeCapabilityMatrices, namespacePslExtensionBlocks, orderIssuesByDependencies, promoteBuiltinKinds, raceAgainstAbort, renderTsLiteral, resolveAuthoringTemplateValue, resolveCodecDescriptorOrThrow, resolveEnumCodecId, resolveRequirementSpecifiers, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError, storageHashHex, validateAuthoringHelperArguments, validateCodecTypeParams, validateExtensionBlock, voidParamsSchema };
+export { APP_SPACE_ID, AsyncIterableResult, BUILTIN_PSL_KIND_KEYS, CONTRACT_CODEC_DESCRIPTOR_MISSING, CONTRACT_SNAPSHOTS_DIRNAME, CodecDescriptorImpl, CodecImpl, IRNodeBase, NamespaceBase, RUNTIME_ABORTED, RuntimeCore, SchemaDiff, SchemaTreeNode, UNBOUND_NAMESPACE_ID, UNSPECIFIED_PSL_NAMESPACE_ID, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH, aggregateDescriptorKey, assembleAuthoringContributions, assembleControlMutationDefaults, assertAnnotationsApplicable, assertNoCrossRegistryCollisions, assertResolvableTypeConstructorTemplates, assertRuntimeContractRequirementsSatisfied, assertUniqueCodecOwner, buildExtensionLoadOrder, buildNamespacedEntities, buildSingleNamespaceView, canonicalizeJson, checkAborted, checkContractComponentRequirements, checkMiddlewareCompatibility, classifyEnumMemberType, collectScalarTypeConstructors, column, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, coordinateKey, createControlStack, createExecutionStack, createMetaBuilder, defineAnnotation, diffSchemas, dispositionForCategory, domainElementCoordinates, elementCoordinates, emptyCodecLookup, entityAt, extractCodecLookup, extractCodecTypeImports, extractComponentIds, extractQueryOperationTypeImports, flatPslCompositeTypes, flatPslModels, flushAuthoringWarnings, freezeNode, hasMigrations, hasOperationPreview, hasPslContractInfer, hasRegisteredFieldNamespace, hasSchemaSubjectClassifier, hasSchemaView, hydrateNamespaceEntities, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, instantiateExecutionStack, isAggregateDescriptor, isAnyInputAggregateDescriptor, isAuthoringArgRef, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, isNoInputAggregateDescriptor, isPlainRecord, isRuntimeError, issueOutcome, keepInternalSpecifiers, makePslNamespace, makePslNamespaceEntries, materializeCodec, mergeAuthoringNamespaces, mergeCapabilityMatrices, namespacePslExtensionBlocks, orderIssuesByDependencies, promoteBuiltinKinds, raceAgainstAbort, renderTsLiteral, resolveAuthoringTemplateValue, resolveCodecDescriptorOrThrow, resolveEnumCodecId, resolveRequirementSpecifiers, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError, settleAggregateOverloads, storageHashHex, validateAuthoringHelperArguments, validateCodecTypeParams, validateExtensionBlock, voidParamsSchema };