@prisma/orm-framework 8.0.0-rc.14-dev.35 → 8.0.0-rc.14-dev.37

package/dist/{runtime-BccsLa5m.d.mts → runtime-NuBiQEuH.d.mts}

@@ -1,6 +1,6 @@
 import { G as PlanMeta } from "./domain-envelope-C2vVIWGK-C5x7cBpU.mjs";
 import { n as ContractExecutionSection } from "./contract-types-BIaUtO7Z-Bcxx2I74.mjs";
-import { a as CodecCallContext } from "./codec-types-CZ8xRBJy-BMjCsUt1.mjs";
+import { a as CodecCallContext } from "./codec-types-8NKqm4AQ-DyNSay3e.mjs";
 import { t as RuntimeErrorEnvelope } from "./runtime-error-CO4MA3Px-YW5SCUcH.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/runtime.d.mts
 //#region src/annotations.d.ts
@@ -413,6 +413,9 @@ type AfterExecuteResult = AfterResultBase & ({
 } | {
   readonly completed: false;
 });
+interface AfterTransactionResult {
+  readonly outcome: 'committed' | 'rolled-back' | 'unknown';
+}
 interface QueryInterceptResult {
   readonly rows: AsyncIterable<Record<string, unknown>> | Iterable<Record<string, unknown>>;
 }
@@ -563,6 +566,12 @@ interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan, TMutator extend
    */
   interceptExecute?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<ExecuteInterceptResult | undefined>;
   afterExecute?(plan: TPlan, result: AfterExecuteResult, ctx: RuntimeMiddlewareContext): Promise<void>;
+  /**
+   * The query's last hook. Fires exactly once for every query whose before-hooks and parameter encoding succeeded, when the transaction enclosing the query has ended, with its outcome. Outside a transaction it fires when the query ends: `committed` when it completed, `unknown` when it failed or the caller stopped reading its rows. A query is inside a transaction when it is sent on the transaction or on its connection after the transaction has begun and before its `commit()` or `rollback()` is called. A query sent on the connection while the transaction is still beginning counts as outside, although the database may run it inside. Inside a transaction, a resolved commit reports `unknown` when one of the transaction's queries failed. When the transaction ends while the query still runs, this fires at the end, before the query's after-hook, with the transaction's outcome, which may not be the query's: the query may reach the database after the transaction ends and run outside it, and its own failure is not counted. Receives the same plan and context as `afterQuery` or `afterExecute`. The runner logs and swallows thrown errors.
+   *
+   * Inside a transaction the hooks run one after another while its connection is still checked out, so their time adds to how long it is held. The hook must not use the connection, and must not wait on a connection from the same pool, for example by awaiting a query through the same runtime. A write it sends through the same runtime gets its own `afterTransaction`.
+   */
+  afterTransaction?(plan: TPlan, result: AfterTransactionResult, ctx: RuntimeMiddlewareContext): Promise<void>;
 }
 /**
  * Cross-family middleware — one that doesn't constrain `familyId` or
@@ -928,6 +937,27 @@ declare function runQueryWithMiddleware<TExec extends ExecutionPlan, Row>(exec:
  * without needing their own out-of-band signal.
  */
 declare function runExecuteWithMiddleware<TExec extends ExecutionPlan>(exec: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec>>, ctx: RuntimeMiddlewareContext, runDriver: () => Promise<RuntimeStatementStats>): Promise<RuntimeStatementStats>;
+/**
+ * Calls each middleware's `afterTransaction` hook in registration order. A
+ * thrown error is passed to `ctx.log.error` and swallowed, and later
+ * middleware still run. Never rejects, so a query's result or a resolved
+ * commit is never replaced by a hook's failure.
+ */
+declare function runAfterTransaction<TExec extends ExecutionPlan>(exec: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec>>, result: AfterTransactionResult, ctx: RuntimeMiddlewareContext): Promise<void>;
+/** How a query ended: its rows or statistics all arrived, an error came out of it, or the caller stopped reading its rows. */
+type QueryEnding = 'completed' | 'failed' | 'stopped';
+/**
+ * Returns what a query outside a transaction calls when it ends: it runs `runStage` with `committed` when the query completed and `unknown` otherwise. Returns `undefined` when `runStage` is `undefined`.
+ */
+declare function onQueryEndOutsideTransaction(runStage: ((result: AfterTransactionResult) => Promise<void>) | undefined): ((ending: QueryEnding) => Promise<void>) | undefined;
+/**
+ * Streams `rows()` and then calls `onQueryEnd` exactly once with how the query ended: `completed` when the stream completes, `failed` when an error comes out of it, and `stopped` when the caller stops reading, calls `return()` or throws into the iterator, before or after the first row. Returns `rows()` itself when `onQueryEnd` is `undefined`.
+ */
+declare function reportQueryEnding<Row>(onQueryEnd: ((ending: QueryEnding) => Promise<void>) | undefined, rows: () => AsyncIterable<Row>): AsyncIterable<Row>;
+/**
+ * Runs `execute()` and then calls `onQueryEnd` exactly once: with `completed` when it resolves, and with `failed` when it rejects.
+ */
+declare function reportExecuteEnding<T>(onQueryEnd: ((ending: QueryEnding) => Promise<void>) | undefined, execute: () => Promise<T>): Promise<T>;
 //#endregion
 //#region src/execution/runtime-core.d.ts
 /**
@@ -957,6 +987,13 @@ interface RuntimeCoreOptions<TMiddleware extends RuntimeMiddleware<ExecutionPlan
  * 4. The matching runner processes `interceptQuery` or `interceptExecute`
  *    before invoking the driver. Queries then fire `onRow` and `afterQuery`;
  *    statements fire `afterExecute`.
+ * 5. Every operation whose lowering (which encodes parameters) and before-hooks
+ *    succeeded fires `afterTransaction` once, as its last hook: `committed`
+ *    when it completed, `unknown` when it threw or the caller stopped reading
+ *    its rows. `reportQueryEnding` and `reportExecuteEnding` report how the
+ *    operation ended, and `onQueryEndOutsideTransaction` turns that into the
+ *    outcome; family runtimes that override `query` or `execute` call them
+ *    too, with {@link afterTransactionStageFor}.
  *
  * Concrete subclasses must implement `lower`, `runDriver`, `runExecute`, and
  * `close`.
@@ -972,7 +1009,12 @@ interface RuntimeCoreOptions<TMiddleware extends RuntimeMiddleware<ExecutionPlan
 declare abstract class RuntimeCore<TPlan extends QueryPlan, TExec extends ExecutionPlan, TMiddleware extends RuntimeMiddleware<TExec>> implements RuntimeExecutor<TPlan> {
   protected readonly middleware: ReadonlyArray<TMiddleware>;
   protected readonly ctx: RuntimeMiddlewareContext;
+  protected readonly anyMiddlewareDeclaresAfterTransaction: boolean;
   constructor(options: RuntimeCoreOptions<TMiddleware>);
+  /**
+   * Returns the function that runs every middleware's `afterTransaction` hook for one operation with a given result, or `undefined` when no middleware declared the hook when the runtime was created.
+   */
+  protected afterTransactionStageFor(exec: TExec, ctx: RuntimeMiddlewareContext): ((result: AfterTransactionResult) => Promise<void>) | undefined;
   /**
    * Pre-lowering hook for plan rewriting. Defaults to identity. Subclasses
    * may override to run a `beforeCompile` middleware chain (SQL does this
@@ -1131,5 +1173,5 @@ interface LaneMetaBuilder<K extends OperationKind> extends MetaBuilder<K> {
  */
 declare function createMetaBuilder<K extends OperationKind>(kind: K, terminalName: string): LaneMetaBuilder<K>;
 //#endregion
-export { runtimeAborted as $, RuntimeExecutor as A, applyMutationDefaults as B, RelationKeys as C, RuntimeCore as D, RuntimeAbortedPhase as E, RuntimeStatementStats as F, collectMutationDefaultGenerators as G, assertMutationDefaultGeneratorsAvailable as H, Scalars as I, raceAgainstAbort as J, createMetaBuilder as K, Shape as L, RuntimeMiddleware as M, RuntimeMiddlewareContext as N, RuntimeCoreOptions as O, RuntimeMutationDefaultGenerator as P, runQueryWithMiddleware as Q, ShapeSpec as R, RUNTIME_ABORTED as S, ResultType as T, checkAborted as U, assertAnnotationsApplicable as V, checkMiddlewareCompatibility as W, runBeforeQueryChain as X, runBeforeExecuteChain as Y, runExecuteWithMiddleware as Z, MutationDefaultsOptions as _, AppliedMutationDefault as a, QueryInterceptResult as b, DefineAnnotationOptions as c, GeneratorStability as d, LaneMetaBuilder as f, MutationDefaultsOp as g, MutationDefaults as h, AnnotationValue as i, RuntimeLog as j, RuntimeExecuteOptions as k, ExecuteInterceptResult as l, MutationDefaultGeneratorContributor as m, AfterQueryResult as n, AsyncIterableResult as o, MetaBuilder as p, defineAnnotation as q, AnnotationHandle as r, CrossFamilyMiddleware as s, AfterExecuteResult as t, ExecutionPlan as u, OperationKind as v, RelationNamesOf as w, QueryPlan as x, ParamRefMutator as y, ValidAnnotations as z };
-//# sourceMappingURL=runtime-BccsLa5m.d.mts.map
+export { reportQueryEnding as $, RuntimeCoreOptions as A, ShapeSpec as B, QueryPlan as C, ResultType as D, RelationNamesOf as E, RuntimeMiddlewareContext as F, checkAborted as G, applyMutationDefaults as H, RuntimeMutationDefaultGenerator as I, createMetaBuilder as J, checkMiddlewareCompatibility as K, RuntimeStatementStats as L, RuntimeExecutor as M, RuntimeLog as N, RuntimeAbortedPhase as O, RuntimeMiddleware as P, reportExecuteEnding as Q, Scalars as R, QueryInterceptResult as S, RelationKeys as T, assertAnnotationsApplicable as U, ValidAnnotations as V, assertMutationDefaultGeneratorsAvailable as W, onQueryEndOutsideTransaction as X, defineAnnotation as Y, raceAgainstAbort as Z, MutationDefaultsOp as _, AnnotationValue as a, runtimeAborted as at, ParamRefMutator as b, CrossFamilyMiddleware as c, ExecutionPlan as d, runAfterTransaction as et, GeneratorStability as f, MutationDefaults as g, MutationDefaultGeneratorContributor as h, AnnotationHandle as i, runQueryWithMiddleware as it, RuntimeExecuteOptions as j, RuntimeCore as k, DefineAnnotationOptions as l, MetaBuilder as m, AfterQueryResult as n, runBeforeQueryChain as nt, AppliedMutationDefault as o, LaneMetaBuilder as p, collectMutationDefaultGenerators as q, AfterTransactionResult as r, runExecuteWithMiddleware as rt, AsyncIterableResult as s, AfterExecuteResult as t, runBeforeExecuteChain as tt, ExecuteInterceptResult as u, MutationDefaultsOptions as v, RUNTIME_ABORTED as w, QueryEnding as x, OperationKind as y, Shape as z };
+//# sourceMappingURL=runtime-NuBiQEuH.d.mts.map

package/dist/runtime-NuBiQEuH.d.mts.map

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

package/dist/{temporal-presets-pC0xlwib-Diikns1l.d.mts → temporal-presets-CLsu00ZK-CAx-cLAM.d.mts}

@@ -1,6 +1,6 @@
-import { T as AuthoringStorageTypeTemplate, W as ScalarTypeConstructorOutput } from "./framework-authoring-BJf_-FTJ-K8fp3V_r.mjs";
-import { c as MutationDefaultGeneratorDescriptor } from "./mutation-default-types-CrA6rrwU-BkMgh2pO.mjs";
-//#region ../../../1-framework/1-core/framework-components/dist/temporal-presets-pC0xlwib.d.mts
+import { T as AuthoringStorageTypeTemplate, W as ScalarTypeConstructorOutput } from "./framework-authoring-DRrZ8_s0-CJ7XXqvx.mjs";
+import { c as MutationDefaultGeneratorDescriptor } from "./mutation-default-types-D_M8NC3U-BQNexfRU.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/temporal-presets-CLsu00ZK.d.mts
 //#region src/shared/tagged-literal.d.ts
 /**
  * Every failure `offset` is an index into the resolved text the function was
@@ -157,4 +157,4 @@ declare function temporalCodecPreset<const Storage extends PresetStorageTemplate
 };
 //#endregion
 export { TIMESTAMP_NOW_GENERATOR_ID as a, describeTaggedLiteralFailure as c, resolveTemplateTagEscapes as d, temporalAuthoringPresets as f, timestampNowControlDescriptor as h, TEMPORAL_ON_UPDATE_ARG as i, printTaggedLiteral as l, temporalPhaseTemplate as m, TAGGED_LITERAL_MAX_BYTES as n, TaggedLiteralCanonicalization as o, temporalCodecPreset as p, TEMPORAL_ON_CREATE_ARG as r, canonicalizeTaggedLiteralBody as s, PresetStorageTemplate as t, resolvePslBacktickEscapes as u };
-//# sourceMappingURL=temporal-presets-pC0xlwib-Diikns1l.d.mts.map
+//# sourceMappingURL=temporal-presets-CLsu00ZK-CAx-cLAM.d.mts.map

package/dist/{temporal-presets-pC0xlwib-Diikns1l.d.mts.map → temporal-presets-CLsu00ZK-CAx-cLAM.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"temporal-presets-pC0xlwib-Diikns1l.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/temporal-presets-pC0xlwib.d.mts"],"mappings":";;;;;;;;KAOK;WACM;WACA;;WAEA;WACA;WACA;;cAEG;;iBAEG,6BAA6B;;iBAE7B,0BAA0B;;iBAE1B,0BAA0B;;;;;;;;iBAQ1B,8BAA8B,mBAAmB;;;;;;;iBAOjD,mBAAmB,aAAa;;;;;;KAM5C,wBAAwB,8BAA8B;;;;cAI7C;;;;;;iBAMG,iCAAiC;;;;iBAIjC,+BAA+B,gBAAgB,6BAA6B,oCAAoC,4BAA4B,OAAO;WACzJ,cAAc;;WAEd;aACE;aACA,QAAQ,KAAK;eACX,cAAc;;eAEd;iBACE;mBACE;mBACA,qBAAqB;;;;;WAK7B;aACE;aACA,QAAQ,KAAK;eACX,cAAc;;eAEd;iBACE;mBACE;mBACA,qBAAqB;;iBAEvB;mBACE;mBACA,qBAAqB;;;;;;cAM1B;WACH;WACA;WACA;WACA;;cAEG;WACH;WACA;WACA;WACA;;;;;iBAKM,4BAA4B,4BAA4B,4BAA4B,OAAO,OAAO,aAAa;WACrH;WACA,OAAO;WACP;aACE;eACE;eACA,IAAI;;;;;;;iBAOF,0BAA0B,gBAAgB,uBAAuB,SAAS;WAChF;WACA;aACE;aACA;aACA;aACA;;aAEA;aACA;aACA;aACA;;WAEF,QAAQ;aACN;eACE;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA;;;;eAIN;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA"}
+{"version":3,"file":"temporal-presets-CLsu00ZK-CAx-cLAM.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/temporal-presets-CLsu00ZK.d.mts"],"mappings":";;;;;;;;KAOK;WACM;WACA;;WAEA;WACA;WACA;;cAEG;;iBAEG,6BAA6B;;iBAE7B,0BAA0B;;iBAE1B,0BAA0B;;;;;;;;iBAQ1B,8BAA8B,mBAAmB;;;;;;;iBAOjD,mBAAmB,aAAa;;;;;;KAM5C,wBAAwB,8BAA8B;;;;cAI7C;;;;;;iBAMG,iCAAiC;;;;iBAIjC,+BAA+B,gBAAgB,6BAA6B,oCAAoC,4BAA4B,OAAO;WACzJ,cAAc;;WAEd;aACE;aACA,QAAQ,KAAK;eACX,cAAc;;eAEd;iBACE;mBACE;mBACA,qBAAqB;;;;;WAK7B;aACE;aACA,QAAQ,KAAK;eACX,cAAc;;eAEd;iBACE;mBACE;mBACA,qBAAqB;;iBAEvB;mBACE;mBACA,qBAAqB;;;;;;cAM1B;WACH;WACA;WACA;WACA;;cAEG;WACH;WACA;WACA;WACA;;;;;iBAKM,4BAA4B,4BAA4B,4BAA4B,OAAO,OAAO,aAAa;WACrH;WACA,OAAO;WACP;aACE;eACE;eACA,IAAI;;;;;;;iBAOF,0BAA0B,gBAAgB,uBAAuB,SAAS;WAChF;WACA;aACE;aACA;aACA;aACA;;aAEA;aACA;aACA;aACA;;WAEF,QAAQ;aACN;eACE;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA;;;;eAIN;iBACE;iBACA;iBACA;mBACE;qBACE;qBACA"}

package/dist/{temporal-presets-UoKnoAlu-6864WUSv.mjs → temporal-presets-DIo9uYtS-Odk6WBk8.mjs}

@@ -4,7 +4,7 @@ import { d as isExecutionMutationDefaultValue, u as isColumnDefaultLiteralInputV
 import { t as InternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
 import { n as invariant } from "./assertions-Dw1lZz_Q.mjs";
 import { n as runtimeError } from "./runtime-error-BA9d7XjZ-BlT8t6LB.mjs";
-//#region ../../../1-framework/1-core/framework-components/dist/temporal-presets-UoKnoAlu.mjs
+//#region ../../../1-framework/1-core/framework-components/dist/temporal-presets-DIo9uYtS.mjs
 const AUTHORING_WARNING_BATCH_THRESHOLD = 5;
 /**
 * Emits collected authoring warnings once per build, grouped by `code`:
@@ -79,6 +79,22 @@ function resolveEnumCodecId(block, ctx) {
 		codecSpan: typeAttr.argSpans?.["codecId"] ?? typeAttr.span
 	};
 }
+const TAG_ENTRY_PREFIX = "tag:";
+/**
+* The key an entry sits under when its tag yields a type whose own key is taken by the entry for
+* another syntax: SQLite's `json` tag yields `sqlite/text`, whose entry reads a plain string. A data
+* type id is `owner/name`, so this key never collides with one.
+*/
+function tagEntryKey(tag) {
+	return `${TAG_ENTRY_PREFIX}${tag}`;
+}
+function isTagEntryKey(key) {
+	return key.startsWith(TAG_ENTRY_PREFIX);
+}
+/** The data type a value entry reads its written form as: its tag's `type`, or else its key. */
+function authoringEntryType(key, entry) {
+	return entry.written.kind === "tag" && entry.written.type !== void 0 ? entry.written.type : key;
+}
 function isAuthoringArgRef(value) {
 	if (typeof value !== "object" || value === null || value.kind !== "arg") return false;
 	const { index, path } = value;
@@ -954,6 +970,6 @@ function temporalCodecPreset(storage) {
 	};
 }
 //#endregion
-export { temporalAuthoringPresets as A, mergeAuthoringAttributeSpecs as C, resolveEnumCodecId as D, resolveAuthoringTemplateValue as E, validateAuthoringTypeParams as F, temporalPhaseTemplate as M, timestampNowControlDescriptor as N, resolvePslBacktickEscapes as O, validateAuthoringHelperArguments as P, isAuthoringTypeConstructorDescriptor as S, printTaggedLiteral as T, isAuthoringArgRef as _, assertNoCrossRegistryCollisions as a, isAuthoringModelAttributeDescriptor as b, classifyEnumMemberType as c, describeTaggedLiteralFailure as d, flushAuthoringWarnings as f, instantiateAuthoringTypeConstructor as g, instantiateAuthoringFieldPreset as h, TIMESTAMP_NOW_GENERATOR_ID as i, temporalCodecPreset as j, resolveTemplateTagEscapes as k, collectContributedDescriptorPaths as l, instantiateAuthoringEntityType as m, TEMPORAL_ON_CREATE_ARG as n, assertResolvableTypeConstructorTemplates as o, getAuthoringTypeConstructor as p, TEMPORAL_ON_UPDATE_ARG as r, canonicalizeTaggedLiteralBody as s, TAGGED_LITERAL_MAX_BYTES as t, collectScalarTypeConstructors as u, isAuthoringEntityTypeDescriptor as v, mergeAuthoringNamespaces as w, isAuthoringPslBlockDescriptor as x, isAuthoringFieldPresetDescriptor as y };
+export { resolvePslBacktickEscapes as A, isAuthoringTypeConstructorDescriptor as C, printTaggedLiteral as D, mergeAuthoringNamespaces as E, temporalPhaseTemplate as F, timestampNowControlDescriptor as I, validateAuthoringHelperArguments as L, tagEntryKey as M, temporalAuthoringPresets as N, resolveAuthoringTemplateValue as O, temporalCodecPreset as P, validateAuthoringTypeParams as R, isAuthoringPslBlockDescriptor as S, mergeAuthoringAttributeSpecs as T, instantiateAuthoringTypeConstructor as _, assertNoCrossRegistryCollisions as a, isAuthoringFieldPresetDescriptor as b, canonicalizeTaggedLiteralBody as c, collectScalarTypeConstructors as d, describeTaggedLiteralFailure as f, instantiateAuthoringFieldPreset as g, instantiateAuthoringEntityType as h, TIMESTAMP_NOW_GENERATOR_ID as i, resolveTemplateTagEscapes as j, resolveEnumCodecId as k, classifyEnumMemberType as l, getAuthoringTypeConstructor as m, TEMPORAL_ON_CREATE_ARG as n, assertResolvableTypeConstructorTemplates as o, flushAuthoringWarnings as p, TEMPORAL_ON_UPDATE_ARG as r, authoringEntryType as s, TAGGED_LITERAL_MAX_BYTES as t, collectContributedDescriptorPaths as u, isAuthoringArgRef as v, isTagEntryKey as w, isAuthoringModelAttributeDescriptor as x, isAuthoringEntityTypeDescriptor as y };
 
-//# sourceMappingURL=temporal-presets-UoKnoAlu-6864WUSv.mjs.map
+//# sourceMappingURL=temporal-presets-DIo9uYtS-Odk6WBk8.mjs.map

package/dist/temporal-presets-DIo9uYtS-Odk6WBk8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-presets-DIo9uYtS-Odk6WBk8.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/temporal-presets-DIo9uYtS.mjs"],"sourcesContent":["import { n as runtimeError } from \"./runtime-error-BA9d7XjZ.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue } from \"@internal/contract/types\";\nimport { invariant } from \"@internal/utils/assertions\";\nimport { InternalError } from \"@internal/utils/internal-error\";\n//#region src/shared/framework-authoring.ts\nconst AUTHORING_WARNING_BATCH_THRESHOLD = 5;\n/**\n* Emits collected authoring warnings once per build, grouped by `code`:\n* a group at or below the threshold itemizes every `message`; above it,\n* one summary — `\"<count> <summary>\"` followed by the `item` lines — so\n* a build with many hits of one kind does not wall-of-text, and warnings\n* of different codes never batch into each other's summary.\n*/\nfunction flushAuthoringWarnings(warnings) {\n\tconst groups = /* @__PURE__ */ new Map();\n\tfor (const warning of warnings) {\n\t\tconst key = JSON.stringify([warning.code, warning.summary]);\n\t\tconst group = groups.get(key) ?? [];\n\t\tgroup.push(warning);\n\t\tgroups.set(key, group);\n\t}\n\tfor (const group of groups.values()) {\n\t\tconst first = group[0];\n\t\tif (first === void 0) continue;\n\t\tif (group.length <= AUTHORING_WARNING_BATCH_THRESHOLD) {\n\t\t\tfor (const warning of group) process.emitWarning(warning.message, { code: warning.code });\n\t\t\tcontinue;\n\t\t}\n\t\tprocess.emitWarning(`${group.length} ${first.summary}\\n${group.map((w) => `  - ${w.item}`).join(\"\\n\")}`, { code: first.code });\n\t}\n}\nfunction classifyEnumMemberType(values) {\n\tlet sawText = false;\n\tlet sawInt = false;\n\tfor (const key of Object.keys(values)) {\n\t\tconst value = values[key];\n\t\tif (value === void 0 || typeof value === \"string\") sawText = true;\n\t\telse if (typeof value === \"number\" && Number.isInteger(value)) sawInt = true;\n\t\telse return null;\n\t}\n\tif (sawText && sawInt) return null;\n\tif (sawText) return \"text\";\n\tif (sawInt) return \"int\";\n\treturn null;\n}\n/**\n* Resolves the codec id for an `enum` block. When `@@type` is absent, the codec\n* is inferred from the members via {@link classifyEnumMemberType}; otherwise the\n* explicit `@@type(\"codec\")` argument is parsed. Pushes the appropriate\n* diagnostic and returns `undefined` when neither yields a codec. `codecSpan` is\n* the span downstream codec-validation diagnostics should anchor to. Shared by\n* every family's enum factory so inference and the explicit path stay identical.\n*/\nfunction resolveEnumCodecId(block, ctx) {\n\tconst sourceId = ctx.sourceId ?? \"unknown\";\n\tconst typeAttr = block.attributes[\"type\"];\n\tif (typeAttr === void 0) {\n\t\tconst inferredKind = classifyEnumMemberType(block.values);\n\t\tif (inferredKind === null || ctx.enumInferenceCodecs === void 0) {\n\t\t\tctx.diagnostics?.push({\n\t\t\t\tcode: \"PSL_ENUM_CANNOT_INFER_TYPE\",\n\t\t\t\tmessage: `cannot infer @@type for enum \"${block.name}\"; add an explicit @@type(...)`,\n\t\t\t\tsourceId,\n\t\t\t\tspan: block.span\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\t\treturn {\n\t\t\tcodecId: ctx.enumInferenceCodecs[inferredKind],\n\t\t\tcodecSpan: block.span\n\t\t};\n\t}\n\tconst codecId = typeAttr.args[\"codecId\"];\n\tinvariant(typeof codecId === \"string\", \"@@type on an enum block parses one string argument\");\n\treturn {\n\t\tcodecId,\n\t\tcodecSpan: typeAttr.argSpans?.[\"codecId\"] ?? typeAttr.span\n\t};\n}\nconst TAG_ENTRY_PREFIX = \"tag:\";\n/**\n* The key an entry sits under when its tag yields a type whose own key is taken by the entry for\n* another syntax: SQLite's `json` tag yields `sqlite/text`, whose entry reads a plain string. A data\n* type id is `owner/name`, so this key never collides with one.\n*/\nfunction tagEntryKey(tag) {\n\treturn `${TAG_ENTRY_PREFIX}${tag}`;\n}\nfunction isTagEntryKey(key) {\n\treturn key.startsWith(TAG_ENTRY_PREFIX);\n}\n/** The data type a value entry reads its written form as: its tag's `type`, or else its key. */\nfunction authoringEntryType(key, entry) {\n\treturn entry.written.kind === \"tag\" && entry.written.type !== void 0 ? entry.written.type : key;\n}\nfunction isAuthoringArgRef(value) {\n\tif (typeof value !== \"object\" || value === null || value.kind !== \"arg\") return false;\n\tconst { index, path } = value;\n\tif (typeof index !== \"number\" || !Number.isInteger(index) || index < 0) return false;\n\tif (path !== void 0 && (!Array.isArray(path) || path.some((s) => typeof s !== \"string\"))) return false;\n\treturn true;\n}\nfunction isAuthoringSelectRef(value) {\n\tif (!isAuthoringTemplateRecord(value) || value[\"kind\"] !== \"select\") return false;\n\tconst index = value[\"index\"];\n\tconst path = value[\"path\"];\n\tconst cases = value[\"cases\"];\n\tif (typeof index !== \"number\" || !Number.isInteger(index) || index < 0) return false;\n\tif (path !== void 0 && (!Array.isArray(path) || path.some((s) => typeof s !== \"string\"))) return false;\n\treturn typeof cases === \"object\" && cases !== null && !Array.isArray(cases);\n}\nfunction isAuthoringTemplateRecord(value) {\n\treturn typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\nfunction readTemplateArgumentValue(args, index, path) {\n\tlet value = args[index];\n\tfor (const segment of path ?? []) {\n\t\tif (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) return;\n\t\tvalue = value[segment];\n\t}\n\treturn value;\n}\nfunction isAuthoringTypeConstructorDescriptor(value) {\n\treturn \"kind\" in value && value.kind === \"typeConstructor\";\n}\n/** The type constructor at `path` in the contributions' type namespace, or `undefined` when none is there. */\nfunction getAuthoringTypeConstructor(contributions, path) {\n\tlet current = contributions?.type;\n\tfor (const segment of path) {\n\t\tif (typeof current !== \"object\" || current === null || \"kind\" in current) return;\n\t\tcurrent = current[segment];\n\t}\n\treturn current !== void 0 && isAuthoringTypeConstructorDescriptor(current) ? current : void 0;\n}\nfunction isAuthoringFieldPresetDescriptor(value) {\n\treturn \"kind\" in value && value.kind === \"fieldPreset\";\n}\nfunction isAuthoringEntityTypeDescriptor(value) {\n\treturn \"kind\" in value && value.kind === \"entity\";\n}\nfunction isAuthoringPslBlockDescriptor(value) {\n\treturn \"kind\" in value && value.kind === \"pslBlock\";\n}\nfunction isAuthoringModelAttributeDescriptor(value) {\n\treturn \"kind\" in value && value.kind === \"modelAttribute\";\n}\nfunction isCopyableNamespaceObject(value) {\n\tif (typeof value !== \"object\" || value === null || Array.isArray(value)) return false;\n\tconst proto = Object.getPrototypeOf(value);\n\treturn proto === Object.prototype || proto === null;\n}\n/**\n* Deep structural check run only at the composition boundary (the merge and\n* collect walkers) to classify a raw namespace-tree node as a leaf descriptor.\n* A node counts as a leaf iff its `kind` matches `descriptorKind` AND it\n* carries that kind's required fields.\n*\n* This is boundary validation over `unknown`, NOT a type-predicate: the four\n* exported `isAuthoring*Descriptor` predicates deliberately narrow on `kind`\n* alone and trust the static types. The walkers, by contrast, also receive\n* type-bypassing packs (`as unknown as never` in tests, untyped JS at runtime)\n* whose descriptor-shaped-but-incomplete nodes must be rejected rather than\n* silently treated as sub-namespaces — so the well-formedness check lives here.\n*/\nfunction isWellFormedDescriptor(value, descriptorKind) {\n\tif (typeof value !== \"object\" || value === null) return false;\n\tif (!(\"kind\" in value) || value.kind !== descriptorKind) return false;\n\tswitch (descriptorKind) {\n\t\tcase \"typeConstructor\":\n\t\tcase \"fieldPreset\": {\n\t\t\tif (!(\"output\" in value)) return false;\n\t\t\tconst output = value.output;\n\t\t\treturn typeof output === \"object\" && output !== null;\n\t\t}\n\t\tcase \"entity\": {\n\t\t\tif (!(\"discriminator\" in value) || typeof value.discriminator !== \"string\") return false;\n\t\t\tif (value.discriminator.length === 0) return false;\n\t\t\tif (!(\"output\" in value)) return false;\n\t\t\tconst output = value.output;\n\t\t\tif (typeof output !== \"object\" || output === null) return false;\n\t\t\tconst factory = \"factory\" in output ? output.factory : void 0;\n\t\t\tconst template = \"template\" in output ? output.template : void 0;\n\t\t\treturn typeof factory === \"function\" || template !== void 0;\n\t\t}\n\t\tcase \"pslBlock\": {\n\t\t\tif (!(\"keyword\" in value) || typeof value.keyword !== \"string\" || value.keyword.length === 0) return false;\n\t\t\tif (!(\"discriminator\" in value) || typeof value.discriminator !== \"string\" || value.discriminator.length === 0) return false;\n\t\t\tif (!(\"name\" in value)) return false;\n\t\t\tconst name = value.name;\n\t\t\tif (typeof name !== \"object\" || name === null) return false;\n\t\t\tif (!(\"required\" in name) || typeof name.required !== \"boolean\") return false;\n\t\t\tif (!(\"spec\" in value) || typeof value.spec !== \"function\") return false;\n\t\t\tif (!(\"attributes\" in value) || value.attributes === void 0) return true;\n\t\t\tconst attributes = value.attributes;\n\t\t\tif (typeof attributes !== \"object\" || attributes === null || Array.isArray(attributes)) return false;\n\t\t\treturn Object.values(attributes).every((factory) => typeof factory === \"function\");\n\t\t}\n\t\tcase \"modelAttribute\":\n\t\t\tif (!(\"attribute\" in value) || typeof value.attribute !== \"string\" || value.attribute.length === 0) return false;\n\t\t\tif (!(\"spec\" in value)) return false;\n\t\t\treturn \"lower\" in value && typeof value.lower === \"function\";\n\t\tdefault: return false;\n\t}\n}\nfunction deepCopyNamespace(source, descriptorKind) {\n\tconst copy = {};\n\tfor (const [key, value] of Object.entries(source)) copy[key] = isCopyableNamespaceObject(value) && !isWellFormedDescriptor(value, descriptorKind) ? deepCopyNamespace(value, descriptorKind) : value;\n\treturn copy;\n}\n/**\n* Merges `source` into `target` recursively at the descriptor-namespace\n* level. `descriptorKind` is the `kind` value ('typeConstructor',\n* 'fieldPreset', 'entity', or 'pslBlock') that identifies a descriptor\n* (terminal merge point; same-path registrations across components are\n* reported as duplicates) as opposed to a sub-namespace (recursion target).\n*\n* Path segments are validated against prototype-pollution names\n* (`__proto__`, `constructor`, `prototype`). A value that is neither a\n* recognized leaf nor a plain object — e.g. a malformed descriptor\n* where the canonical leaf guard rejected it for missing `output` —\n* is reported as an invalid contribution rather than recursed into,\n* which would either silently mangle state or infinite-loop on\n* primitive properties.\n*\n* Within-registry duplicate detection is this walker's job;\n* cross-registry detection runs separately via\n* `assertNoCrossRegistryCollisions` after merging completes.\n*/\nfunction mergeAuthoringNamespaces(target, source, path, descriptorKind, label) {\n\tconst assertSafePath = (currentPath) => {\n\t\tconst blockedSegment = currentPath.find((segment) => segment === \"__proto__\" || segment === \"constructor\" || segment === \"prototype\");\n\t\tif (blockedSegment) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Invalid authoring ${label} helper \"${currentPath.join(\".\")}\". Helper path segments must not use \"${blockedSegment}\".`);\n\t};\n\tfor (const [key, sourceValue] of Object.entries(source)) {\n\t\tconst currentPath = [...path, key];\n\t\tassertSafePath(currentPath);\n\t\tconst hasExistingValue = Object.hasOwn(target, key);\n\t\tconst existingValue = hasExistingValue ? target[key] : void 0;\n\t\tif (!hasExistingValue) {\n\t\t\ttarget[key] = isCopyableNamespaceObject(sourceValue) && !isWellFormedDescriptor(sourceValue, descriptorKind) ? deepCopyNamespace(sourceValue, descriptorKind) : sourceValue;\n\t\t\tcontinue;\n\t\t}\n\t\tconst existingIsLeaf = isWellFormedDescriptor(existingValue, descriptorKind);\n\t\tconst sourceIsLeaf = isWellFormedDescriptor(sourceValue, descriptorKind);\n\t\tif (existingIsLeaf || sourceIsLeaf) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Duplicate authoring ${label} helper \"${currentPath.join(\".\")}\". Helper names must be unique across composed packs.`);\n\t\tif (!isCopyableNamespaceObject(existingValue) || !isCopyableNamespaceObject(sourceValue)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Invalid authoring ${label} helper \"${currentPath.join(\".\")}\". Expected a sub-namespace object or a recognized descriptor; received a malformed value.`);\n\t\tmergeAuthoringNamespaces(existingValue, sourceValue, currentPath, descriptorKind, label);\n\t}\n}\nconst ATTRIBUTE_SPEC_LEVELS = [\"model\", \"field\"];\nfunction mergeAuthoringAttributeSpecs(target, source, contributedBy, owners) {\n\tconst invalidContribution = (detail) => runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Invalid authoring attributeSpecs contribution from descriptor \"${contributedBy}\". ${detail}`);\n\tif (!isCopyableNamespaceObject(source)) throw invalidContribution(\"Expected a record carrying a \\\"model\\\" and a \\\"field\\\" level.\");\n\tfor (const level of ATTRIBUTE_SPEC_LEVELS) {\n\t\tconst contributed = source[level];\n\t\tif (!isCopyableNamespaceObject(contributed)) throw invalidContribution(`The \"${level}\" level must be a record of spec factories keyed by attribute name.`);\n\t\tfor (const [attribute, factory] of Object.entries(contributed)) {\n\t\t\tconst entryPath = `${level}.${attribute}`;\n\t\t\tconst invalidEntry = (detail) => runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Invalid authoring attributeSpecs entry \"${entryPath}\" contributed by descriptor \"${contributedBy}\". ${detail}`);\n\t\t\tif (attribute === \"__proto__\" || attribute === \"constructor\" || attribute === \"prototype\") throw invalidEntry(`Attribute names must not use \"${attribute}\".`);\n\t\t\tif (typeof factory !== \"function\") throw invalidEntry(\"Each entry must be a spec factory function.\");\n\t\t\tconst existingOwner = owners.get(entryPath);\n\t\t\tif (existingOwner !== void 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Duplicate authoring attributeSpecs entry \"${entryPath}\". Descriptor \"${contributedBy}\" conflicts with \"${existingOwner}\". Each attribute name may be claimed once per level.`);\n\t\t\towners.set(entryPath, contributedBy);\n\t\t\ttarget[level][attribute] = factory;\n\t\t}\n\t}\n}\n/**\n* Collects the full dotted paths of every well-formed descriptor of\n* `descriptorKind` in a raw contribution tree, using the same boundary\n* classification as {@link mergeAuthoringNamespaces}. Lets assembly-level\n* callers attribute each contributed path to its contributing component\n* before merging, so a same-path collision can be reported naming both\n* contributors.\n*/\nfunction collectContributedDescriptorPaths(namespace, descriptorKind, path = []) {\n\tconst paths = [];\n\tfor (const [key, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, key];\n\t\tif (isWellFormedDescriptor(value, descriptorKind)) {\n\t\t\tpaths.push(currentPath.join(\".\"));\n\t\t\tcontinue;\n\t\t}\n\t\tif (isCopyableNamespaceObject(value)) paths.push(...collectContributedDescriptorPaths(value, descriptorKind, currentPath));\n\t}\n\treturn paths;\n}\n/**\n* Derives the scalar view of an assembled authoring type namespace: every\n* **top-level** type constructor that is instantiable with an empty argument\n* list — all declared args optional and no entity-ref argument. A bare type\n* name `T` in a schema is semantically the zero-arg instantiation `T()`, so\n* each entry is exactly what that call produces (defaulted template values\n* applied, absent optional-arg typeParams keys omitted). Constructors\n* registered under a namespace segment, constructors with required args, and\n* entity-ref constructors are not scalars and are excluded.\n*\n* Eligibility needs no template inspection: templates that cannot resolve\n* for their legal call shapes are rejected at the composition boundary by\n* {@link assertResolvableTypeConstructorTemplates}, so the zero-arg\n* instantiation below cannot fail for an eligible constructor.\n*/\nfunction collectScalarTypeConstructors(namespace) {\n\tconst result = /* @__PURE__ */ new Map();\n\tfor (const [name, value] of Object.entries(namespace)) {\n\t\tif (!isAuthoringTypeConstructorDescriptor(value)) continue;\n\t\tif (value.entityRefArg !== void 0) continue;\n\t\tif (value.args?.some((arg) => arg.optional !== true)) continue;\n\t\tresult.set(name, instantiateAuthoringTypeConstructor(value, []));\n\t}\n\treturn result;\n}\nfunction visitTemplateArgRefs(template, visit) {\n\tif (template === void 0) return;\n\tif (isAuthoringArgRef(template)) {\n\t\tvisit(template);\n\t\tvisitTemplateArgRefs(template.default, visit);\n\t\treturn;\n\t}\n\tif (Array.isArray(template)) {\n\t\tfor (const value of template) visitTemplateArgRefs(value, visit);\n\t\treturn;\n\t}\n\tif (typeof template === \"object\" && template !== null) for (const value of Object.values(template)) visitTemplateArgRefs(value, visit);\n}\n/**\n* Boundary validation for a contributed authoring type namespace, called\n* per contributing component at assembly (which supplies `contributedBy`\n* for attribution). Rejects what the types cannot express — entity-ref\n* constructors are skipped (their output derives from the referenced\n* entity): every `typeParams` arg-ref (including refs inside arg-ref\n* defaults) must point at a declared argument index.\n*/\nfunction assertResolvableTypeConstructorTemplates(namespace, contributedBy, path = []) {\n\tfor (const [name, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, name];\n\t\tif (!isAuthoringTypeConstructorDescriptor(value)) {\n\t\t\tassertResolvableTypeConstructorTemplates(value, contributedBy, currentPath);\n\t\t\tcontinue;\n\t\t}\n\t\tif (value.entityRefArg !== void 0) continue;\n\t\tconst args = value.args ?? [];\n\t\tconst invalid = (detail) => /* @__PURE__ */ new Error(`Invalid authoring type constructor \"${currentPath.join(\".\")}\" contributed by descriptor \"${contributedBy}\". ${detail}`);\n\t\tfor (const [key, template] of Object.entries(value.output.typeParams ?? {})) visitTemplateArgRefs(template, (ref) => {\n\t\t\tif (args[ref.index] === void 0) throw invalid(`output.typeParams.${key} references argument ${ref.index}, but the constructor declares ${args.length} argument(s). Declare the argument or correct the reference index.`);\n\t\t});\n\t}\n}\nfunction collectDescriptorPaths(namespace, isLeaf, path = []) {\n\tconst paths = [];\n\tfor (const [key, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, key];\n\t\tif (isLeaf(value)) {\n\t\t\tpaths.push(currentPath.join(\".\"));\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof value === \"object\" && value !== null && !Array.isArray(value)) paths.push(...collectDescriptorPaths(value, isLeaf, currentPath));\n\t}\n\treturn paths;\n}\nfunction collectDescriptorEntries(namespace, isLeaf, descriptorKind, label, path = []) {\n\tconst entries = [];\n\tfor (const [key, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, key];\n\t\tif (isLeaf(value)) {\n\t\t\tif (!isWellFormedDescriptor(value, descriptorKind)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Malformed authoring ${label} contribution at \"${currentPath.join(\".\")}\". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the ${label} descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);\n\t\t\tif (value.discriminator.length > 0) entries.push({\n\t\t\t\tpath: currentPath.join(\".\"),\n\t\t\t\tdiscriminator: value.discriminator\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof value === \"object\" && value !== null && !Array.isArray(value)) {\n\t\t\tconst record = blindCast(value);\n\t\t\tif ((record[\"kind\"] !== void 0 || record[\"keyword\"] !== void 0 || record[\"discriminator\"] !== void 0) && !isLeaf(value)) {\n\t\t\t\tconst hasKind = record[\"kind\"] === \"pslBlock\";\n\t\t\t\tconst hasKeyword = typeof record[\"keyword\"] === \"string\";\n\t\t\t\tconst hasDiscriminator = typeof record[\"discriminator\"] === \"string\";\n\t\t\t\tif (hasKind || hasKeyword && hasDiscriminator) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Malformed authoring ${label} contribution at \"${currentPath.join(\".\")}\". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the ${label} descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);\n\t\t\t}\n\t\t\tentries.push(...collectDescriptorEntries(value, isLeaf, descriptorKind, label, currentPath));\n\t\t}\n\t}\n\treturn entries;\n}\n/**\n* Throws when two or more entries in the same namespace share a key. A\n* duplicate key makes dispatch ambiguous — the caller's lookup dispatches by\n* this key, so one entry would silently shadow the other. Catch duplicates\n* before building any dispatch map.\n*\n* `label` (e.g. `'pslBlock'`, `'entityType'`) names which namespace the\n* duplicate was found in and is carried in the structured error metadata;\n* the key itself is always called `key` in both the message and the\n* metadata, since what it semantically represents (a discriminator for\n* `entityType`, the parser's dispatch keyword for `pslBlock`) is the\n* caller's concern, not this function's.\n*/\nfunction assertUniqueDiscriminators(entries, label) {\n\tconst seen = /* @__PURE__ */ new Map();\n\tfor (const { path, discriminator: key } of entries) {\n\t\tconst existing = seen.get(key);\n\t\tif (existing !== void 0) throw runtimeError(\"RUNTIME.DUPLICATE_AUTHORING_DISCRIMINATOR\", `Duplicate ${label} key \"${key}\" registered at both \"${existing}\" and \"${path}\". Each ${label} contribution must use a unique key.`, {\n\t\t\tlabel,\n\t\t\tkey,\n\t\t\texistingPath: existing,\n\t\t\tpath\n\t\t});\n\t\tseen.set(key, path);\n\t}\n}\nfunction collectPslBlockDescriptorEntries(namespace, path = []) {\n\tconst entries = [];\n\tfor (const [key, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, key];\n\t\tif (isAuthoringPslBlockDescriptor(value)) {\n\t\t\tif (!isWellFormedDescriptor(value, \"pslBlock\")) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Malformed authoring pslBlock contribution at \"${currentPath.join(\".\")}\". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the pslBlock descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);\n\t\t\tentries.push({\n\t\t\t\tpath: currentPath.join(\".\"),\n\t\t\t\tdiscriminator: value.discriminator,\n\t\t\t\tkeyword: value.keyword\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof value === \"object\" && value !== null && !Array.isArray(value)) {\n\t\t\tconst record = blindCast(value);\n\t\t\tconst hasKind = record[\"kind\"] === \"pslBlock\";\n\t\t\tconst hasKeyword = typeof record[\"keyword\"] === \"string\";\n\t\t\tconst hasDiscriminator = typeof record[\"discriminator\"] === \"string\";\n\t\t\tif (hasKind || hasKeyword && hasDiscriminator) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Malformed authoring pslBlock contribution at \"${currentPath.join(\".\")}\". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the pslBlock descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);\n\t\t\tentries.push(...collectPslBlockDescriptorEntries(value, currentPath));\n\t\t}\n\t}\n\treturn entries;\n}\n/**\n* Every `pslBlockDescriptors` entry requires a matching `entityTypes` factory\n* with the same discriminator. An `entityTypes` factory may stand alone (e.g.\n* `enum`, reachable from the TypeScript builder without any PSL block).\n*\n* Uniqueness for pslBlock entries is keyed on **keyword**, not discriminator:\n* several keywords (e.g. `policy_select`/`policy_insert`) may legitimately\n* share one discriminator, routing to the same `entityTypes` factory and the\n* same `entries[discriminator]` slot — that N:1 shape is exactly what lets\n* one entity kind be authored through several PSL keywords. What must stay\n* unique is the keyword itself, since that's what the parser dispatches on.\n*/\nfunction assertPslBlocksHaveFactories(entityTypeNamespace, pslBlockNamespace) {\n\tconst blockEntries = collectPslBlockDescriptorEntries(pslBlockNamespace);\n\tconst entityEntries = collectDescriptorEntries(entityTypeNamespace, isAuthoringEntityTypeDescriptor, \"entity\", \"entityType\");\n\tassertUniqueDiscriminators(blockEntries.map((entry) => ({\n\t\tpath: entry.path,\n\t\tdiscriminator: entry.keyword\n\t})), \"pslBlock\");\n\tassertUniqueDiscriminators(entityEntries, \"entityType\");\n\tconst entityDiscriminators = new Set(entityEntries.map((entry) => entry.discriminator));\n\tfor (const block of blockEntries) if (!entityDiscriminators.has(block.discriminator)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Incomplete extension contribution: pslBlock helper \"${block.path}\" registers discriminator \"${block.discriminator}\" but no entityType contribution shares that discriminator. An extension-contributed PSL block requires a matching entityType factory so the parsed AST node can lower to an IR class instance; add an entityType helper with discriminator \"${block.discriminator}\".`);\n}\nfunction collectModelAttributeEntries(namespace, path = []) {\n\tconst entries = [];\n\tfor (const [key, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, key];\n\t\tif (isAuthoringModelAttributeDescriptor(value)) {\n\t\t\tif (!isWellFormedDescriptor(value, \"modelAttribute\")) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Malformed authoring modelAttribute contribution at \"${currentPath.join(\".\")}\". The value carries descriptor keys (kind/attribute) but does not satisfy the modelAttribute descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);\n\t\t\tentries.push({\n\t\t\t\tpath: currentPath.join(\".\"),\n\t\t\t\tdiscriminator: value.attribute\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof value === \"object\" && value !== null && !Array.isArray(value)) {\n\t\t\tconst record = blindCast(value);\n\t\t\tif (typeof record[\"attribute\"] === \"string\" && \"spec\" in record) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Malformed authoring modelAttribute contribution at \"${currentPath.join(\".\")}\". The value carries descriptor keys (kind/attribute) but does not satisfy the modelAttribute descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);\n\t\t\tentries.push(...collectModelAttributeEntries(value, currentPath));\n\t\t}\n\t}\n\treturn entries;\n}\n/**\n* Throws when two modelAttribute contributions — at any paths, even\n* different ones — claim the same bare `@@` attribute name. The family\n* interpreter dispatches by attribute name, not by registration path, so\n* two descriptors claiming the same name would have one silently shadow\n* the other.\n*/\nfunction assertUniqueModelAttributeNames(entries) {\n\tconst seen = /* @__PURE__ */ new Map();\n\tfor (const { path, discriminator: attribute } of entries) {\n\t\tconst existing = seen.get(attribute);\n\t\tif (existing !== void 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Duplicate modelAttribute \"${attribute}\" registered at both \"${existing}\" and \"${path}\". Each modelAttribute contribution must claim a unique attribute name.`);\n\t\tseen.set(attribute, path);\n\t}\n}\nfunction assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace = {}, pslBlockNamespace = {}, modelAttributeNamespace = {}) {\n\tconst typePaths = new Set(collectDescriptorPaths(typeNamespace, isAuthoringTypeConstructorDescriptor));\n\tconst fieldPaths = new Set(collectDescriptorPaths(fieldNamespace, isAuthoringFieldPresetDescriptor));\n\tconst entityPaths = new Set(collectDescriptorPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor));\n\tconst ambiguityHint = \"Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.\";\n\tfor (const fieldPath of fieldPaths) if (typePaths.has(fieldPath)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Ambiguous authoring registry path \"${fieldPath}\". The same path is registered as both a type constructor and a field preset; PSL resolution would be ambiguous. ${ambiguityHint}`);\n\tfor (const entityPath of entityPaths) if (typePaths.has(entityPath) || fieldPaths.has(entityPath)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Ambiguous authoring registry path \"${entityPath}\". The same path is registered as an entity contribution AND as a type constructor or field preset; PSL resolution would be ambiguous. ${ambiguityHint}`);\n\tassertPslBlocksHaveFactories(entityTypeNamespace, pslBlockNamespace);\n\tassertUniqueModelAttributeNames(collectModelAttributeEntries(modelAttributeNamespace));\n\tassertSelectTemplatesMatchOptionArgs(typeNamespace, fieldNamespace, entityTypeNamespace);\n}\nfunction collectDescriptorNodes(namespace, isLeaf, path = []) {\n\tconst nodes = [];\n\tfor (const [key, value] of Object.entries(namespace)) {\n\t\tconst currentPath = [...path, key];\n\t\tif (isLeaf(value)) {\n\t\t\tnodes.push([currentPath.join(\".\"), value]);\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof value === \"object\" && value !== null && !Array.isArray(value)) nodes.push(...collectDescriptorNodes(value, isLeaf, currentPath));\n\t}\n\treturn nodes;\n}\nfunction collectSelectRefs(value, found) {\n\tif (typeof value !== \"object\" || value === null) return;\n\tif (isAuthoringSelectRef(value)) {\n\t\tfound.push(value);\n\t\tfor (const caseTemplate of Object.values(value.cases)) collectSelectRefs(caseTemplate, found);\n\t\treturn;\n\t}\n\tif (isAuthoringArgRef(value)) {\n\t\tcollectSelectRefs(value.default, found);\n\t\treturn;\n\t}\n\tif (Array.isArray(value)) {\n\t\tfor (const entry of value) collectSelectRefs(entry, found);\n\t\treturn;\n\t}\n\tfor (const entry of Object.values(value)) collectSelectRefs(entry, found);\n}\nfunction validateSelectRefsAgainstArgs(label, helperPath, args, templateRoot) {\n\tconst selects = [];\n\tcollectSelectRefs(templateRoot, selects);\n\tfor (const select of selects) {\n\t\tconst position = `#${select.index + 1}`;\n\t\tlet descriptor = args?.[select.index];\n\t\tif (descriptor === void 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Authoring ${label} helper \"${helperPath}\" select template references argument ${position}, but the helper declares no argument at that position.`);\n\t\tfor (const segment of select.path ?? []) {\n\t\t\tdescriptor = descriptor.kind === \"object\" ? descriptor.properties[segment] : void 0;\n\t\t\tif (descriptor === void 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Authoring ${label} helper \"${helperPath}\" select template references argument ${position} at path \"${(select.path ?? []).join(\".\")}\", which does not resolve to a declared argument property.`);\n\t\t}\n\t\tif (descriptor.kind !== \"option\") throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Authoring ${label} helper \"${helperPath}\" select template references argument ${position}, which is kind \"${descriptor.kind}\"; select requires an option argument.`);\n\t\tconst argumentLabel = descriptor.name !== void 0 ? `\"${descriptor.name}\"` : position;\n\t\tconst missing = descriptor.values.filter((value) => !Object.hasOwn(select.cases, value));\n\t\tif (missing.length > 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Authoring ${label} helper \"${helperPath}\" option argument ${argumentLabel} allows [${descriptor.values.join(\", \")}] but the select template has no case for: ${missing.join(\", \")}.`);\n\t\tconst values = descriptor.values;\n\t\tconst unreachable = Object.keys(select.cases).filter((key) => !values.includes(key));\n\t\tif (unreachable.length > 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Authoring ${label} helper \"${helperPath}\" select template has case(s) not allowed by option argument ${argumentLabel}: ${unreachable.join(\", \")}. Allowed values: [${values.join(\", \")}].`);\n\t}\n}\n/**\n* Every `select` template node must target an option argument whose `values`\n* exactly cover the node's `cases` — a legal token with no case and a case no\n* token can reach are both declaration bugs, caught here at pack-registration\n* time rather than at first resolution.\n*/\nfunction assertSelectTemplatesMatchOptionArgs(typeNamespace, fieldNamespace, entityTypeNamespace) {\n\tfor (const [helperPath, descriptor] of collectDescriptorNodes(fieldNamespace, isAuthoringFieldPresetDescriptor)) validateSelectRefsAgainstArgs(\"field\", helperPath, descriptor.args, descriptor.output);\n\tfor (const [helperPath, descriptor] of collectDescriptorNodes(typeNamespace, isAuthoringTypeConstructorDescriptor)) validateSelectRefsAgainstArgs(\"type\", helperPath, descriptor.args, descriptor.output);\n\tfor (const [helperPath, descriptor] of collectDescriptorNodes(entityTypeNamespace, isAuthoringEntityTypeDescriptor)) if (\"template\" in descriptor.output) validateSelectRefsAgainstArgs(\"entityType\", helperPath, descriptor.args, descriptor.output.template);\n}\nfunction resolveAuthoringTemplateValue(template, args) {\n\tif (template === void 0) return;\n\tif (isAuthoringArgRef(template)) {\n\t\tconst value = readTemplateArgumentValue(args, template.index, template.path);\n\t\tif (value === void 0 && template.default !== void 0) return resolveAuthoringTemplateValue(template.default, args);\n\t\treturn value;\n\t}\n\tif (isAuthoringSelectRef(template)) {\n\t\tconst value = readTemplateArgumentValue(args, template.index, template.path);\n\t\tif (value === void 0) return;\n\t\tif (typeof value !== \"string\" || !Object.hasOwn(template.cases, value)) throw new InternalError(`Authoring template select has no case for value \"${String(value)}\"`);\n\t\treturn resolveAuthoringTemplateValue(template.cases[value], args);\n\t}\n\tif (Array.isArray(template)) return template.map((value) => resolveAuthoringTemplateValue(value, args));\n\tif (typeof template === \"object\" && template !== null) {\n\t\tconst resolved = {};\n\t\tfor (const [key, value] of Object.entries(template)) {\n\t\t\tconst resolvedValue = resolveAuthoringTemplateValue(value, args);\n\t\t\tif (resolvedValue !== void 0) resolved[key] = resolvedValue;\n\t\t}\n\t\treturn resolved;\n\t}\n\treturn template;\n}\nfunction validateAuthoringArgument(descriptor, value, path) {\n\tif (value === void 0) {\n\t\tif (descriptor.optional) return;\n\t\tthrow runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} is missing`);\n\t}\n\tif (descriptor.kind === \"string\") {\n\t\tif (typeof value !== \"string\") throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be a string`);\n\t\treturn;\n\t}\n\tif (descriptor.kind === \"boolean\") {\n\t\tif (typeof value !== \"boolean\") throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be a boolean`);\n\t\treturn;\n\t}\n\tif (descriptor.kind === \"stringArray\") {\n\t\tif (!Array.isArray(value)) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be an array of strings`);\n\t\tfor (const entry of value) if (typeof entry !== \"string\") throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be an array of strings`);\n\t\treturn;\n\t}\n\tif (descriptor.kind === \"object\") {\n\t\tif (typeof value !== \"object\" || value === null || Array.isArray(value)) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be an object`);\n\t\tconst input = value;\n\t\tconst expectedKeys = new Set(Object.keys(descriptor.properties));\n\t\tfor (const key of Object.keys(input)) if (!expectedKeys.has(key)) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} contains unknown property \"${key}\"`);\n\t\tfor (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);\n\t\treturn;\n\t}\n\tif (descriptor.kind === \"option\") {\n\t\tif (typeof value !== \"string\" || !descriptor.values.includes(value)) {\n\t\t\tconst quoted = descriptor.values.map((option) => JSON.stringify(option));\n\t\t\tthrow runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} ${quoted.length === 0 ? \"takes no value\" : `must be ${quoted.length === 1 ? quoted.join(\"\") : `one of ${quoted.join(\", \")}`}`}; received ${describeReceivedArgument(value)}`);\n\t\t}\n\t\treturn;\n\t}\n\tif (typeof value !== \"number\" || Number.isNaN(value)) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be a number`);\n\tif (descriptor.integer && !Number.isInteger(value)) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be an integer`);\n\tif (descriptor.minimum !== void 0 && value < descriptor.minimum) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be >= ${descriptor.minimum}, received ${value}`);\n\tif (descriptor.maximum !== void 0 && value > descriptor.maximum) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${path} must be <= ${descriptor.maximum}, received ${value}`);\n}\nfunction validateAuthoringHelperArguments(helperPath, descriptors, args) {\n\tconst expected = descriptors ?? [];\n\tconst minimumArgs = expected.reduce((count, descriptor, index) => descriptor.optional ? count : index + 1, 0);\n\tif (args.length < minimumArgs || args.length > expected.length) throw runtimeError(\"CONTRACT.ARGUMENT_INVALID\", `${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`);\n\texpected.forEach((descriptor, index) => {\n\t\tvalidateAuthoringArgument(descriptor, args[index], argumentLabel(helperPath, descriptor, index));\n\t});\n}\nfunction argumentLabel(helperPath, descriptor, index) {\n\treturn descriptor.name === void 0 ? `Authoring helper argument at ${helperPath}[${index}]` : `Argument \"${descriptor.name}\" of ${helperPath}`;\n}\nfunction describeReceivedArgument(value) {\n\treturn typeof value === \"string\" ? JSON.stringify(value) : String(value);\n}\nfunction argumentIndexOf(template) {\n\tlet index;\n\tvisitTemplateArgRefs(template, (ref) => {\n\t\tindex ??= ref.index;\n\t});\n\treturn index;\n}\nfunction issueKey(issue) {\n\tconst [first] = issue.path ?? [];\n\tconst key = typeof first === \"object\" && first !== null ? first.key : first;\n\treturn typeof key === \"string\" ? key : void 0;\n}\n/**\n* Checks the type parameters a constructor or preset produced against its codec's parameter schema, which is where the bounds of a data type's parameters are written. A failure names the argument the failing parameter came from.\n*/\nfunction validateAuthoringTypeParams(helperPath, template, typeParams, paramsSchema) {\n\tif (template.typeParams === void 0 || paramsSchema === void 0) return;\n\tconst result = paramsSchema[\"~standard\"].validate(typeParams ?? {});\n\tif (result instanceof Promise) throw new InternalError(`The parameter schema of codec \"${template.codecId}\" is asynchronous; authoring requires a synchronous schema.`);\n\tconst [issue] = result.issues ?? [];\n\tif (issue === void 0) return;\n\tconst key = issueKey(issue);\n\tconst argumentIndex = key === void 0 ? void 0 : argumentIndexOf(template.typeParams[key]);\n\tthrow runtimeError(\"CONTRACT.ARGUMENT_INVALID\", argumentIndex === void 0 ? `The type parameters of ${helperPath} are invalid: ${issue.message}` : `Authoring helper argument at ${helperPath}[${argumentIndex}] is invalid: ${issue.message}`, {\n\t\thelperPath,\n\t\t...ifDefined(\"argumentIndex\", argumentIndex)\n\t});\n}\nfunction resolveAuthoringStorageTypeTemplate(template, args) {\n\tconst typeParams = template.typeParams === void 0 ? void 0 : resolveAuthoringTemplateValue(template.typeParams, args);\n\tif (typeParams !== void 0 && !isAuthoringTemplateRecord(typeParams)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Resolved authoring typeParams must be an object for codec \"${template.codecId}\", received ${String(typeParams)}`);\n\tconst normalizedTypeParams = typeParams !== void 0 && Object.keys(typeParams).length === 0 ? void 0 : typeParams;\n\treturn {\n\t\tcodecId: template.codecId,\n\t\t...ifDefined(\"typeParams\", normalizedTypeParams)\n\t};\n}\nfunction resolveAuthoringColumnDefaultTemplate(template, args) {\n\tif (template.kind === \"literal\") {\n\t\tconst value = resolveAuthoringTemplateValue(template.value, args);\n\t\tif (value === void 0) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", \"Resolved authoring literal default must not be undefined\");\n\t\tif (!isColumnDefaultLiteralInputValue(value)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Resolved authoring literal default must be a JSON-serializable value or Date, received ${String(value)}`);\n\t\treturn {\n\t\t\tkind: \"literal\",\n\t\t\tvalue\n\t\t};\n\t}\n\tconst expression = resolveAuthoringTemplateValue(template.expression, args);\n\tif (expression === void 0 || typeof expression === \"object\" && expression !== null) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`);\n\treturn {\n\t\tkind: \"function\",\n\t\texpression: String(expression)\n\t};\n}\nfunction resolveExecutionMutationDefaultPhase(phase, template, args) {\n\tconst value = resolveAuthoringTemplateValue(template, args);\n\tif (value === void 0) return;\n\tif (!isExecutionMutationDefaultValue(value)) throw runtimeError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Authoring preset executionDefaults.${phase} did not resolve to a valid generator descriptor (kind: 'generator', id: string).`);\n\treturn value;\n}\nfunction resolveAuthoringExecutionDefaultsTemplate(template, args) {\n\tconst phases = {\n\t\t...ifDefined(\"onCreate\", template.onCreate !== void 0 ? resolveExecutionMutationDefaultPhase(\"onCreate\", template.onCreate, args) : void 0),\n\t\t...ifDefined(\"onUpdate\", template.onUpdate !== void 0 ? resolveExecutionMutationDefaultPhase(\"onUpdate\", template.onUpdate, args) : void 0)\n\t};\n\treturn Object.keys(phases).length === 0 ? void 0 : phases;\n}\nfunction instantiateAuthoringTypeConstructor(descriptor, args) {\n\treturn resolveAuthoringStorageTypeTemplate(descriptor.output, args);\n}\nfunction instantiateAuthoringEntityType(helperPath, descriptor, args, ctx) {\n\tif (\"factory\" in descriptor.output) {\n\t\tconst input = args[0];\n\t\treturn blindCast(descriptor.output.factory)(input, ctx);\n\t}\n\tvalidateAuthoringHelperArguments(helperPath, descriptor.args, args);\n\treturn blindCast(resolveAuthoringTemplateValue(descriptor.output.template, args));\n}\nfunction instantiateAuthoringFieldPreset(descriptor, args) {\n\treturn {\n\t\tdescriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),\n\t\tnullable: descriptor.output.nullable ?? false,\n\t\t...ifDefined(\"default\", descriptor.output.default !== void 0 ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args) : void 0),\n\t\t...ifDefined(\"executionDefaults\", descriptor.output.executionDefaults !== void 0 ? resolveAuthoringExecutionDefaultsTemplate(descriptor.output.executionDefaults, args) : void 0),\n\t\tid: descriptor.output.id ?? false,\n\t\tunique: descriptor.output.unique ?? false\n\t};\n}\n//#endregion\n//#region src/shared/tagged-literal.ts\nconst TAGGED_LITERAL_MAX_BYTES = 65536;\n/** The message a tagged literal's canonicalization failure is reported with, in PSL and in TypeScript. */\nfunction describeTaggedLiteralFailure(reason) {\n\tswitch (reason) {\n\t\tcase \"nul\": return \"Tagged literals must not contain NUL characters.\";\n\t\tcase \"too-large\": return `Tagged literal exceeds ${TAGGED_LITERAL_MAX_BYTES} bytes.`;\n\t}\n}\nconst PSL_BACKTICK_ESCAPES = /* @__PURE__ */ new Set([\"`\", \"\\\\\"]);\nconst TEMPLATE_TAG_ESCAPES = /* @__PURE__ */ new Set([\n\t\"`\",\n\t\"\\\\\",\n\t\"$\"\n]);\n/** The escapes a PSL backtick string resolves: `` \\` `` and `\\\\`. PSL has no interpolation, so `${` is ordinary text. */\nfunction resolvePslBacktickEscapes(raw) {\n\treturn resolveEscapes(raw, PSL_BACKTICK_ESCAPES);\n}\n/** The escapes a TypeScript template tag resolves: the PSL two plus `\\$`, the only way to write `${` in a template literal. */\nfunction resolveTemplateTagEscapes(raw) {\n\treturn resolveEscapes(raw, TEMPLATE_TAG_ESCAPES);\n}\n/** Every other backslash sequence is kept as written, both characters, so a SQL body may contain `E'\\n'` unchanged. */\nfunction resolveEscapes(raw, escapes) {\n\tlet out = \"\";\n\tlet i = 0;\n\twhile (i < raw.length) {\n\t\tconst ch = raw.charAt(i);\n\t\tconst next = raw.charAt(i + 1);\n\t\tif (ch === \"\\\\\" && escapes.has(next)) {\n\t\t\tout += next;\n\t\t\ti += 2;\n\t\t\tcontinue;\n\t\t}\n\t\tout += ch;\n\t\ti++;\n\t}\n\treturn out;\n}\nconst BLANK_LINE = /^[ \\t]*$/;\nconst LEADING_INDENT = /^[ \\t]*/;\nconst LINE_BREAK = /\\r\\n|\\r|\\n/g;\n/**\n* Turns the escape-resolved text of a tagged literal into its canonical body:\n* newlines become `\\n`, a blank first and last line are dropped, common leading\n* whitespace is removed, internal blank lines become empty, and no trailing\n* newline is added. Fails on a NUL character or when the result is larger than\n* 65536 UTF-8 bytes.\n*/\nfunction canonicalizeTaggedLiteralBody(resolved) {\n\tconst nul = resolved.indexOf(\"\\0\");\n\tif (nul !== -1) return {\n\t\tok: false,\n\t\treason: \"nul\",\n\t\toffset: nul\n\t};\n\tconst lines = splitLines(resolved);\n\tif (lines.length > 0 && BLANK_LINE.test(lines[0]?.text ?? \"\")) lines.shift();\n\tif (lines.length > 0 && BLANK_LINE.test(lines.at(-1)?.text ?? \"\")) lines.pop();\n\tconst indent = commonIndent(lines);\n\tconst bodyLines = lines.map((line) => BLANK_LINE.test(line.text) ? {\n\t\ttext: \"\",\n\t\tstart: line.start\n\t} : {\n\t\ttext: line.text.slice(indent),\n\t\tstart: line.start + indent\n\t});\n\tconst excess = offsetWhereBytesExceed(bodyLines, TAGGED_LITERAL_MAX_BYTES);\n\tif (excess !== void 0) return {\n\t\tok: false,\n\t\treason: \"too-large\",\n\t\toffset: excess\n\t};\n\treturn {\n\t\tok: true,\n\t\tbody: bodyLines.map((line) => line.text).join(\"\\n\")\n\t};\n}\nfunction splitLines(text) {\n\tconst lines = [];\n\tlet start = 0;\n\tfor (const match of text.matchAll(LINE_BREAK)) {\n\t\tlines.push({\n\t\t\ttext: text.slice(start, match.index),\n\t\t\tstart\n\t\t});\n\t\tstart = match.index + match[0].length;\n\t}\n\tlines.push({\n\t\ttext: text.slice(start),\n\t\tstart\n\t});\n\treturn lines;\n}\nfunction commonIndent(lines) {\n\tlet indent = Number.POSITIVE_INFINITY;\n\tfor (const line of lines) {\n\t\tif (BLANK_LINE.test(line.text)) continue;\n\t\tindent = Math.min(indent, LEADING_INDENT.exec(line.text)?.[0].length ?? 0);\n\t}\n\treturn Number.isFinite(indent) ? indent : 0;\n}\n/** The resolved-text offset of the first character that pushes the body past `limit` bytes. */\nfunction offsetWhereBytesExceed(lines, limit) {\n\tlet bytes = 0;\n\tfor (const [index, line] of lines.entries()) {\n\t\tif (index > 0) {\n\t\t\tbytes += 1;\n\t\t\tif (bytes > limit) return line.start;\n\t\t}\n\t\tlet offsetInLine = 0;\n\t\tfor (const char of line.text) {\n\t\t\tbytes += utf8Length(char.codePointAt(0) ?? 0);\n\t\t\tif (bytes > limit) return line.start + offsetInLine;\n\t\t\toffsetInLine += char.length;\n\t\t}\n\t}\n}\nfunction utf8Length(codePoint) {\n\tif (codePoint < 128) return 1;\n\tif (codePoint < 2048) return 2;\n\tif (codePoint < 65536) return 3;\n\treturn 4;\n}\nfunction escapeQuotedText(text) {\n\treturn text.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\");\n}\n/**\n* The PSL text of a tagged literal whose canonical text is `text`: the backtick form, or the double-quote form when the\n* text holds a backtick, which reads better than escaping each backtick. A multi-line text starts on the line after\n* the opening backtick, so indentation a printer adds to an enclosing block is common to every line and the\n* canonicalization removes it. ADR 129.\n*/\nfunction printTaggedLiteral(tag, text) {\n\tif (text.includes(\"`\")) return `${tag}\"${escapeQuotedText(text)}\"`;\n\tconst fenced = text.replace(/\\\\/g, \"\\\\\\\\\");\n\treturn text.includes(\"\\n\") ? `${tag}\\`\\n${fenced}\\n\\`` : `${tag}\\`${fenced}\\``;\n}\n//#endregion\n//#region src/shared/temporal-presets.ts\n/**\n* Canonical id for the wall-clock-now mutation default generator. It flows to the control-plane descriptor and the temporal field presets below, to each family's runtime generator, and to the authoring surfaces (PSL `temporal.updatedAt()`, TS `field.temporal.updatedAt()`) through the descriptor.\n*/\nconst TIMESTAMP_NOW_GENERATOR_ID = \"timestampNow\";\n/**\n* Builds the control-plane descriptor for the wall-clock-now mutation default generator. Its `id` and `buildPhases` are target-agnostic, so PSL `temporal.updatedAt()` and TS `field.temporal.updatedAt()` lower to byte-identical contracts.\n*\n* `applicableCodecIds` is omitted: `timestampNow` is reachable only through a preset, which co-registers the codec itself, so a compatibility list would be tautological.\n*/\nfunction timestampNowControlDescriptor() {\n\treturn {\n\t\tid: TIMESTAMP_NOW_GENERATOR_ID,\n\t\tbuildPhases: () => ({\n\t\t\tonCreate: {\n\t\t\t\tkind: \"generator\",\n\t\t\t\tid: TIMESTAMP_NOW_GENERATOR_ID\n\t\t\t},\n\t\t\tonUpdate: {\n\t\t\t\tkind: \"generator\",\n\t\t\t\tid: TIMESTAMP_NOW_GENERATOR_ID\n\t\t\t}\n\t\t})\n\t};\n}\n/**\n* Builds the `temporal.{createdAt,updatedAt}` field-preset pair. `createdAt` lowers to an execution generator on `onCreate`; `updatedAt` lowers to the same generator on both `onCreate` and `onUpdate`. The target supplies the storage template of its timestamp codec, which the presets carry through unchanged; everything else is shared, so PSL and TS authoring lower to byte-identical contracts across targets.\n*/\n/* @__NO_SIDE_EFFECTS__ */\nfunction temporalAuthoringPresets(input) {\n\tconst { generatorId: requestedGeneratorId, ...storage } = input;\n\tconst generatorId = requestedGeneratorId ?? \"timestampNow\";\n\treturn {\n\t\tcreatedAt: {\n\t\t\tkind: \"fieldPreset\",\n\t\t\toutput: {\n\t\t\t\t...storage,\n\t\t\t\texecutionDefaults: { onCreate: {\n\t\t\t\t\tkind: \"generator\",\n\t\t\t\t\tid: generatorId\n\t\t\t\t} }\n\t\t\t}\n\t\t},\n\t\tupdatedAt: {\n\t\t\tkind: \"fieldPreset\",\n\t\t\toutput: {\n\t\t\t\t...storage,\n\t\t\t\texecutionDefaults: {\n\t\t\t\t\tonCreate: {\n\t\t\t\t\t\tkind: \"generator\",\n\t\t\t\t\t\tid: generatorId\n\t\t\t\t\t},\n\t\t\t\t\tonUpdate: {\n\t\t\t\t\t\tkind: \"generator\",\n\t\t\t\t\t\tid: generatorId\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\nconst TEMPORAL_ON_CREATE_ARG = {\n\tname: \"onCreate\",\n\tkind: \"option\",\n\tvalues: [\"now\"],\n\toptional: true\n};\nconst TEMPORAL_ON_UPDATE_ARG = {\n\tname: \"onUpdate\",\n\tkind: \"option\",\n\tvalues: [\"now\"],\n\toptional: true\n};\n/**\n* Selects a generator descriptor for the preset's `now` token. The token is preset vocabulary; the generator id never appears in a user's spelling (ADR 169 — these generators are preset-only).\n*/\nfunction temporalPhaseTemplate(index, generatorId) {\n\treturn {\n\t\tkind: \"select\",\n\t\tindex,\n\t\tcases: { now: {\n\t\t\tkind: \"generator\",\n\t\t\tid: generatorId\n\t\t} }\n\t};\n}\n/**\n* Builds a `temporal.<codec>` field preset for a codec with no type parameters, carrying the codec's storage template through unchanged. Both phase arguments are optional, and omitting one omits that phase.\n*/\n/* @__NO_SIDE_EFFECTS__ */\nfunction temporalCodecPreset(storage) {\n\treturn {\n\t\tkind: \"fieldPreset\",\n\t\targs: [TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG],\n\t\toutput: {\n\t\t\t...storage,\n\t\t\texecutionDefaults: {\n\t\t\t\tonCreate: temporalPhaseTemplate(0, TIMESTAMP_NOW_GENERATOR_ID),\n\t\t\t\tonUpdate: temporalPhaseTemplate(1, TIMESTAMP_NOW_GENERATOR_ID)\n\t\t\t}\n\t\t}\n\t};\n}\n//#endregion\nexport { isAuthoringTypeConstructorDescriptor as A, instantiateAuthoringFieldPreset as C, isAuthoringFieldPresetDescriptor as D, isAuthoringEntityTypeDescriptor as E, resolveEnumCodecId as F, tagEntryKey as I, validateAuthoringHelperArguments as L, mergeAuthoringAttributeSpecs as M, mergeAuthoringNamespaces as N, isAuthoringModelAttributeDescriptor as O, resolveAuthoringTemplateValue as P, validateAuthoringTypeParams as R, instantiateAuthoringEntityType as S, isAuthoringArgRef as T, classifyEnumMemberType as _, temporalCodecPreset as a, flushAuthoringWarnings as b, TAGGED_LITERAL_MAX_BYTES as c, printTaggedLiteral as d, resolvePslBacktickEscapes as f, authoringEntryType as g, assertResolvableTypeConstructorTemplates as h, temporalAuthoringPresets as i, isTagEntryKey as j, isAuthoringPslBlockDescriptor as k, canonicalizeTaggedLiteralBody as l, assertNoCrossRegistryCollisions as m, TEMPORAL_ON_UPDATE_ARG as n, temporalPhaseTemplate as o, resolveTemplateTagEscapes as p, TIMESTAMP_NOW_GENERATOR_ID as r, timestampNowControlDescriptor as s, TEMPORAL_ON_CREATE_ARG as t, describeTaggedLiteralFailure as u, collectContributedDescriptorPaths as v, instantiateAuthoringTypeConstructor as w, getAuthoringTypeConstructor as x, collectScalarTypeConstructors as y };\n\n//# sourceMappingURL=temporal-presets-DIo9uYtS.mjs.map"],"mappings":"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"}

package/dist/{types-import-spec-BLFYPur6-QN7ntocb.d.mts → types-import-spec-U2GFdg-x-CRt_XdWj.d.mts}

@@ -1,6 +1,6 @@
 import { V as JsonValue } from "./domain-envelope-C2vVIWGK-C5x7cBpU.mjs";
-import { g as CodecTrait, m as CodecRef } from "./codec-types-CZ8xRBJy-BMjCsUt1.mjs";
-//#region ../../../1-framework/1-core/framework-components/dist/types-import-spec-BLFYPur6.d.mts
+import { g as CodecTrait, m as CodecRef } from "./codec-types-8NKqm4AQ-DyNSay3e.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/types-import-spec-U2GFdg-x.d.mts
 //#region src/shared/aggregate-descriptor.d.ts
 /**
  * How a descriptor matches the value an aggregate consumes.
@@ -110,4 +110,4 @@ interface TypesImportSpec {
 }
 //#endregion
 export { AnyInputAggregateDescriptor as a, SelfAggregateOutput as c, aggregateDescriptorKey as d, isAggregateDescriptor as f, AggregateResultNullability as i, TypesImportSpec as l, isNoInputAggregateDescriptor as m, AggregateInputMatch as n, NamedAggregateOutput as o, isAnyInputAggregateDescriptor as p, AggregateOutputCodec as r, NoInputAggregateDescriptor as s, AggregateDescriptor as t, ValueInputAggregateDescriptor as u };
-//# sourceMappingURL=types-import-spec-BLFYPur6-QN7ntocb.d.mts.map
+//# sourceMappingURL=types-import-spec-U2GFdg-x-CRt_XdWj.d.mts.map

package/dist/{types-import-spec-BLFYPur6-QN7ntocb.d.mts.map → types-import-spec-U2GFdg-x-CRt_XdWj.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-import-spec-BLFYPur6-QN7ntocb.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/types-import-spec-BLFYPur6.d.mts"],"mappings":";;;;;;;;;;;;;;KAaK;WACM;;WAEA;WACA;;WAEA;WACA,OAAO;;WAEP;;;;;;;UAOD;WACC;WACA;WACA,cAAc,OAAO,yBAAyB;;;UAG/C;WACC;;;KAGN,uBAAuB,sBAAsB;;;;;;KAM7C;WACM;;WAEA;WACA,iBAAiB;;KAEvB,0BAA0B;;WAEpB;;;KAGN,6BAA6B;WACvB;aACE;;WAEF,QAAQ;;;KAGd,8BAA8B;WACxB;aACE;;WAEF,QAAQ;;;KAGd,gCAAgC;WAC1B;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"}
+{"version":3,"file":"types-import-spec-U2GFdg-x-CRt_XdWj.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/types-import-spec-U2GFdg-x.d.mts"],"mappings":";;;;;;;;;;;;;;KAaK;WACM;;WAEA;WACA;;WAEA;WACA,OAAO;;WAEP;;;;;;;UAOD;WACC;WACA;WACA,cAAc,OAAO,yBAAyB;;;UAG/C;WACC;;;KAGN,uBAAuB,sBAAsB;;;;;;KAM7C;WACM;;WAEA;WACA,iBAAiB;;KAEvB,0BAA0B;;WAEpB;;;KAGN,6BAA6B;WACvB;aACE;;WAEF,QAAQ;;;KAGd,8BAA8B;WACxB;aACE;;WAEF,QAAQ;;;KAGd,gCAAgC;WAC1B;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": "8.0.0-rc.14-dev.35",
+  "version": "8.0.0-rc.14-dev.37",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -16,20 +16,20 @@
     "uniku": "^0.5.0"
   },
   "devDependencies": {
-    "@internal/config": "8.0.0-rc.14-dev.35",
-    "@internal/contract": "8.0.0-rc.14-dev.35",
-    "@internal/contract-authoring": "8.0.0-rc.14-dev.35",
-    "@internal/errors": "8.0.0-rc.14-dev.35",
-    "@internal/framework-components": "8.0.0-rc.14-dev.35",
-    "@internal/ids": "8.0.0-rc.14-dev.35",
-    "@internal/operations": "8.0.0-rc.14-dev.35",
-    "@internal/psl-parser": "8.0.0-rc.14-dev.35",
-    "@internal/psl-printer": "8.0.0-rc.14-dev.35",
-    "@internal/ts-render": "8.0.0-rc.14-dev.35",
-    "@repo/tsconfig": "8.0.0-rc.14-dev.35",
-    "@internal/publish-surface": "8.0.0-rc.14-dev.35",
-    "@repo/tsdown": "8.0.0-rc.14-dev.35",
-    "@internal/utils": "8.0.0-rc.14-dev.35",
+    "@internal/config": "8.0.0-rc.14-dev.37",
+    "@internal/contract": "8.0.0-rc.14-dev.37",
+    "@internal/contract-authoring": "8.0.0-rc.14-dev.37",
+    "@internal/errors": "8.0.0-rc.14-dev.37",
+    "@internal/framework-components": "8.0.0-rc.14-dev.37",
+    "@internal/ids": "8.0.0-rc.14-dev.37",
+    "@internal/operations": "8.0.0-rc.14-dev.37",
+    "@internal/psl-parser": "8.0.0-rc.14-dev.37",
+    "@internal/psl-printer": "8.0.0-rc.14-dev.37",
+    "@internal/ts-render": "8.0.0-rc.14-dev.37",
+    "@repo/tsconfig": "8.0.0-rc.14-dev.37",
+    "@internal/publish-surface": "8.0.0-rc.14-dev.37",
+    "@repo/tsdown": "8.0.0-rc.14-dev.37",
+    "@internal/utils": "8.0.0-rc.14-dev.37",
     "tsdown": "0.22.14",
     "typescript": "5.9.3",
     "vitest": "5.0.0-rc.2"

package/dist/authoring-Cp71GImA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring-Cp71GImA.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/authoring.mjs"],"sourcesContent":["import { t as canonicalizeJson } from \"./canonicalize-json-ZPawceQR.mjs\";\nimport { C as instantiateAuthoringTypeConstructor, D as isAuthoringModelAttributeDescriptor, E as isAuthoringFieldPresetDescriptor, F as validateAuthoringTypeParams, M as resolveAuthoringTemplateValue, N as resolveEnumCodecId, O as isAuthoringPslBlockDescriptor, P as validateAuthoringHelperArguments, S as instantiateAuthoringFieldPreset, T as isAuthoringEntityTypeDescriptor, a as temporalCodecPreset, b as getAuthoringTypeConstructor, d as printTaggedLiteral, g as classifyEnumMemberType, h as assertResolvableTypeConstructorTemplates, i as temporalAuthoringPresets, j as mergeAuthoringNamespaces, k as isAuthoringTypeConstructorDescriptor, m as assertNoCrossRegistryCollisions, n as TEMPORAL_ON_UPDATE_ARG, o as temporalPhaseTemplate, r as TIMESTAMP_NOW_GENERATOR_ID, t as TEMPORAL_ON_CREATE_ARG, v as collectScalarTypeConstructors, w as isAuthoringArgRef, x as instantiateAuthoringEntityType, y as flushAuthoringWarnings } from \"./temporal-presets-UoKnoAlu.mjs\";\nimport { isInternalError } from \"@internal/utils/internal-error\";\nimport { canonicalStringify } from \"@internal/utils/canonical-stringify\";\n//#region src/shared/authoring-type-constructor-call.ts\nfunction* typeConstructors(namespace, path = []) {\n\tfor (const [name, value] of Object.entries(namespace)) if (isAuthoringTypeConstructorDescriptor(value)) yield {\n\t\tpath: [...path, name],\n\t\tdescriptor: value\n\t};\n\telse yield* typeConstructors(value, [...path, name]);\n}\nfunction produces(produced, wanted) {\n\tconst wantedFields = {\n\t\t...wanted,\n\t\ttypeParams: wanted.typeParams ?? {}\n\t};\n\treturn Object.entries({\n\t\t...produced,\n\t\ttypeParams: produced.typeParams ?? {}\n\t}).every(([key, value]) => canonicalizeJson(value) === canonicalizeJson(wantedFields[key]));\n}\n/**\n* The arguments that make `descriptor` produce exactly `output`, when each of its type parameters\n* comes straight from one argument; `undefined` when it cannot produce `output`, including when\n* `output` has no value for an argument the constructor requires.\n*/\nfunction argumentsFor(descriptor, output) {\n\tif (descriptor.entityRefArg !== void 0 || descriptor.output.codecId !== output.codecId) return;\n\tconst args = [];\n\tfor (const [key, template] of Object.entries(descriptor.output.typeParams ?? {})) {\n\t\tconst value = output.typeParams?.[key];\n\t\tif (value !== void 0 && isAuthoringArgRef(template) && template.path === void 0) args[template.index] = value;\n\t}\n\tconst requiredArgs = (descriptor.args ?? []).filter((arg) => arg.optional !== true).length;\n\tif (args.length < requiredArgs || Array.from(args).includes(void 0)) return void 0;\n\ttry {\n\t\treturn produces(instantiateAuthoringTypeConstructor(descriptor, args), output) ? args : void 0;\n\t} catch {\n\t\treturn;\n\t}\n}\n/**\n* The first call, in namespace order, to a type constructor in `namespace` that produces exactly\n* `output`. The inverse of {@link instantiateAuthoringTypeConstructor} for constructors whose type\n* parameters each come straight from one argument. A constructor whose argument names another\n* entity is never chosen. `undefined` when no call produces `output`.\n*/\nfunction findAuthoringTypeConstructorCall(namespace, output) {\n\tfor (const { path, descriptor } of typeConstructors(namespace)) {\n\t\tconst args = argumentsFor(descriptor, output);\n\t\tif (args !== void 0) return {\n\t\t\tpath,\n\t\t\targs\n\t\t};\n\t}\n}\n//#endregion\n//#region src/shared/enum-block-members.ts\n/**\n* Reads the members of an `enum` block through its codec. A bare member is read from its own name.\n* Pushes a diagnostic and returns `undefined` when the codec refuses a member, when two members\n* store the same value, or when the block has no members. Shared by every family's enum factory.\n*/\nfunction readEnumBlockMembers(block, codecId, codec, ctx) {\n\tconst sourceId = ctx.sourceId ?? \"unknown\";\n\tconst diagnostics = ctx.diagnostics;\n\tconst memberByStoredValue = /* @__PURE__ */ new Map();\n\tconst members = [];\n\tlet memberError = false;\n\tfor (const [memberName, memberValue] of Object.entries(block.values)) {\n\t\tconst span = block.parameterSpans[memberName] ?? block.span;\n\t\tconst written = memberValue === void 0 ? memberName : memberValue;\n\t\tlet read;\n\t\ttry {\n\t\t\tread = codec.decodeJson(written);\n\t\t} catch (err) {\n\t\t\tif (isInternalError(err)) throw err;\n\t\t\tdiagnostics?.push(memberValue === void 0 ? {\n\t\t\t\tcode: \"PSL_ENUM_BARE_MEMBER_NON_STRING_CODEC\",\n\t\t\t\tmessage: `enum \"${block.name}\" member \"${memberName}\" has no value and codec \"${codecId}\" does not accept a bare name as input`,\n\t\t\t\tsourceId,\n\t\t\t\tspan\n\t\t\t} : {\n\t\t\t\tcode: \"PSL_EXTENSION_INVALID_VALUE\",\n\t\t\t\tmessage: `enum \"${block.name}\" member \"${memberName}\" was rejected by codec \"${codecId}\": ${err instanceof Error ? err.message : String(err)}`,\n\t\t\t\tsourceId,\n\t\t\t\tspan\n\t\t\t});\n\t\t\tmemberError = true;\n\t\t\tcontinue;\n\t\t}\n\t\tconst stored = codec.encodeJson(read);\n\t\tconst storedKey = canonicalStringify(stored);\n\t\tconst earlier = memberByStoredValue.get(storedKey);\n\t\tif (earlier !== void 0) {\n\t\t\tdiagnostics?.push({\n\t\t\t\tcode: \"PSL_ENUM_DUPLICATE_MEMBER_VALUE\",\n\t\t\t\tmessage: `enum \"${block.name}\": members \"${earlier}\" and \"${memberName}\" both store ${JSON.stringify(stored)}`,\n\t\t\t\tsourceId,\n\t\t\t\tspan\n\t\t\t});\n\t\t\tmemberError = true;\n\t\t\tcontinue;\n\t\t}\n\t\tmemberByStoredValue.set(storedKey, memberName);\n\t\tmembers.push({\n\t\t\tname: memberName,\n\t\t\tvalue: read\n\t\t});\n\t}\n\tif (memberError) return void 0;\n\tif (members.length === 0) {\n\t\tdiagnostics?.push({\n\t\t\tcode: \"PSL_ENUM_MISSING_TYPE\",\n\t\t\tmessage: `enum \"${block.name}\" must have at least one member`,\n\t\t\tsourceId,\n\t\t\tspan: block.span\n\t\t});\n\t\treturn;\n\t}\n\treturn members;\n}\n//#endregion\n//#region src/shared/field-preset-resolution.ts\nfunction presetSpellingsUnder(members, prefix) {\n\treturn Object.entries(members).flatMap(([name, member]) => isAuthoringFieldPresetDescriptor(member) ? [`${prefix}.${name}(${(member.args ?? []).map((arg, index) => arg.name ?? `argument${index + 1}`).join(\", \")})`] : presetSpellingsUnder(member, `${prefix}.${name}`));\n}\n/**\n* How each field preset registered under `namespace`, at any depth, is written, with the names of its arguments: `temporal.timestamp(onCreate, onUpdate)`.\n*/\nfunction fieldPresetSpellings(contributions, namespace) {\n\tconst members = contributions?.field?.[namespace];\n\tif (members === void 0 || isAuthoringFieldPresetDescriptor(members)) return [];\n\treturn presetSpellingsUnder(members, namespace);\n}\n/**\n* Walks `authoringContributions.field` segment by segment and returns the field-preset descriptor at the path, or `undefined` when none is registered there.\n*/\nfunction getAuthoringFieldPreset(contributions, path) {\n\tlet current = contributions?.field;\n\tfor (const segment of path) {\n\t\tif (typeof current !== \"object\" || current === null || \"kind\" in current) return;\n\t\tcurrent = current[segment];\n\t}\n\treturn current !== void 0 && isAuthoringFieldPresetDescriptor(current) ? current : void 0;\n}\n//#endregion\nexport { TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG, TIMESTAMP_NOW_GENERATOR_ID, assertNoCrossRegistryCollisions, assertResolvableTypeConstructorTemplates, classifyEnumMemberType, collectScalarTypeConstructors, fieldPresetSpellings, findAuthoringTypeConstructorCall, flushAuthoringWarnings, getAuthoringFieldPreset, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringArgRef, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, printTaggedLiteral, readEnumBlockMembers, resolveAuthoringTemplateValue, resolveEnumCodecId, temporalAuthoringPresets, temporalCodecPreset, temporalPhaseTemplate, validateAuthoringHelperArguments, validateAuthoringTypeParams };\n\n//# sourceMappingURL=authoring.mjs.map"],"mappings":"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"}

package/dist/codec-0XB-9TzG.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-0XB-9TzG.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec.d.mts"],"mappings":";;;;;;;;;;;KAUK,qBAAqB;WACf,SAAS;;WAET;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,oCAAoC,gBAAgB,oBAAoB,mBAAmB;;;;KAIrH,sBAAsB,UAAU,oCAAoC,gBAAgB,WAAW,WAAW,WAAW,gBAAgB,mBAAmB;;;;KAIxJ,mBAAmB,UAAU,gCAAgC,WAAW,yBAAyB,0BAA0B,WAAW;;;;;;iBAM1H,gBAAgB,iBAAiB,kBAAkB,MAAM;iBACzD,iBAAiB,iBAAiB,MAAM;;iBAExC,mBAAmB,iBAAiB,MAAM,WAAW,SAAS,QAAQ;iBACtE,kBAAkB,iBAAiB,MAAM;UAChD;WACC;WACA;;;iBAGM,YAAY,gBAAgB,OAAO,eAAe;;cAErD,oBAAoB;;cAEpB,aAAa;iBACV,kBAAkB,iBAAiB,MAAM,WAAW,OAAO;UAClE;WACC;WACA;;;cAGG,aAAa;;cAEb,2BAA2B;;iBAExB,sBAAsB,iBAAiB,MAAM,WAAW,QAAQ;;iBAEhE,gBAAgB;;iBAEhB,gBAAgB,gBAAgB;iBAChC,gBAAgB,iBAAiB,MAAM;;;;;;;;;;;;iBAYvC,gBAAgB,OAAO;;;cAG1B;;;;;;;iBAOG,8BAA8B,gBAAgB,oBAAoB,gCAAgC,KAAK,UAAU,iFAAiF;;;;;;;;;;;iBAWlM,wBAAwB,YAAY,oBAAoB,KAAK;;;;;;;iBAO7D,iBAAiB,YAAY,oBAAoB,KAAK,UAAU,KAAK,uBAAuB;;;;iBAI5F,YAAY,QAAQ,KAAK,8CAA8C,KAAK,WAAW"}

package/dist/codec-Cz-bOon3.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-Cz-bOon3.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec.mjs"],"sourcesContent":["import { t as emptyCodecLookup } from \"./codec-types-BXLUbk-Y.mjs\";\nimport { a as resolveCodecDescriptorOrThrow, c as createDataTypeLookup, d as objectSchemaKeys, f as requiredParamKeys, i as materializeCodec, l as dataType, o as validateCodecTypeParams, p as requiredSchemaKeys, r as codecForRef, s as assembleDataTypes, t as CONTRACT_CODEC_DESCRIPTOR_MISSING, u as dataTypeId } from \"./resolve-codec-qE0g980d.mjs\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { tsStringLiteral } from \"@internal/ts-render\";\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`, `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 CodecDescriptorTemplateImpl = class {\n\tget isParameterized() {\n\t\treturn this.paramsSchema !== void 0;\n\t}\n};\n/**\n* Abstract base for a concrete codec descriptor: a {@link CodecDescriptorTemplateImpl} that also\n* names the data type its codec represents.\n*\n* A codec whose data type depends on the target that adopts it extends\n* {@link CodecDescriptorTemplateImpl} instead, and the target names the type when it adapts the\n* template.\n*/\nvar CodecDescriptorImpl = class extends CodecDescriptorTemplateImpl {};\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 ignored: the contract names the column's database type from the data type the codec represents.\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/decode-json.ts\n/**\n* Readers for the JSON forms codecs share, each built as {@link Codec.decodeJson} requires: it returns the application value for a stored form of the codec's type and refuses anything else with {@link refuseJsonValue}.\n*/\nconst RECEIVED_PREVIEW_LIMIT = 100;\n/** The value a refusal names: its JSON text, or its digits for a number JSON cannot write, cut to 100 characters. */\nfunction receivedPreview(json) {\n\treturn (typeof json === \"number\" ? String(json) : JSON.stringify(json)).slice(0, RECEIVED_PREVIEW_LIMIT);\n}\n/**\n* The refusal every `decodeJson` raises: `RUNTIME.DECODE_FAILED`, `<codecId> JSON value must be <expected>`, with `meta.codecId` and `meta.received`, the value it was given as JSON text, cut to 100 characters.\n*/\nfunction refuseJsonValue(codecId, expected, json) {\n\tthrow structuredError(\"RUNTIME.DECODE_FAILED\", `${codecId} JSON value must be ${expected}`, { meta: {\n\t\tcodecId,\n\t\treceived: receivedPreview(json)\n\t} });\n}\nfunction decodeJsonString(codecId, json) {\n\tif (typeof json !== \"string\") return refuseJsonValue(codecId, \"a string\", json);\n\treturn json;\n}\n/** Reads a JSON string that matches `pattern`; `form` names what the pattern accepts, for the refusal. */\nfunction decodeJsonMatching(codecId, json, pattern, form) {\n\tif (typeof json !== \"string\" || !pattern.test(json)) return refuseJsonValue(codecId, form, json);\n\treturn json;\n}\nfunction decodeJsonBoolean(codecId, json) {\n\tif (typeof json !== \"boolean\") return refuseJsonValue(codecId, \"a boolean\", json);\n\treturn json;\n}\n/** Whether `value` is an integer within `range`, its ends included. */\nfunction isIntegerIn(value, range) {\n\treturn typeof value === \"number\" && Number.isInteger(value) && value >= range.min && value <= range.max;\n}\n/** The integers a JavaScript `number` holds exactly. */\nconst SAFE_INTEGER_RANGE = {\n\tmin: Number.MIN_SAFE_INTEGER,\n\tmax: Number.MAX_SAFE_INTEGER\n};\n/** The integers a signed 32-bit integer holds. */\nconst INT32_RANGE = {\n\tmin: -(2 ** 31),\n\tmax: 2 ** 31 - 1\n};\nfunction decodeJsonInteger(codecId, json, range) {\n\tif (!isIntegerIn(json, range)) return refuseJsonValue(codecId, `an integer from ${range.min} to ${range.max}`, json);\n\treturn json;\n}\n/** The integers a signed 64-bit integer holds. */\nconst INT64_RANGE = {\n\tmin: -(2n ** 63n),\n\tmax: 2n ** 63n - 1n\n};\n/** The integers a JavaScript `number` holds exactly, as a `bigint` range. */\nconst SAFE_INTEGER_BIGINT_RANGE = {\n\tmin: BigInt(Number.MIN_SAFE_INTEGER),\n\tmax: BigInt(Number.MAX_SAFE_INTEGER)\n};\nconst DECIMAL_INTEGER_TEXT = /^-?\\d+$/;\n/** Reads an integer a codec writes as decimal text, because a JSON number cannot hold every value of its type. */\nfunction decodeJsonIntegerText(codecId, json, range) {\n\tconst expected = range === void 0 ? \"a decimal integer string\" : `a decimal integer string from ${range.min} to ${range.max}`;\n\tconst value = BigInt(decodeJsonMatching(codecId, json, DECIMAL_INTEGER_TEXT, expected));\n\tif (range !== void 0 && (value < range.min || value > range.max)) return refuseJsonValue(codecId, expected, json);\n\treturn value;\n}\nconst NON_FINITE_TEXT = /* @__PURE__ */ new Set([\n\t\"NaN\",\n\t\"Infinity\",\n\t\"-Infinity\"\n]);\n/** Whether `text` is `NaN`, `Infinity` or `-Infinity`, the text a float's JSON form writes for a value JSON has no number for. */\nfunction isNonFiniteText(text) {\n\treturn NON_FINITE_TEXT.has(text);\n}\n/** JSON has no number for NaN or an infinity, so a float's JSON form writes them as the text `NaN`, `Infinity` and `-Infinity`. */\nfunction encodeJsonFloat(value) {\n\treturn Number.isFinite(value) ? value : String(value);\n}\nfunction decodeJsonFloat(codecId, json) {\n\tif (typeof json === \"number\" && Number.isFinite(json)) return json;\n\tif (typeof json === \"string\" && isNonFiniteText(json)) return Number(json);\n\treturn refuseJsonValue(codecId, \"a finite number or the text NaN, Infinity or -Infinity\", json);\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*/\nfunction renderTsLiteral(value) {\n\tif (typeof value === \"string\") return tsStringLiteral(value);\n\tif (typeof value === \"number\" || typeof value === \"boolean\") return String(value);\n}\n//#endregion\nexport { CONTRACT_CODEC_DESCRIPTOR_MISSING, CodecDescriptorImpl, CodecDescriptorTemplateImpl, CodecImpl, INT32_RANGE, INT64_RANGE, SAFE_INTEGER_BIGINT_RANGE, SAFE_INTEGER_RANGE, assembleDataTypes, codecForRef, column, createDataTypeLookup, dataType, dataTypeId, decodeJsonBoolean, decodeJsonFloat, decodeJsonInteger, decodeJsonIntegerText, decodeJsonMatching, decodeJsonString, emptyCodecLookup, encodeJsonFloat, isIntegerIn, isNonFiniteText, materializeCodec, objectSchemaKeys, refuseJsonValue, renderTsLiteral, requiredParamKeys, requiredSchemaKeys, resolveCodecDescriptorOrThrow, validateCodecTypeParams };\n\n//# sourceMappingURL=codec.mjs.map"],"mappings":"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"}

package/dist/codec-types-CZ8xRBJy-BMjCsUt1.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-CZ8xRBJy-BMjCsUt1.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/codec-types-CZ8xRBJy.d.mts"],"mappings":";;;;;;;;;;KASK;WACM;;;;;;KAMN,QAAQ,OAAO,cAAc;;;;;UAKxB;WACC,aAAa;WACb,OAAO,mBAAmB,gBAAgB;;;;;;;KAOhD,mBAAmB,OAAO,cAAc;UACnC;WACC,IAAI;;WAEJ,SAAS;;WAET,OAAO,SAAS,OAAO,YAAY;WACnC,WAAW;;;;;WAKX,kBAAkB;;UAEnB;WACC,SAAS;WACT,QAAQ,SAAS,eAAe;WAChC;aACE;aACA,MAAM;;WAER,kBAAkB;;;UAGnB;EACR,IAAI,aAAa;EACjB,IAAI;;;iBAGW,WAAW,aAAa;;iBAExB,SAAS,YAAY,MAAM,eAAe;;iBAE1C,iBAAiB;;iBAEjB,mBAAmB;;iBAEnB,kBAAkB,MAAM;iBACxB,qBAAqB,gBAAgB,aAAa;;iBAElD,kBAAkB,aAAa;WACrC;WACA,YAAY,cAAc;;WAE1B,QAAQ;WACR,UAAU;aACR,MAAM;aACN;;;;;;;;;;;;;;;;UAgBH,wBAAwB;;WAEvB;;WAEA,iBAAiB;;WAEjB,cAAc,iBAAiB;;WAE/B;;WAEA,oBAAoB,QAAQ;;WAE5B,mBAAmB,QAAQ;;;;;;;;;;;WAW3B,sBAAsB,OAAO,WAAW;;WAExC,UAAU,QAAQ,OAAO,KAAK,yBAAyB;;;;;;;;;UASxD,gBAAgB,kBAAkB,wBAAwB;;WAEzD,UAAU;;;;;;KAMhB,6BAA6B;;;;;;KAM7B,qBAAqB;;;;;;;;uBAQH,4BAA4B,2BAA2B,wBAAwB;oBAClF;oBACA,iBAAiB;oBACjB,cAAc,iBAAiB;MAC7C;;EAEJ,kBAAkB,QAAQ;;EAE1B,iBAAiB,QAAQ;;EAEzB,oBAAoB,OAAO,WAAW;;;;WAI7B,QAAQ,QAAQ,WAAW,KAAK,yBAAyB,uBAAuB;;;;;;;;;;uBAUpE,oBAAoB,wBAAwB,4BAA4B,oBAAoB,gBAAgB;oBAC/G,UAAU;;;;;;;;;;;;;;;;;;;;;;;UAuBpB,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;;;;EAI3B,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;;WAE3B,WAAW,MAAM,YAAY;;;;;cAK1B;KACT,qBAAqB;;;;;;;;;;;;UAYhB;WACC;WACA,aAAa;WACb;;;;;;;;;;;;;UAaD;WACC,SAAS;;;;;;;;UAQV;EACR,IAAI,aAAa;EACjB,oBAAoB,YAAY,QAAQ;;EAExC,oBAAoB,YAAY,QAAQ;;EAExC,uBAAuB,YAAY,OAAO,WAAW;;;UAG7C,mCAAmC;;;;EAI3C,cAAc,aAAa;;;;;;;;;;;;;;;UAenB,sBAAsB;EAC9B,YAAY,KAAK,WAAW;EAC5B,UAAU,qBAAqB,eAAe,iBAAiB;;;cAGnD,kBAAkB;;;;;;;;UAQtB;WACC"}