@prisma/orm-framework 0.17.0-dev.1 → 0.17.0-dev.11

package/dist/psl-parser.d.mts

@@ -1,12 +1,12 @@
-import { c as CodecLookup } from "./codec-types-XJO6eC9U-B_K2q0zm.mjs";
-import { B as PslExtensionBlockParamList, F as PslDiagnosticCode, G as PslPosition, H as PslExtensionBlockParamRef, I as PslExtensionBlock, K as PslSpan, L as PslExtensionBlockAttribute, R as PslExtensionBlockAttributeArg, U as PslExtensionBlockParamScalarValue, V as PslExtensionBlockParamOption, W as PslExtensionBlockParamValue, b as AuthoringPslBlockDescriptorNamespace, y as AuthoringPslBlockDescriptor, z as PslExtensionBlockParamBare } from "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";
-import "./authoring-Dd7p6pTS.mjs";
-import "./codec-D3GVAkR_.mjs";
-import { M as namespacePslExtensionBlocks, T as PslTypesBlock, a as PslAttributeArgument, b as PslNamedTypeDeclaration, c as PslAttributeTarget, d as PslDefaultLiteralValue, f as PslDefaultValue, g as PslFieldAttribute, h as PslField, i as PslAttribute, k as flatPslModels, l as PslCompositeType, m as PslDocumentAst, o as PslAttributeNamedArgument, p as PslDiagnostic, s as PslAttributePositionalArgument, u as PslDefaultFunctionValue, v as PslModel, w as PslTypeConstructorCall, x as PslNamespace, y as PslModelAttribute } from "./psl-ast-Chgi8e4o-rSlBk1UV.mjs";
+import { c as CodecLookup } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
+import { B as PslExtensionBlockParamList, F as PslDiagnosticCode, G as PslPosition, H as PslExtensionBlockParamRef, I as PslExtensionBlock, K as PslSpan, L as PslExtensionBlockAttribute, R as PslExtensionBlockAttributeArg, U as PslExtensionBlockParamScalarValue, V as PslExtensionBlockParamOption, W as PslExtensionBlockParamValue, b as AuthoringPslBlockDescriptorNamespace, y as AuthoringPslBlockDescriptor, z as PslExtensionBlockParamBare } from "./framework-authoring--R1ZGWs1-C5F11Vhx.mjs";
+import "./authoring-ljy8m56O.mjs";
+import "./codec-LWTqo1GG.mjs";
+import { M as namespacePslExtensionBlocks, T as PslTypesBlock, a as PslAttributeArgument, b as PslNamedTypeDeclaration, c as PslAttributeTarget, d as PslDefaultLiteralValue, f as PslDefaultValue, g as PslFieldAttribute, h as PslField, i as PslAttribute, k as flatPslModels, l as PslCompositeType, m as PslDocumentAst, o as PslAttributeNamedArgument, p as PslDiagnostic, s as PslAttributePositionalArgument, u as PslDefaultFunctionValue, v as PslModel, w as PslTypeConstructorCall, x as PslNamespace, y as PslModelAttribute } from "./psl-ast-C4IAv2T_-CO0jh_VK.mjs";
 import { r as Result } from "./result-Bpupv5vO.mjs";
-import "./psl-ast-BEwO80EH.mjs";
-import { C as ModelAttributeAst, I as SourceFile, f as ExpressionAst, n as AstNode, p as FieldAttributeAst, r as AttributeArgAst } from "./parse-0ZJjj_2N-WZZ1nlrv.mjs";
-import { _ as nodePslSpan, a as ModelSymbol, b as readResolvedAttributes, c as ResolvedAttribute, d as ResolvedTypeConstructorCall, f as SymbolTable, g as keywordPslSpan, h as buildSymbolTable, i as FieldSymbol, l as ResolvedAttributeArg, m as TopLevelScope, n as BuildSymbolTableOptions, o as NamedTypeSymbol, p as SymbolTableResult, r as CompositeTypeSymbol, s as NamespaceSymbol, t as BlockSymbol, u as ResolvedNamedTypeBinding, v as rangeToPslSpan, x as readResolvedConstructorCall, y as readResolvedAttribute } from "./symbol-table-CZ7EVCTL-oYQtrmzq.mjs";
+import "./psl-ast-DAMpjVOP.mjs";
+import { C as ModelAttributeAst, I as SourceFile, f as ExpressionAst, n as AstNode, p as FieldAttributeAst, r as AttributeArgAst } from "./parse-0ZJjj_2N-CGZMQABI.mjs";
+import { _ as nodePslSpan, a as ModelSymbol, b as readResolvedAttributes, c as ResolvedAttribute, d as ResolvedTypeConstructorCall, f as SymbolTable, g as keywordPslSpan, h as buildSymbolTable, i as FieldSymbol, l as ResolvedAttributeArg, m as TopLevelScope, n as BuildSymbolTableOptions, o as NamedTypeSymbol, p as SymbolTableResult, r as CompositeTypeSymbol, s as NamespaceSymbol, t as BlockSymbol, u as ResolvedNamedTypeBinding, v as rangeToPslSpan, x as readResolvedConstructorCall, y as readResolvedAttribute } from "./symbol-table-CZ7EVCTL-CqkpG3a_.mjs";
 import { n as UnionToIntersection, t as Simplify } from "./types-DGxlljKG.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/index.d.mts
 //#region src/attribute-helpers.d.ts

package/dist/psl-parser__interpret.d.mts

@@ -1,9 +1,9 @@
 import { t as Contract } from "./contract-types-CkdMH7F7-9EHXSwbH.mjs";
 import { r as Result } from "./result-Bpupv5vO.mjs";
-import { c as ContractSourceProvider, m as PslContractSourceProvider, n as ContractSourceContext, o as ContractSourceDiagnostics, r as ContractSourceDiagnostic } from "./config-types-W-87vhZ4-BgYaH8YO.mjs";
-import "./config-types-zrHI32Om.mjs";
-import { I as SourceFile, d as DocumentAst } from "./parse-0ZJjj_2N-WZZ1nlrv.mjs";
-import { f as SymbolTable } from "./symbol-table-CZ7EVCTL-oYQtrmzq.mjs";
+import { c as ContractSourceProvider, m as PslContractSourceProvider, n as ContractSourceContext, o as ContractSourceDiagnostics, r as ContractSourceDiagnostic } from "./config-types-W-87vhZ4-xE_-BXZD.mjs";
+import "./config-types-DzIlP4Ue.mjs";
+import { I as SourceFile, d as DocumentAst } from "./parse-0ZJjj_2N-CGZMQABI.mjs";
+import { f as SymbolTable } from "./symbol-table-CZ7EVCTL-CqkpG3a_.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/interpret.d.mts
 //#region src/interpret.d.ts
 /**

package/dist/psl-parser__syntax.d.mts

@@ -1,5 +1,5 @@
 import { n as TokenKind } from "./tokenizer-DcYI0Xrq-C-nNE9mE.mjs";
-import { $ as parse, A as ObjectLiteralExprAst, B as SyntaxNode, C as ModelAttributeAst, D as NamespaceMemberAst, E as NamespaceDeclarationAst, F as Range, G as any, H as TokenAtOffset, I as SourceFile, J as filterChildren, K as castExpression, L as StringLiteralExprAst, M as ParseResult, N as Position, O as NumberLiteralExprAst, P as QualifiedNameAst, Q as greenToken, R as SyntaxElement, S as KeyValuePairAst, T as NamedTypeDeclarationAst, U as TypeAnnotationAst, V as SyntaxToken, W as TypesBlockAst, X as findFirstChild, Y as findChildToken, Z as greenNode, _ as GenericBlockMemberAst, a as AttributeAst, b as GreenToken, c as BracedBlock, d as DocumentAst, et as printSyntax, f as ExpressionAst, g as GenericBlockDeclarationAst, h as FunctionCallAst, i as AttributeArgListAst, j as ParseDiagnostic, k as ObjectFieldAst, l as CompositeTypeDeclarationAst, m as FieldDeclarationAst, n as AstNode, o as BlockMemberAst, p as FieldAttributeAst, q as createSyntaxTree, r as AttributeArgAst, s as BooleanLiteralExprAst, t as ArrayLiteralAst, u as DeclarationAst, v as GreenElement, w as ModelDeclarationAst, x as IdentifierAst, y as GreenNode, z as SyntaxKind } from "./parse-0ZJjj_2N-WZZ1nlrv.mjs";
+import { $ as parse, A as ObjectLiteralExprAst, B as SyntaxNode, C as ModelAttributeAst, D as NamespaceMemberAst, E as NamespaceDeclarationAst, F as Range, G as any, H as TokenAtOffset, I as SourceFile, J as filterChildren, K as castExpression, L as StringLiteralExprAst, M as ParseResult, N as Position, O as NumberLiteralExprAst, P as QualifiedNameAst, Q as greenToken, R as SyntaxElement, S as KeyValuePairAst, T as NamedTypeDeclarationAst, U as TypeAnnotationAst, V as SyntaxToken, W as TypesBlockAst, X as findFirstChild, Y as findChildToken, Z as greenNode, _ as GenericBlockMemberAst, a as AttributeAst, b as GreenToken, c as BracedBlock, d as DocumentAst, et as printSyntax, f as ExpressionAst, g as GenericBlockDeclarationAst, h as FunctionCallAst, i as AttributeArgListAst, j as ParseDiagnostic, k as ObjectFieldAst, l as CompositeTypeDeclarationAst, m as FieldDeclarationAst, n as AstNode, o as BlockMemberAst, p as FieldAttributeAst, q as createSyntaxTree, r as AttributeArgAst, s as BooleanLiteralExprAst, t as ArrayLiteralAst, u as DeclarationAst, v as GreenElement, w as ModelDeclarationAst, x as IdentifierAst, y as GreenNode, z as SyntaxKind } from "./parse-0ZJjj_2N-CGZMQABI.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/syntax.d.mts
 //#region src/syntax/green-builder.d.ts
 declare class GreenNodeBuilder {

package/dist/psl-printer.d.mts

@@ -1,9 +1,9 @@
-import { c as CodecLookup } from "./codec-types-XJO6eC9U-B_K2q0zm.mjs";
-import { b as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";
-import "./authoring-Dd7p6pTS.mjs";
-import "./codec-D3GVAkR_.mjs";
-import { m as PslDocumentAst } from "./psl-ast-Chgi8e4o-rSlBk1UV.mjs";
-import "./psl-ast-BEwO80EH.mjs";
+import { c as CodecLookup } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
+import { b as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring--R1ZGWs1-C5F11Vhx.mjs";
+import "./authoring-ljy8m56O.mjs";
+import "./codec-LWTqo1GG.mjs";
+import { m as PslDocumentAst } from "./psl-ast-C4IAv2T_-CO0jh_VK.mjs";
+import "./psl-ast-DAMpjVOP.mjs";
 //#region ../../../1-framework/2-authoring/psl-printer/dist/index.d.mts
 //#region src/print-psl.d.ts
 type PslBlockDescriptorsNamespace = AuthoringPslBlockDescriptorNamespace;

package/dist/{runtime--RZXG1zP.d.mts → runtime-Cne6hBaG.d.mts}

@@ -1,5 +1,5 @@
 import { U as PlanMeta } from "./domain-envelope-D6Wn9AmZ-BqZKTT9U.mjs";
-import { r as CodecCallContext } from "./codec-types-XJO6eC9U-B_K2q0zm.mjs";
+import { r as CodecCallContext } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/runtime.d.mts
 //#region src/annotations.d.ts
 /**
@@ -898,4 +898,4 @@ interface LaneMetaBuilder<K extends OperationKind> extends MetaBuilder<K> {
 declare function createMetaBuilder<K extends OperationKind>(kind: K, terminalName: string): LaneMetaBuilder<K>;
 //#endregion
 export { defineAnnotation as A, RuntimeMiddleware as C, checkAborted as D, assertAnnotationsApplicable as E, runtimeAborted as F, runtimeError as I, raceAgainstAbort as M, runBeforeExecuteChain as N, checkMiddlewareCompatibility as O, runWithMiddleware as P, RuntimeLog as S, ValidAnnotations as T, RuntimeCore as _, CrossFamilyMiddleware as a, RuntimeExecuteOptions as b, InterceptResult as c, OperationKind as d, ParamRefMutator as f, RuntimeAbortedPhase as g, ResultType as h, AsyncIterableResult as i, isRuntimeError as j, createMetaBuilder as k, LaneMetaBuilder as l, RUNTIME_ABORTED as m, AnnotationHandle as n, DefineAnnotationOptions as o, QueryPlan as p, AnnotationValue as r, ExecutionPlan as s, AfterExecuteResult as t, MetaBuilder as u, RuntimeCoreOptions as v, RuntimeMiddlewareContext as w, RuntimeExecutor as x, RuntimeErrorEnvelope as y };
-//# sourceMappingURL=runtime--RZXG1zP.d.mts.map
+//# sourceMappingURL=runtime-Cne6hBaG.d.mts.map

package/dist/{runtime--RZXG1zP.d.mts.map → runtime-Cne6hBaG.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"runtime--RZXG1zP.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/runtime.d.mts"],"mappings":"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"}
+{"version":3,"file":"runtime-Cne6hBaG.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/runtime.d.mts"],"mappings":"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"}

package/dist/{symbol-table-CZ7EVCTL-oYQtrmzq.d.mts → symbol-table-CZ7EVCTL-CqkpG3a_.d.mts}

@@ -1,7 +1,7 @@
-import { I as PslExtensionBlock, K as PslSpan, b as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";
-import "./authoring-Dd7p6pTS.mjs";
-import "./psl-ast-BEwO80EH.mjs";
-import { B as SyntaxNode, C as ModelAttributeAst, E as NamespaceDeclarationAst, F as Range, I as SourceFile, T as NamedTypeDeclarationAst, U as TypeAnnotationAst, d as DocumentAst, f as ExpressionAst, g as GenericBlockDeclarationAst, j as ParseDiagnostic, l as CompositeTypeDeclarationAst, m as FieldDeclarationAst, p as FieldAttributeAst, w as ModelDeclarationAst } from "./parse-0ZJjj_2N-WZZ1nlrv.mjs";
+import { I as PslExtensionBlock, K as PslSpan, b as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring--R1ZGWs1-C5F11Vhx.mjs";
+import "./authoring-ljy8m56O.mjs";
+import "./psl-ast-DAMpjVOP.mjs";
+import { B as SyntaxNode, C as ModelAttributeAst, E as NamespaceDeclarationAst, F as Range, I as SourceFile, T as NamedTypeDeclarationAst, U as TypeAnnotationAst, d as DocumentAst, f as ExpressionAst, g as GenericBlockDeclarationAst, j as ParseDiagnostic, l as CompositeTypeDeclarationAst, m as FieldDeclarationAst, p as FieldAttributeAst, w as ModelDeclarationAst } from "./parse-0ZJjj_2N-CGZMQABI.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/symbol-table-CZ7EVCTL.d.mts
 //#region src/resolve.d.ts
 interface ResolvedAttributeArg {
@@ -122,4 +122,4 @@ interface SymbolTableResult {
 declare function buildSymbolTable(options: BuildSymbolTableOptions): SymbolTableResult;
 //#endregion
 export { nodePslSpan as _, ModelSymbol as a, readResolvedAttributes as b, ResolvedAttribute as c, ResolvedTypeConstructorCall as d, SymbolTable as f, keywordPslSpan as g, buildSymbolTable as h, FieldSymbol as i, ResolvedAttributeArg as l, TopLevelScope as m, BuildSymbolTableOptions as n, NamedTypeSymbol as o, SymbolTableResult as p, CompositeTypeSymbol as r, NamespaceSymbol as s, BlockSymbol as t, ResolvedNamedTypeBinding as u, rangeToPslSpan as v, readResolvedConstructorCall as x, readResolvedAttribute as y };
-//# sourceMappingURL=symbol-table-CZ7EVCTL-oYQtrmzq.d.mts.map
+//# sourceMappingURL=symbol-table-CZ7EVCTL-CqkpG3a_.d.mts.map

package/dist/{symbol-table-CZ7EVCTL-oYQtrmzq.d.mts.map → symbol-table-CZ7EVCTL-CqkpG3a_.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"symbol-table-CZ7EVCTL-oYQtrmzq.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/symbol-table-CZ7EVCTL.d.mts"],"mappings":";;;;;;UAIU;WACC;WACA;WACA;WACA,aAAa;WACb,MAAM;;UAEP;WACC;WACA,eAAe;WACf,MAAM;;UAEP;WACC;WACA,eAAe;WACf,MAAM;;iBAEA,sBAAsB,WAAW,oBAAoB,mBAAmB,YAAY,aAAa;iBACjG,uBAAuB,YAAY,SAAS,oBAAoB,oBAAoB,YAAY,sBAAsB;iBACtH,4BAA4B,YAAY,+BAA+B,YAAY,aAAa;iBAChG,YAAY,MAAM,YAAY,YAAY,aAAa;;iBAEvD,eAAe,MAAM,YAAY,iBAAiB,YAAY,aAAa;iBAC3E,eAAe,OAAO,OAAO,YAAY,aAAa;;;UAG7D;WACC,UAAU;;UAEX;WACC,YAAY,eAAe;WAC3B,YAAY,eAAe;WAC3B,QAAQ,eAAe;WACvB,QAAQ,eAAe;WACvB,gBAAgB,eAAe;;UAEhC;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN,QAAQ,eAAe;WACvB,gBAAgB,eAAe;WAC/B,QAAQ,eAAe;;UAExB;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN,QAAQ,eAAe;WACvB,qBAAqB;;UAEtB;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN,QAAQ,eAAe;WACvB,qBAAqB;;UAEtB;WACC;WACA;WACA;WACA,MAAM;WACN,MAAM;;WAEN,OAAO;;UAER;WACC;WACA,kBAAkB;WAClB;WACA,qBAAqB;;;;;;;UAOtB,wBAAwB;WACvB;WACA;WACA,MAAM;WACN,MAAM;;UAEP;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN;WACA;WACA;WACA;WACA;WACA,kBAAkB;WAClB,qBAAqB;;WAErB;;UAED;WACC,UAAU;WACV,YAAY;WACZ,qBAAqB;;UAEtB;WACC,OAAO;WACP,sBAAsB;;;;;;iBAMhB,iBAAiB,SAAS,0BAA0B"}
+{"version":3,"file":"symbol-table-CZ7EVCTL-CqkpG3a_.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/symbol-table-CZ7EVCTL.d.mts"],"mappings":";;;;;;UAIU;WACC;WACA;WACA;WACA,aAAa;WACb,MAAM;;UAEP;WACC;WACA,eAAe;WACf,MAAM;;UAEP;WACC;WACA,eAAe;WACf,MAAM;;iBAEA,sBAAsB,WAAW,oBAAoB,mBAAmB,YAAY,aAAa;iBACjG,uBAAuB,YAAY,SAAS,oBAAoB,oBAAoB,YAAY,sBAAsB;iBACtH,4BAA4B,YAAY,+BAA+B,YAAY,aAAa;iBAChG,YAAY,MAAM,YAAY,YAAY,aAAa;;iBAEvD,eAAe,MAAM,YAAY,iBAAiB,YAAY,aAAa;iBAC3E,eAAe,OAAO,OAAO,YAAY,aAAa;;;UAG7D;WACC,UAAU;;UAEX;WACC,YAAY,eAAe;WAC3B,YAAY,eAAe;WAC3B,QAAQ,eAAe;WACvB,QAAQ,eAAe;WACvB,gBAAgB,eAAe;;UAEhC;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN,QAAQ,eAAe;WACvB,gBAAgB,eAAe;WAC/B,QAAQ,eAAe;;UAExB;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN,QAAQ,eAAe;WACvB,qBAAqB;;UAEtB;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN,QAAQ,eAAe;WACvB,qBAAqB;;UAEtB;WACC;WACA;WACA;WACA,MAAM;WACN,MAAM;;WAEN,OAAO;;UAER;WACC;WACA,kBAAkB;WAClB;WACA,qBAAqB;;;;;;;UAOtB,wBAAwB;WACvB;WACA;WACA,MAAM;WACN,MAAM;;UAEP;WACC;WACA;WACA,MAAM;WACN,MAAM;WACN;WACA;WACA;WACA;WACA;WACA,kBAAkB;WAClB,qBAAqB;;WAErB;;UAED;WACC,UAAU;WACV,YAAY;WACZ,qBAAqB;;UAEtB;WACC,OAAO;WACP,sBAAsB;;;;;;iBAMhB,iBAAiB,SAAS,0BAA0B"}

package/dist/ts-render.d.mts

@@ -1,2 +1,2 @@
-import { a as jsonToTsSource, i as TsExpression, n as JsonObject, o as renderImports, r as JsonValue, t as ImportRequirement } from "./index-GY2oGH9L.mjs";
-export { type ImportRequirement, type JsonObject, type JsonValue, TsExpression, jsonToTsSource, renderImports };
+import { a as jsonToTsSource, i as TsExpression, n as JsonObject, o as renderImports, r as JsonValue, s as tsStringLiteral, t as ImportRequirement } from "./index-CDk9yEbw.mjs";
+export { type ImportRequirement, type JsonObject, type JsonValue, TsExpression, jsonToTsSource, renderImports, tsStringLiteral };

package/dist/ts-render.mjs

@@ -1,240 +1,2 @@
-import { a as structuredError } from "./structured-error-H6WU9Kjt.mjs";
-import { t as InternalError } from "./internal-error-BIc-ehme-ouBQPoEL.mjs";
-//#region ../../../1-framework/1-core/ts-render/dist/index.mjs
-/**
-* Pure JSON-to-TypeScript-source printer.
-*
-* This module is the second stage of the codec → TS pipeline:
-*
-*     jsValue  →  codec.encodeJson  →  JsonValue  →  jsonToTsSource  →  TS source text
-*
-* Stage 1 (`codec.encodeJson`) is a codec responsibility — date serialization,
-* opaque domain types (vector, bigint, uuid), JSON canonicalization. Stage 2
-* (this module) is a pure JSON-to-TS printer that must never grow type-specific
-* branches.
-*
-* To render a non-JSON JS value (Date, Vector, BigInt, Buffer, …), encode it
-* through the relevant codec's `encodeJson` first. Adding special cases to
-* this file is not the answer — that's what codecs are for.
-*/
-/**
-* Render a JSON-compatible value as a TypeScript source-text literal.
-*
-* Accepts `unknown` for ergonomics with structural types (e.g. `ColumnSpec`,
-* `ForeignKeySpec`) whose fields are all JSON-compatible but whose interfaces
-* lack the index signature TypeScript requires for `JsonObject` assignability.
-* Non-JSON values (Date, Symbol, Function, etc.) throw at runtime.
-*/
-function jsonToTsSource(value) {
-	if (value === void 0) return "undefined";
-	if (value === null) return "null";
-	if (typeof value === "string") return stringifyLiteral(value);
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (Array.isArray(value)) {
-		if (value.length === 0) return "[]";
-		const items = value.map((v) => jsonToTsSource(v));
-		const singleLine = `[${items.join(", ")}]`;
-		if (singleLine.length <= 80) return singleLine;
-		return `[\n${items.map((i) => `  ${i}`).join(",\n")},\n]`;
-	}
-	if (typeof value === "object") {
-		const entries = Object.entries(value).filter(([, v]) => v !== void 0);
-		if (entries.length === 0) return "{}";
-		const items = entries.map(([k, v]) => `${renderKey(k)}: ${jsonToTsSource(v)}`);
-		const singleLine = `{ ${items.join(", ")} }`;
-		if (singleLine.length <= 80) return singleLine;
-		return `{\n${items.map((i) => `  ${i}`).join(",\n")},\n}`;
-	}
-	throw new InternalError(`jsonToTsSource: unsupported value type "${typeof value}"`);
-}
-function renderKey(key) {
-	if (key === "__proto__") return stringifyLiteral(key);
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : stringifyLiteral(key);
-}
-function stringifyLiteral(value) {
-	return JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function contractError(code, message, options) {
-	return structuredError(code, message, options);
-}
-/**
-* Render an aggregated `import` block from a flat list of
-* `ImportRequirement`s. Each target's migration renderer collects
-* requirements polymorphically from its call nodes and pipes them here.
-*
-* The emitter invariants:
-*
-* - **Usually one line per module specifier.** Named imports are aggregated
-*   and emitted sorted; a single default symbol is combined onto the same
-*   line when attributes agree (`import def, { a, b } from "m";`). Aliased
-*   symbols render `symbol as alias`. When every symbol for a module is
-*   `typeOnly`, the statement collapses to `import type { … }`; a module
-*   mixing value and type symbols prefixes the type-only ones
-*   (`import { type T, v }`). Exceptions that split into multiple lines: a
-*   fully type-only statement with both a default and one or more named
-*   bindings (`import type D from "m";` then `import type { N } from "m";`,
-*   because TypeScript rejects `import type D, { N } from "m"` — TS1363),
-*   and multiple distinct default symbols (see below).
-* - **Multiple distinct default symbols per module are allowed.** JS permits
-*   re-importing the same specifier under different default-binding names
-*   (`import a from 'm'; import b from 'm';`), so each distinct default
-*   symbol renders its own `import` line, sorted alphabetically; a repeated
-*   requirement for the same symbol still collapses into one binding,
-*   merging `typeOnly` by AND.
-* - **Attribute unanimity per module.** All requirements for the same
-*   module specifier must carry the same (or no) `attributes` map.
-*   Divergent attribute maps throw — they can't collapse to one line
-*   and there's no user-resolvable recovery at this layer.
-* - **Distinct (symbol, alias) pairs are distinct bindings.** TypeScript
-*   permits importing the same export under multiple local names, so
-*   `{ A }` + `{ A as B }` renders as `import { A, A as B } from "m"` and
-*   `{ A as B }` + `{ A as C }` renders as `import { A as B, A as C } from "m"`.
-*   Truly identical `(symbol, alias)` pairs still collapse to one binding,
-*   merging `typeOnly` by AND.
-* - **Deterministic ordering.** Modules are emitted sorted by specifier;
-*   within a module, named bindings are emitted sorted by `(symbol, alias)`
-*   using JavaScript code-unit comparison, with the un-aliased form (no
-*   alias) treated as alias `""` so it sorts before any aliased form of the
-*   same symbol.
-*
-* Returns a string containing one or more import lines per module (see the
-* splitting exceptions above), joined by `\n` (no trailing newline). An
-* empty requirement list returns `""`.
-*/
-function renderImports(requirements) {
-	return [...aggregateByModule(requirements).entries()].sort(([a], [b]) => a.localeCompare(b)).map(([moduleSpecifier, group]) => renderModuleImport(moduleSpecifier, group)).join("\n");
-}
-function aggregateByModule(requirements) {
-	const byModule = /* @__PURE__ */ new Map();
-	for (const req of requirements) {
-		let group = byModule.get(req.moduleSpecifier);
-		if (!group) {
-			group = {
-				named: /* @__PURE__ */ new Map(),
-				defaults: /* @__PURE__ */ new Map(),
-				attributes: null,
-				attributesSet: false
-			};
-			byModule.set(req.moduleSpecifier, group);
-		}
-		mergeRequirementIntoGroup(req, group);
-	}
-	return byModule;
-}
-function mergeRequirementIntoGroup(req, group) {
-	const kind = req.kind ?? "named";
-	const typeOnly = req.typeOnly === true;
-	if (kind === "default") {
-		const existingTypeOnly = group.defaults.get(req.symbol);
-		group.defaults.set(req.symbol, existingTypeOnly === void 0 ? typeOnly : existingTypeOnly && typeOnly);
-	} else {
-		const alias = req.alias && req.alias !== req.symbol ? req.alias : null;
-		const key = namedBindingKey(req.symbol, alias);
-		const existing = group.named.get(key);
-		if (existing) existing.typeOnly = existing.typeOnly && typeOnly;
-		else group.named.set(key, {
-			symbol: req.symbol,
-			alias,
-			typeOnly
-		});
-	}
-	mergeAttributes(req, group);
-}
-function mergeAttributes(req, group) {
-	const incoming = req.attributes ?? null;
-	if (!group.attributesSet) {
-		group.attributes = incoming;
-		group.attributesSet = true;
-		return;
-	}
-	if (!attributesEqual(group.attributes, incoming)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Conflicting import attributes for module "${req.moduleSpecifier}": ${stringifyAttributes(group.attributes)} vs ${stringifyAttributes(incoming)}.`, { meta: { moduleSpecifier: req.moduleSpecifier } });
-}
-function attributesEqual(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null) return false;
-	const aKeys = Object.keys(a).sort();
-	const bKeys = Object.keys(b).sort();
-	if (aKeys.length !== bKeys.length) return false;
-	for (let i = 0; i < aKeys.length; i++) {
-		const key = aKeys[i];
-		if (key !== bKeys[i]) return false;
-		if (a[key] !== b[key]) return false;
-	}
-	return true;
-}
-function stringifyAttributes(attrs) {
-	if (attrs === null) return "(none)";
-	return `{ ${Object.entries(attrs).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ")} }`;
-}
-function renderModuleImport(moduleSpecifier, group) {
-	const attrs = buildAttributesClause(group.attributes);
-	const defaultEntries = [...group.defaults.entries()].sort(([a], [b]) => a.localeCompare(b));
-	const hasNamed = group.named.size > 0;
-	if (defaultEntries.length > 1) {
-		const defaultLines = defaultEntries.map(([symbol, typeOnly]) => `import ${typeOnly ? "type " : ""}${symbol} from '${moduleSpecifier}'${attrs};`);
-		if (!hasNamed) return defaultLines.join("\n");
-		return [...defaultLines, renderNamedOnlyStatement(moduleSpecifier, group, attrs)].join("\n");
-	}
-	const defaultEntry = defaultEntries[0];
-	const hasDefault = defaultEntry !== void 0;
-	const [defaultSymbol, defaultTypeOnly] = defaultEntry ?? [null, true];
-	const typeOnlyStatement = isStatementTypeOnly(hasDefault, defaultTypeOnly, group);
-	if (typeOnlyStatement && hasDefault && hasNamed) return `${`import type ${defaultSymbol} from '${moduleSpecifier}'${attrs};`}\n${`import type { ${renderNamedBindingsList(group, true)} } from '${moduleSpecifier}'${attrs};`}`;
-	return `${typeOnlyStatement ? "import type" : "import"} ${buildImportClause(defaultSymbol, group, typeOnlyStatement)} from '${moduleSpecifier}'${attrs};`;
-}
-function renderNamedOnlyStatement(moduleSpecifier, group, attrs) {
-	const typeOnlyStatement = [...group.named.values()].every((binding) => binding.typeOnly);
-	return `${typeOnlyStatement ? "import type" : "import"} { ${renderNamedBindingsList(group, typeOnlyStatement)} } from '${moduleSpecifier}'${attrs};`;
-}
-function isStatementTypeOnly(hasDefault, defaultTypeOnly, group) {
-	const hasNamed = group.named.size > 0;
-	if (!hasDefault && !hasNamed) return false;
-	if (hasDefault && !defaultTypeOnly) return false;
-	for (const binding of group.named.values()) if (!binding.typeOnly) return false;
-	return true;
-}
-function buildImportClause(defaultSymbol, group, statementTypeOnly) {
-	const hasNamed = group.named.size > 0;
-	const hasDefault = defaultSymbol !== null;
-	const namedClause = hasNamed ? renderNamedBindingsList(group, statementTypeOnly) : "";
-	if (hasDefault && hasNamed) return `${defaultSymbol}, { ${namedClause} }`;
-	if (hasDefault) return defaultSymbol;
-	return `{ ${namedClause} }`;
-}
-function renderNamedBindingsList(group, statementTypeOnly) {
-	return [...group.named.values()].sort(compareNamedBindings).map((binding) => renderNamedBinding(binding, statementTypeOnly)).join(", ");
-}
-function compareNamedBindings(a, b) {
-	if (a.symbol !== b.symbol) return a.symbol < b.symbol ? -1 : 1;
-	const aAlias = a.alias ?? "";
-	const bAlias = b.alias ?? "";
-	if (aAlias === bAlias) return 0;
-	return aAlias < bAlias ? -1 : 1;
-}
-function namedBindingKey(symbol, alias) {
-	return `${symbol}\x00${alias ?? ""}`;
-}
-function renderNamedBinding(binding, statementTypeOnly) {
-	const prefix = !statementTypeOnly && binding.typeOnly ? "type " : "";
-	const aliasClause = binding.alias !== null ? ` as ${binding.alias}` : "";
-	return `${prefix}${binding.symbol}${aliasClause}`;
-}
-function buildAttributesClause(attrs) {
-	if (attrs === null) return "";
-	const entries = Object.entries(attrs).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
-	if (entries.length === 0) return "";
-	return ` with { ${entries.join(", ")} }`;
-}
-/**
-* Abstract base class for any IR node that can be emitted as a TypeScript
-* expression and declare its own import requirements.
-*
-* A top-level renderer walks an array of these polymorphically, concatenates
-* `renderTypeScript()` results, and aggregates `importRequirements()` into a
-* deduplicated import block.
-*/
-var TsExpression = class {};
-//#endregion
-export { TsExpression, jsonToTsSource, renderImports };
-
-//# sourceMappingURL=ts-render.mjs.map
+import { i as tsStringLiteral, n as jsonToTsSource, r as renderImports, t as TsExpression } from "./dist-DFakQfiQ.mjs";
+export { TsExpression, jsonToTsSource, renderImports, tsStringLiteral };

package/dist/types-import-spec-B4hKOPE9-BwQGG38j.d.mts

@@ -0,0 +1,104 @@
+import { z as JsonValue } from "./domain-envelope-D6Wn9AmZ-BqZKTT9U.mjs";
+import { d as CodecTrait, l as CodecRef } from "./codec-types-720XoDZ0-Br-QaYK3.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/types-import-spec-B4hKOPE9.d.mts
+//#region src/shared/aggregate-descriptor.d.ts
+/**
+ * How a descriptor matches the value an aggregate consumes.
+ *
+ * - `none` — the operation consumes no value (counting entries).
+ * - `codec` — the value's codec id matches exactly.
+ * - `trait` — the value's codec advertises the trait.
+ * - `any` — the operation's result does not depend on its input, so the descriptor answers calls with and without one (counting entries or non-null values).
+ *
+ * Resolution consults exact codec matches first, then traits, then input-agnostic matches; a `none` match answers only a call that carries no input.
+ */
+type AggregateInputMatch = {
+  readonly kind: 'none';
+} | {
+  readonly kind: 'codec';
+  readonly codecId: string;
+} | {
+  readonly kind: 'trait';
+  readonly trait: CodecTrait;
+} | {
+  readonly kind: 'any';
+};
+/**
+ * Result identity that names its codec outright. The optional `typeParams` resolver derives the result's type parameters from the input reference; it cannot change which codec id the result carries.
+ *
+ * The resolved parameters refine which codec instance decodes the result. The emitted aggregate rows select the result's application type from the codec id alone — the same granularity every emitted codec type has — so the parameters never widen or narrow the static result type.
+ */
+interface NamedAggregateOutput {
+  readonly kind: 'codec';
+  readonly codecId: string;
+  readonly typeParams?: (input: CodecRef | undefined) => JsonValue | undefined;
+}
+/** Result identity that reuses the matched input codec, type parameters included. */
+interface SelfAggregateOutput {
+  readonly kind: 'self';
+}
+/** Declarative identity of the codec an aggregate's result carries. */
+type AggregateOutputCodec = SelfAggregateOutput | NamedAggregateOutput;
+interface AggregateDescriptorBase {
+  /** The aggregate operation this descriptor resolves (e.g. `count`, `sum`). */
+  readonly operation: string;
+  /** Whether the result can be null — declared, never inferred from the input's nullability. */
+  readonly nullable: boolean;
+}
+/** Overload of an operation that consumes no value. Its result names a codec outright, there being no input codec to reuse. */
+interface NoInputAggregateDescriptor extends AggregateDescriptorBase {
+  readonly input: {
+    readonly kind: 'none';
+  };
+  readonly output: NamedAggregateOutput;
+}
+/** Overload of an operation whose result does not depend on its input. It answers calls with and without an input, so — like a no-input overload — it names its result codec outright. */
+interface AnyInputAggregateDescriptor extends AggregateDescriptorBase {
+  readonly input: {
+    readonly kind: 'any';
+  };
+  readonly output: NamedAggregateOutput;
+}
+/** Overload of an operation over values whose codec matches by id or by trait. */
+interface ValueInputAggregateDescriptor extends AggregateDescriptorBase {
+  readonly input: {
+    readonly kind: 'codec';
+    readonly codecId: string;
+  } | {
+    readonly kind: 'trait';
+    readonly trait: CodecTrait;
+  };
+  readonly output: AggregateOutputCodec;
+}
+/**
+ * One `(operation, input)` overload of an aggregate operation.
+ *
+ * Each pair has exactly one contributor across a composed stack, so `count` over entries, `sum` over a numeric trait, and `sum` over one exact codec id are three independent descriptors that may come from three different components.
+ */
+type AggregateDescriptor = NoInputAggregateDescriptor | AnyInputAggregateDescriptor | ValueInputAggregateDescriptor;
+/**
+ * Ownership key of an `(operation, input)` pair. Two descriptors sharing a key are two contributors claiming one overload, which is a composition error.
+ */
+declare function aggregateDescriptorKey(descriptor: AggregateDescriptor): string;
+/** Whether `descriptor` is the overload of an operation that consumes no value — the case whose result always names a codec outright. */
+declare function isNoInputAggregateDescriptor(descriptor: AggregateDescriptor): descriptor is NoInputAggregateDescriptor;
+/** Whether `descriptor` answers regardless of input — the fallback rung of resolution. */
+declare function isAnyInputAggregateDescriptor(descriptor: AggregateDescriptor): descriptor is AnyInputAggregateDescriptor;
+/**
+ * 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.
+ */
+declare function isAggregateDescriptor(value: unknown): value is AggregateDescriptor;
+//#endregion
+//#region src/shared/types-import-spec.d.ts
+/**
+ * Specifies how to import TypeScript types from a package.
+ * Used in extension pack manifests to declare codec and operation type imports.
+ */
+interface TypesImportSpec {
+  readonly package: string;
+  readonly named: string;
+  readonly alias: string;
+}
+//#endregion
+export { NamedAggregateOutput as a, TypesImportSpec as c, isAggregateDescriptor as d, isAnyInputAggregateDescriptor as f, AnyInputAggregateDescriptor as i, ValueInputAggregateDescriptor as l, AggregateInputMatch as n, NoInputAggregateDescriptor as o, isNoInputAggregateDescriptor as p, AggregateOutputCodec as r, SelfAggregateOutput as s, AggregateDescriptor as t, aggregateDescriptorKey as u };
+//# sourceMappingURL=types-import-spec-B4hKOPE9-BwQGG38j.d.mts.map

package/dist/types-import-spec-B4hKOPE9-BwQGG38j.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-import-spec-B4hKOPE9-BwQGG38j.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/types-import-spec-B4hKOPE9.d.mts"],"mappings":";;;;;;;;;;;;;;KAaK;WACM;;WAEA;WACA;;WAEA;WACA,OAAO;;WAEP;;;;;;;UAOD;WACC;WACA;WACA,cAAc,OAAO,yBAAyB;;;UAG/C;WACC;;;KAGN,uBAAuB,sBAAsB;UACxC;;WAEC;;WAEA;;;UAGD,mCAAmC;WAClC;aACE;;WAEF,QAAQ;;;UAGT,oCAAoC;WACnC;aACE;;WAEF,QAAQ;;;UAGT,sCAAsC;WACrC;aACE;aACA;;aAEA;aACA,OAAO;;WAET,QAAQ;;;;;;;KAOd,sBAAsB,6BAA6B,8BAA8B;;;;iBAIrE,uBAAuB,YAAY;;iBAEnC,6BAA6B,YAAY,sBAAsB,cAAc;;iBAE7E,8BAA8B,YAAY,sBAAsB,cAAc;;;;iBAI9E,sBAAsB,iBAAiB,SAAS;;;;;;;UAOvD;WACC;WACA;WACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/orm-framework",
-  "version": "0.17.0-dev.1",
+  "version": "0.17.0-dev.11",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -15,20 +15,20 @@
     "uniku": "^0.4.3"
   },
   "devDependencies": {
-    "@internal/config": "0.17.0-dev.1",
-    "@internal/contract": "0.17.0-dev.1",
-    "@internal/contract-authoring": "0.17.0-dev.1",
-    "@internal/errors": "0.17.0-dev.1",
-    "@internal/framework-components": "0.17.0-dev.1",
-    "@internal/ids": "0.17.0-dev.1",
-    "@internal/operations": "0.17.0-dev.1",
-    "@internal/psl-parser": "0.17.0-dev.1",
-    "@internal/psl-printer": "0.17.0-dev.1",
-    "@internal/ts-render": "0.17.0-dev.1",
-    "@repo/tsconfig": "0.17.0-dev.1",
-    "@internal/publish-surface": "0.17.0-dev.1",
-    "@repo/tsdown": "0.17.0-dev.1",
-    "@internal/utils": "0.17.0-dev.1",
+    "@internal/config": "0.17.0-dev.11",
+    "@internal/contract": "0.17.0-dev.11",
+    "@internal/contract-authoring": "0.17.0-dev.11",
+    "@internal/errors": "0.17.0-dev.11",
+    "@internal/framework-components": "0.17.0-dev.11",
+    "@internal/ids": "0.17.0-dev.11",
+    "@internal/operations": "0.17.0-dev.11",
+    "@internal/psl-parser": "0.17.0-dev.11",
+    "@internal/psl-printer": "0.17.0-dev.11",
+    "@internal/ts-render": "0.17.0-dev.11",
+    "@repo/tsconfig": "0.17.0-dev.11",
+    "@internal/publish-surface": "0.17.0-dev.11",
+    "@repo/tsdown": "0.17.0-dev.11",
+    "@internal/utils": "0.17.0-dev.11",
     "tsdown": "0.22.14",
     "typescript": "5.9.3",
     "vitest": "4.1.10"

package/dist/authoring-Dd7p6pTS.d.mts

@@ -1 +0,0 @@
-import "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";

package/dist/capabilities-CPj7MfXO-GRkp0Q_D.mjs

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

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

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

package/dist/codec-Cly9VPoA.mjs.map

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