@prisma-next/framework-components 0.13.0-dev.15 → 0.13.0-dev.17

package/src/control/psl-extension-block-validator.ts

@@ -107,15 +107,17 @@ export function validateExtensionBlock(
   const nodeKeys = new Set(Object.keys(node.parameters));
 
   // 1. Unknown parameters — keys in the node not in the descriptor.
-  for (const key of nodeKeys) {
-    if (!descriptorKeys.has(key)) {
-      const captured = node.parameters[key];
-      diagnostics.push({
-        code: 'PSL_EXTENSION_UNKNOWN_PARAMETER',
-        message: `Unknown parameter "${key}" in "${descriptor.keyword}" block "${node.name}". The descriptor does not declare this parameter.`,
-        sourceId,
-        span: captured?.span ?? node.span,
-      });
+  if (!descriptor.variadicParameters) {
+    for (const key of nodeKeys) {
+      if (!descriptorKeys.has(key)) {
+        const captured = node.parameters[key];
+        diagnostics.push({
+          code: 'PSL_EXTENSION_UNKNOWN_PARAMETER',
+          message: `Unknown parameter "${key}" in "${descriptor.keyword}" block "${node.name}". The descriptor does not declare this parameter.`,
+          sourceId,
+          span: captured?.span ?? node.span,
+        });
+      }
     }
   }
 

package/src/exports/authoring.ts

@@ -3,6 +3,7 @@ export type {
   AuthoringArgumentDescriptor,
   AuthoringColumnDefaultTemplate,
   AuthoringContributions,
+  AuthoringDiagnosticSink,
   AuthoringEntityContext,
   AuthoringEntityTypeDescriptor,
   AuthoringEntityTypeFactoryOutput,

package/src/exports/control.ts

@@ -47,7 +47,6 @@ export type {
   MigrationRunnerSuccessValue,
   MigrationScaffoldContext,
   OpFactoryCall,
-  SerializedQueryPlan,
   TargetMigrationsCapability,
 } from '../control/control-migration-types';
 export type {

package/src/shared/framework-authoring.ts

@@ -10,6 +10,7 @@ import {
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Type } from 'arktype';
+import type { CodecLookup } from './codec-types';
 import type { PslBlockParam } from './psl-extension-block';
 
 export type AuthoringArgRef = {
@@ -109,9 +110,30 @@ export type AuthoringFieldNamespace = {
  * discover what the factory actually needs to read (codec lookup,
  * namespace registry, …).
  */
+/**
+ * A write-only sink that a factory may push authoring-time diagnostics into.
+ * The concrete type pushed must be structurally compatible with whatever the
+ * consumer accumulates (typically `ContractSourceDiagnostic[]`); the framework
+ * layer deliberately does not depend on that concrete type.
+ */
+export interface AuthoringDiagnosticSink {
+  push(d: {
+    readonly code: string;
+    readonly message: string;
+    readonly sourceId: string;
+    readonly span?: unknown;
+  }): void;
+}
+
 export interface AuthoringEntityContext {
   readonly family: string;
   readonly target: string;
+  /** Codec registry available to factories that need to validate or decode values. */
+  readonly codecLookup?: CodecLookup;
+  /** Source file identifier threaded into diagnostics emitted by the factory. */
+  readonly sourceId?: string;
+  /** Push channel for authoring-time diagnostics emitted by the factory. */
+  readonly diagnostics?: AuthoringDiagnosticSink;
 }
 
 export interface AuthoringEntityTypeTemplateOutput {
@@ -186,6 +208,21 @@ export interface AuthoringPslBlockDescriptor {
   readonly discriminator: string;
   readonly name: { readonly required: boolean };
   readonly parameters: Record<string, PslBlockParam>;
+  /**
+   * When `true`, the block body accepts a variadic tail of parameters beyond
+   * the declared set. The block body may contain: fields (model-style),
+   * `key = value` parameters, and `@@` attributes. With `variadicParameters`,
+   * bare identifiers (keys without a `= value`) and undeclared `key = value`
+   * pairs flow into the variadic tail — their semantics belong to the
+   * lowering, not the parser.
+   *
+   * A key that IS declared in `parameters` must still be supplied as
+   * `key = value`; a bare occurrence of a declared key is a diagnostic.
+   *
+   * When `false` (default), the validator emits `PSL_EXTENSION_UNKNOWN_PARAMETER`
+   * for keys absent from `parameters`.
+   */
+  readonly variadicParameters?: boolean;
 }
 
 export type AuthoringPslBlockDescriptorNamespace = {
@@ -399,7 +436,7 @@ export function mergeAuthoringNamespaces(
   }
 }
 
-function collectAuthoringLeafPaths(
+function collectDescriptorPaths(
   namespace: Readonly<Record<string, unknown>>,
   isLeaf: (value: unknown) => boolean,
   path: readonly string[] = [],
@@ -413,29 +450,25 @@ function collectAuthoringLeafPaths(
     }
     if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
       paths.push(
-        ...collectAuthoringLeafPaths(
-          value as Readonly<Record<string, unknown>>,
-          isLeaf,
-          currentPath,
-        ),
+        ...collectDescriptorPaths(value as Readonly<Record<string, unknown>>, isLeaf, currentPath),
       );
     }
   }
   return paths;
 }
 
-interface AuthoringLeafEntry {
+interface DescriptorEntry {
   readonly path: string;
   readonly discriminator: string;
 }
 
-function collectAuthoringLeafDiscriminators(
+function collectDescriptorEntries(
   namespace: Readonly<Record<string, unknown>>,
   isLeaf: (value: unknown) => boolean,
   label: string,
   path: readonly string[] = [],
-): AuthoringLeafEntry[] {
-  const entries: AuthoringLeafEntry[] = [];
+): DescriptorEntry[] {
+  const entries: DescriptorEntry[] = [];
   for (const [key, value] of Object.entries(namespace)) {
     const currentPath = [...path, key];
     if (isLeaf(value)) {
@@ -479,7 +512,7 @@ function collectAuthoringLeafDiscriminators(
           );
         }
       }
-      entries.push(...collectAuthoringLeafDiscriminators(record, isLeaf, label, currentPath));
+      entries.push(...collectDescriptorEntries(record, isLeaf, label, currentPath));
     }
   }
   return entries;
@@ -491,7 +524,7 @@ function collectAuthoringLeafDiscriminators(
  * lowering factory lookup dispatches by discriminator, so one would silently
  * shadow the other. Catch duplicates before building any dispatch map.
  */
-function assertUniqueDiscriminators(entries: readonly AuthoringLeafEntry[], label: string): void {
+function assertUniqueDiscriminators(entries: readonly DescriptorEntry[], label: string): void {
   const seen = new Map<string, string>();
   for (const { path, discriminator } of entries) {
     const existing = seen.get(discriminator);
@@ -504,23 +537,50 @@ function assertUniqueDiscriminators(entries: readonly AuthoringLeafEntry[], labe
   }
 }
 
+function collectPslBlockDescriptorEntries(
+  namespace: Readonly<Record<string, unknown>>,
+  path: readonly string[] = [],
+): DescriptorEntry[] {
+  const entries: DescriptorEntry[] = [];
+  for (const [key, value] of Object.entries(namespace)) {
+    const currentPath = [...path, key];
+    if (isAuthoringPslBlockDescriptor(value)) {
+      entries.push({
+        path: currentPath.join('.'),
+        discriminator: value.discriminator,
+      });
+      continue;
+    }
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const record = blindCast<
+        Readonly<Record<string, unknown>>,
+        'walker descends into psl block namespace'
+      >(value);
+      const hasKind = record['kind'] === 'pslBlock';
+      const hasKeyword = typeof record['keyword'] === 'string';
+      const hasDiscriminator = typeof record['discriminator'] === 'string';
+      if (hasKind || (hasKeyword && hasDiscriminator)) {
+        throw new Error(
+          `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.`,
+        );
+      }
+      entries.push(...collectPslBlockDescriptorEntries(record, currentPath));
+    }
+  }
+  return entries;
+}
+
 /**
- * Every `pslBlockDescriptors` entry needs a matching `entityTypes` factory
- * (same discriminator): the parser would otherwise produce an AST node
- * nothing can lower to an IR class instance. The link is one-directional
- * — an `entityTypes` factory may stand alone (e.g. `enum`, reachable from
- * the TypeScript builder without any PSL block).
+ * Every `pslBlockDescriptors` entry requires a matching `entityTypes` factory
+ * with the same discriminator. An `entityTypes` factory may stand alone (e.g.
+ * `enum`, reachable from the TypeScript builder without any PSL block).
  */
 function assertPslBlocksHaveFactories(
   entityTypeNamespace: AuthoringEntityTypeNamespace,
   pslBlockNamespace: AuthoringPslBlockDescriptorNamespace,
 ): void {
-  const blockEntries = collectAuthoringLeafDiscriminators(
-    pslBlockNamespace,
-    isAuthoringPslBlockDescriptor,
-    'pslBlock',
-  );
-  const entityEntries = collectAuthoringLeafDiscriminators(
+  const blockEntries = collectPslBlockDescriptorEntries(pslBlockNamespace);
+  const entityEntries = collectDescriptorEntries(
     entityTypeNamespace,
     isAuthoringEntityTypeDescriptor,
     'entityType',
@@ -547,13 +607,13 @@ export function assertNoCrossRegistryCollisions(
   pslBlockNamespace: AuthoringPslBlockDescriptorNamespace = {},
 ): void {
   const typePaths = new Set(
-    collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),
+    collectDescriptorPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),
   );
   const fieldPaths = new Set(
-    collectAuthoringLeafPaths(fieldNamespace, isAuthoringFieldPresetDescriptor),
+    collectDescriptorPaths(fieldNamespace, isAuthoringFieldPresetDescriptor),
   );
   const entityPaths = new Set(
-    collectAuthoringLeafPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor),
+    collectDescriptorPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor),
   );
   // Within-registry duplicate detection is handled upstream by the merge
   // walker (`mergeAuthoringNamespaces` in control-stack.ts and

package/src/shared/psl-extension-block.ts

@@ -70,7 +70,16 @@ export type PslDiagnosticCode =
    * A `ref`-kind parameter identifier does not resolve to a declared entity of
    * the required `refKind` within the declared scope.
    */
-  | 'PSL_EXTENSION_UNRESOLVED_REF';
+  | 'PSL_EXTENSION_UNRESOLVED_REF'
+  /**
+   * A parameter key appears more than once in an extension block body.
+   * The first occurrence is kept; subsequent occurrences emit this diagnostic.
+   */
+  | 'PSL_EXTENSION_DUPLICATE_PARAMETER'
+  /**
+   * A `@@`-prefixed block-attribute line inside an extension block has invalid syntax.
+   */
+  | 'PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE';
 
 /**
  * Descriptor vocabulary for a single parameter on a declared block.
@@ -118,14 +127,17 @@ export interface PslBlockParamList {
 /**
  * The parsed representation of a single parameter value on a uniform
  * extension-block AST node. Mirrors the `PslBlockParam` descriptor
- * vocabulary:
+ * vocabulary, plus `bare` for keyonly entries:
  *
  * - `ref`    → `PslExtensionBlockParamRef` — a raw identifier string
  *   (resolution runs in the validator, not the parser).
- * - `value`  → `PslExtensionBlockParamValue` — a raw PSL literal string
+ * - `value`  → `PslExtensionBlockParamScalarValue` — a raw PSL literal string
  *   (codec validation runs in the validator).
  * - `option` → `PslExtensionBlockParamOption` — the chosen token.
  * - `list`   → `PslExtensionBlockParamList` — ordered list of the above.
+ * - `bare`   → `PslExtensionBlockParamBare` — a bare identifier line with no
+ *   `= value` (e.g. `Low` in an enum2 block). The name is the key in
+ *   `parameters`; the interpreting consumer decides the default value.
  *
  * These shapes are intentionally minimal. The validator and lowering refine
  * and consume them; the generic framework parser produces them.
@@ -134,7 +146,8 @@ export type PslExtensionBlockParamValue =
   | PslExtensionBlockParamRef
   | PslExtensionBlockParamScalarValue
   | PslExtensionBlockParamOption
-  | PslExtensionBlockParamList;
+  | PslExtensionBlockParamList
+  | PslExtensionBlockParamBare;
 
 export interface PslExtensionBlockParamRef {
   readonly kind: 'ref';
@@ -160,6 +173,38 @@ export interface PslExtensionBlockParamList {
   readonly span: PslSpan;
 }
 
+/**
+ * A bare identifier line inside an extension block — a key with no `= value`.
+ * Emitted when a line matches `/^[A-Za-z_]\w*$/` with no assignment. The
+ * consumer decides what default value (if any) to apply.
+ */
+export interface PslExtensionBlockParamBare {
+  readonly kind: 'bare';
+  readonly span: PslSpan;
+}
+
+/**
+ * A positional argument on a block attribute, e.g. the `"pg/text@1"` in
+ * `@@type("pg/text@1")`.
+ */
+export interface PslExtensionBlockAttributeArg {
+  readonly kind: 'positional';
+  readonly value: string;
+  readonly span: PslSpan;
+}
+
+/**
+ * A `@@`-prefixed block-level attribute parsed inside an extension block,
+ * e.g. `@@type("pg/text@1")`. Block attributes are captured generically
+ * — the parser does not validate attribute names or argument shapes; that
+ * is a concern of the block's interpreter.
+ */
+export interface PslExtensionBlockAttribute {
+  readonly name: string;
+  readonly args: readonly PslExtensionBlockAttributeArg[];
+  readonly span: PslSpan;
+}
+
 /**
  * Base shape for a uniform extension-contributed top-level PSL block
  * node, as produced by the generic framework parser and consumed by the
@@ -173,12 +218,18 @@ export interface PslExtensionBlockParamList {
  *   parameter names from the descriptor; values are the parsed parameter
  *   representations. Only parameters present in the source are included
  *   — absence of a required parameter is a validator concern, not a
- *   parser concern.
+ *   parser concern. Insertion order is preserved; the first occurrence of a
+ *   duplicate key is retained and subsequent occurrences emit
+ *   `PSL_EXTENSION_DUPLICATE_PARAMETER`.
+ * - `blockAttributes` are `@@`-prefixed attribute lines inside the block, in
+ *   declaration order. Captured generically — names and args are not validated
+ *   by the parser.
  * - `span` covers the full block from keyword to closing brace.
  */
 export interface PslExtensionBlock {
   readonly kind: string;
   readonly name: string;
   readonly parameters: Record<string, PslExtensionBlockParamValue>;
+  readonly blockAttributes: readonly PslExtensionBlockAttribute[];
   readonly span: PslSpan;
 }

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

@@ -1 +0,0 @@
-{"version":3,"file":"codec-DCQAerzB.d.mts","names":[],"sources":["../src/shared/codec-types.ts","../src/shared/codec-descriptor.ts","../src/shared/codec.ts"],"mappings":";;;;KAIY,UAAA;AAAZ;;;;AAAsB;AAWtB;;;;AAXA,UAWiB,QAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA,GAAa,SAAS;AAAA;AAAA;AAcjC;;;;AAC+B;AAW/B;;;;;AA1BiC,UAchB,gBAAA;EAAA,SACN,MAAA,GAAS,WAAW;AAAA;;;;;;;;;UAWd,WAAA;EACf,GAAA,CAAI,EAAA,WAAa,KAAA;EACjB,cAAA,CAAe,EAAA;EACf,OAAA,CAAQ,EAAA,WAAa,SAAA;EACrB,mBAAA,CAAoB,EAAA,UAAY,MAAA,EAAQ,MAAA;AAAA;AAAA,cAG7B,gBAAA,EAAkB,WAK9B;;;;AAAA;AASD;;;UAAiB,oBAAA;EAAA,SACN,IAAI;AAAA;;;;UAME,SAAA;EAAA,SACN,EAAA,GAAK,MAAM;AAAA;;;AAMyB;cAAlC,gBAAA,EAAkB,gBAAgB;;;;;;;;AA7Dd;AAcjC;;;;AAC+B;UCFd,eAAA;EDaW;EAAA,SCXjB,OAAA;EDYQ;EAAA,SCVR,MAAA,WAAiB,UAAA;EDac;EAAA,SCX/B,WAAA;EDWqC;EAAA,SCTrC,IAAA,GAAO,SAAA;EDMZ;EAAA,SCJK,YAAA,EAAc,gBAAA,CAAiB,CAAA;EDKxC;EAAA,SCHS,eAAA;EDIT;EAAA,SCFS,gBAAA,IAAoB,MAAA,EAAQ,CAAA;EDEhB;EAAA,SCAZ,OAAA,GAAU,MAAA,EAAQ,CAAA,MAAO,GAAA,EAAK,oBAAA,KAAyB,KAAA;AAAA;;;;ADCD;AAGjE;KCKY,kBAAA,GAAqB,eAAe;;;ADA/C;AASD;;;;uBCAsB,mBAAA,4BAA+C,eAAA,CAAgB,OAAA;EAAA,kBACjE,OAAA;EAAA,kBACA,MAAA,WAAiB,UAAA;EAAA,kBACjB,WAAA;EAAA,SACT,IAAA,GAAO,SAAA;EAAA,kBAEE,YAAA,EAAc,gBAAA,CAAiB,OAAA;EDQtC;EAAA,ICLP,eAAA;;EAKJ,gBAAA,EAAkB,MAAA,EAAQ,OAAA;EDAmB;;;EAAA,SCKpC,OAAA,CACP,MAAA,EAAQ,OAAA,IACN,GAAA,EAAK,oBAAA,KAAyB,KAAA,kBAAuB,UAAA;AAAA;;;;;;;;ADpE1B;AAcjC;;;;AAC+B;AAW/B;;;;;;;;UEViB,KAAA,sDAEU,UAAA,cAAwB,UAAA;EFS7C;EAAA,SEJK,EAAA,EAAI,EAAA;EFKb;EAAA,SEHS,aAAA,GAAgB,OAAA;EFIzB;EEFA,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,KAAA;EFEjC;EEArB,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,MAAA;EFChC;EECpB,UAAA,CAAW,KAAA,EAAO,MAAA,GAAS,SAAA;EFDK;EEGhC,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,MAAA;AAAA;AFA/B;;;;AAKC;AALD,uBEQsB,SAAA,sDAEK,UAAA,cAAwB,UAAA,kDAGtC,KAAA,CAAM,EAAA,EAAI,OAAA,EAAS,KAAA,EAAO,MAAA;EAAA,SAMT,UAAA,EAAY,eAAA;;;AFJ3B;cEIe,UAAA,EAAY,eAAA;EAAA,IAEpC,EAAA,IAAM,EAAA;EAAA,SAID,MAAA,CAAO,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,KAAA;EAAA,SACtD,MAAA,CAAO,IAAA,EAAM,KAAA,EAAO,GAAA,EAAK,gBAAA,GAAmB,OAAA,CAAQ,MAAA;EAAA,SACpD,UAAA,CAAW,KAAA,EAAO,MAAA,GAAS,SAAA;EAAA,SAC3B,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,MAAA;AAAA"}

package/dist/framework-authoring-CnwPJCO4.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-authoring-CnwPJCO4.mjs","names":[],"sources":["../src/shared/framework-authoring.ts"],"sourcesContent":["import type {\n  ColumnDefault,\n  ExecutionMutationDefaultPhases,\n  ExecutionMutationDefaultValue,\n} from '@prisma-next/contract/types';\nimport {\n  isColumnDefaultLiteralInputValue,\n  isExecutionMutationDefaultValue,\n} from '@prisma-next/contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { Type } from 'arktype';\nimport type { PslBlockParam } from './psl-extension-block';\n\nexport type AuthoringArgRef = {\n  readonly kind: 'arg';\n  readonly index: number;\n  readonly path?: readonly string[];\n  readonly default?: AuthoringTemplateValue;\n};\n\nexport type AuthoringTemplateValue =\n  | string\n  | number\n  | boolean\n  | null\n  | AuthoringArgRef\n  | readonly AuthoringTemplateValue[]\n  | { readonly [key: string]: AuthoringTemplateValue };\n\ninterface AuthoringArgumentDescriptorCommon {\n  readonly name?: string;\n  readonly optional?: boolean;\n}\n\nexport type AuthoringArgumentDescriptor = AuthoringArgumentDescriptorCommon &\n  (\n    | { readonly kind: 'string' }\n    | { readonly kind: 'boolean' }\n    | {\n        readonly kind: 'number';\n        readonly integer?: boolean;\n        readonly minimum?: number;\n        readonly maximum?: number;\n      }\n    | { readonly kind: 'stringArray' }\n    | {\n        readonly kind: 'object';\n        readonly properties: Record<string, AuthoringArgumentDescriptor>;\n      }\n  );\n\nexport interface AuthoringStorageTypeTemplate {\n  readonly codecId: string;\n  readonly nativeType: AuthoringTemplateValue;\n  readonly typeParams?: Record<string, AuthoringTemplateValue>;\n}\n\nexport interface AuthoringTypeConstructorDescriptor {\n  readonly kind: 'typeConstructor';\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output: AuthoringStorageTypeTemplate;\n}\n\nexport interface AuthoringColumnDefaultTemplateLiteral {\n  readonly kind: 'literal';\n  readonly value: AuthoringTemplateValue;\n}\n\nexport interface AuthoringColumnDefaultTemplateFunction {\n  readonly kind: 'function';\n  readonly expression: AuthoringTemplateValue;\n}\n\nexport type AuthoringColumnDefaultTemplate =\n  | AuthoringColumnDefaultTemplateLiteral\n  | AuthoringColumnDefaultTemplateFunction;\n\nexport interface AuthoringExecutionDefaultsTemplate {\n  readonly onCreate?: AuthoringTemplateValue;\n  readonly onUpdate?: AuthoringTemplateValue;\n}\n\nexport interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {\n  readonly nullable?: boolean;\n  readonly default?: AuthoringColumnDefaultTemplate;\n  readonly executionDefaults?: AuthoringExecutionDefaultsTemplate;\n  readonly id?: boolean;\n  readonly unique?: boolean;\n}\n\nexport interface AuthoringFieldPresetDescriptor {\n  readonly kind: 'fieldPreset';\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output: AuthoringFieldPresetOutput;\n}\n\nexport type AuthoringTypeNamespace = {\n  readonly [name: string]: AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace;\n};\n\nexport type AuthoringFieldNamespace = {\n  readonly [name: string]: AuthoringFieldPresetDescriptor | AuthoringFieldNamespace;\n};\n\n/**\n * Context surfaced to entity-type factories at call time. Currently a\n * placeholder — sharpened as concrete consumers (enum, namespace, …)\n * discover what the factory actually needs to read (codec lookup,\n * namespace registry, …).\n */\nexport interface AuthoringEntityContext {\n  readonly family: string;\n  readonly target: string;\n}\n\nexport interface AuthoringEntityTypeTemplateOutput {\n  readonly template: AuthoringTemplateValue;\n}\n\n/**\n * Default `Input = never` is load-bearing for pack-bag-driven type\n * narrowing. Factory parameter positions are contravariant, so a pack\n * literal declaring `factory: (input: DemoEntityInput) => DemoEntity`\n * is only assignable to the base descriptor's factory shape if the\n * base's input is `never` (the bottom of the contravariant position).\n * The concrete input/output types are recovered at the helper-derivation\n * site via `EntityHelperFunction<Descriptor>`'s conditional inference,\n * which reads them from the pack's `as const` literal factory signature\n * — the base widening does not erase the literal because `satisfies`\n * does not widen the declared type.\n */\nexport interface AuthoringEntityTypeFactoryOutput<Input = never, Output = unknown> {\n  readonly factory: (input: Input, ctx: AuthoringEntityContext) => Output;\n}\n\nexport interface AuthoringEntityTypeDescriptor<Input = never, Output = unknown> {\n  readonly kind: 'entity';\n  readonly discriminator: string;\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output:\n    | AuthoringEntityTypeTemplateOutput\n    | AuthoringEntityTypeFactoryOutput<Input, Output>;\n  /**\n   * arktype schema fragment for one entry whose envelope `kind` matches\n   * this descriptor's {@link discriminator}. The family validator composes\n   * contributed fragments into the per-namespace entry schema at\n   * validator construction time so the structural check covers\n   * pack-introduced kinds without the family core hard-coding the schema.\n   *\n   * Hydration uses {@link AuthoringEntityTypeFactoryOutput.factory}\n   * directly — the wire shape conforms structurally to the factory's\n   * `Input` after `validatorSchema` validates it.\n   */\n  readonly validatorSchema?: Type<unknown>;\n}\n\nexport type AuthoringEntityTypeNamespace = {\n  readonly [name: string]: AuthoringEntityTypeDescriptor | AuthoringEntityTypeNamespace;\n};\n\n/**\n * Declarative descriptor for an extension-contributed top-level PSL block.\n *\n * An extension registers one of these per keyword it contributes. The\n * framework owns the generic parser, validator, and printer — no\n * parsing or printing code runs from the extension.\n *\n * - `keyword` is the PSL top-level identifier this descriptor claims\n *   (`policy_select`, `role`, …).\n * - `discriminator` is the routing key used by the printer dispatch and\n *   the `entityTypes` lowering factory lookup. Convention:\n *   `<target-or-family>-<kind>` (`postgres-policy-select`).\n * - `name.required` declares whether the block must have a name token\n *   after the keyword. Currently always `true` — anonymous blocks are\n *   not part of the closed-grammar premise — but the field is explicit\n *   so the type can evolve without a breaking change.\n * - `parameters` maps parameter names to their value-kind descriptors\n *   (`ref` / `value` / `option` / `list`). The generic parser and\n *   validator interpret these; the extension supplies no parser or\n *   printer function.\n */\nexport interface AuthoringPslBlockDescriptor {\n  readonly kind: 'pslBlock';\n  readonly keyword: string;\n  readonly discriminator: string;\n  readonly name: { readonly required: boolean };\n  readonly parameters: Record<string, PslBlockParam>;\n}\n\nexport type AuthoringPslBlockDescriptorNamespace = {\n  readonly [name: string]: AuthoringPslBlockDescriptor | AuthoringPslBlockDescriptorNamespace;\n};\n\nexport interface AuthoringContributions {\n  readonly type?: AuthoringTypeNamespace;\n  readonly field?: AuthoringFieldNamespace;\n  readonly entityTypes?: AuthoringEntityTypeNamespace;\n  /**\n   * Registry of declarative block descriptors this contribution registers,\n   * keyed by arbitrary path segments. Each leaf is an\n   * {@link AuthoringPslBlockDescriptor} that claims a PSL top-level keyword.\n   * The framework owns the generic parser, validator, and printer; the\n   * contribution supplies only these declarative descriptors.\n   *\n   * Contrast with the parsed block nodes themselves, which live in a\n   * namespace's `entries` under their discriminator key; this field holds the\n   * registry of descriptors that teach the parser how to read those blocks.\n   */\n  readonly pslBlockDescriptors?: AuthoringPslBlockDescriptorNamespace;\n}\n\nexport function isAuthoringArgRef(value: unknown): value is AuthoringArgRef {\n  if (typeof value !== 'object' || value === null || (value as { kind?: unknown }).kind !== 'arg') {\n    return false;\n  }\n  const { index, path } = value as { index?: unknown; path?: unknown };\n  if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {\n    return false;\n  }\n  if (path !== undefined && (!Array.isArray(path) || path.some((s) => typeof s !== 'string'))) {\n    return false;\n  }\n  return true;\n}\n\nfunction isAuthoringTemplateRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nexport function isAuthoringTypeConstructorDescriptor(\n  value: unknown,\n): value is AuthoringTypeConstructorDescriptor {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'typeConstructor' &&\n    typeof (value as { output?: unknown }).output === 'object' &&\n    (value as { output?: unknown }).output !== null\n  );\n}\n\nexport function isAuthoringFieldPresetDescriptor(\n  value: unknown,\n): value is AuthoringFieldPresetDescriptor {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'fieldPreset' &&\n    typeof (value as { output?: unknown }).output === 'object' &&\n    (value as { output?: unknown }).output !== null\n  );\n}\n\nexport function isAuthoringEntityTypeDescriptor(\n  value: unknown,\n): value is AuthoringEntityTypeDescriptor {\n  if (\n    typeof value !== 'object' ||\n    value === null ||\n    (value as { kind?: unknown }).kind !== 'entity'\n  ) {\n    return false;\n  }\n  const discriminator = (value as { discriminator?: unknown }).discriminator;\n  if (typeof discriminator !== 'string' || discriminator.length === 0) {\n    return false;\n  }\n  const output = (value as { output?: unknown }).output;\n  if (typeof output !== 'object' || output === null) {\n    return false;\n  }\n  const factory = (output as { factory?: unknown }).factory;\n  const template = (output as { template?: unknown }).template;\n  return typeof factory === 'function' || template !== undefined;\n}\n\nexport function isAuthoringPslBlockDescriptor(\n  value: unknown,\n): value is AuthoringPslBlockDescriptor {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  const record = blindCast<\n    Record<string, unknown>,\n    'type-guard probing an unknown candidate-descriptor object for known property names'\n  >(value);\n  if (record['kind'] !== 'pslBlock') {\n    return false;\n  }\n  const keyword = record['keyword'];\n  if (typeof keyword !== 'string' || keyword.length === 0) {\n    return false;\n  }\n  const discriminator = record['discriminator'];\n  if (typeof discriminator !== 'string' || discriminator.length === 0) {\n    return false;\n  }\n  const name = record['name'];\n  if (typeof name !== 'object' || name === null) {\n    return false;\n  }\n  const nameRecord = blindCast<\n    Record<string, unknown>,\n    'type-guard probing the name property of a candidate pslBlock descriptor'\n  >(name);\n  if (typeof nameRecord['required'] !== 'boolean') {\n    return false;\n  }\n  const parameters = record['parameters'];\n  return typeof parameters === 'object' && parameters !== null && !Array.isArray(parameters);\n}\n\n/**\n * Returns true when `namespace` is a non-leaf key in `contributions.field`.\n *\n * `AuthoringFieldNamespace` permits a leaf descriptor at any depth — including\n * the root — so a top-level `field: { Foo: { kind: 'fieldPreset', ... } }`\n * registration must NOT be treated as a \"namespace\" with sub-paths. Callers\n * use this predicate to gate dot-namespaced lookups (e.g. PSL `@Foo.bar`).\n */\nexport function hasRegisteredFieldNamespace(\n  contributions: AuthoringContributions | undefined,\n  namespace: string,\n): boolean {\n  if (contributions?.field === undefined || !Object.hasOwn(contributions.field, namespace)) {\n    return false;\n  }\n  return !isAuthoringFieldPresetDescriptor(contributions.field[namespace]);\n}\n\nfunction isPlainNamespaceObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Merges `source` into `target` recursively at the descriptor-namespace\n * level. `leafGuard` decides which values are descriptors (terminal\n * merge points; same-path registrations across components are reported\n * as duplicates) versus sub-namespaces (recursion targets).\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 */\nexport function mergeAuthoringNamespaces(\n  target: Record<string, unknown>,\n  source: Record<string, unknown>,\n  path: readonly string[],\n  leafGuard: (value: unknown) => boolean,\n  label: string,\n): void {\n  const assertSafePath = (currentPath: readonly string[]) => {\n    const blockedSegment = currentPath.find(\n      (segment) => segment === '__proto__' || segment === 'constructor' || segment === 'prototype',\n    );\n    if (blockedSegment) {\n      throw new Error(\n        `Invalid authoring ${label} helper \"${currentPath.join('.')}\". Helper path segments must not use \"${blockedSegment}\".`,\n      );\n    }\n  };\n\n  for (const [key, sourceValue] of Object.entries(source)) {\n    const currentPath = [...path, key];\n    assertSafePath(currentPath);\n    const hasExistingValue = Object.hasOwn(target, key);\n    const existingValue = hasExistingValue ? target[key] : undefined;\n\n    if (!hasExistingValue) {\n      target[key] = sourceValue;\n      continue;\n    }\n\n    const existingIsLeaf = leafGuard(existingValue);\n    const sourceIsLeaf = leafGuard(sourceValue);\n\n    if (existingIsLeaf || sourceIsLeaf) {\n      throw new Error(\n        `Duplicate authoring ${label} helper \"${currentPath.join('.')}\". Helper names must be unique across composed packs.`,\n      );\n    }\n\n    if (!isPlainNamespaceObject(existingValue) || !isPlainNamespaceObject(sourceValue)) {\n      throw new Error(\n        `Invalid authoring ${label} helper \"${currentPath.join('.')}\". Expected a sub-namespace object or a recognized descriptor; received a malformed value.`,\n      );\n    }\n\n    mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, leafGuard, label);\n  }\n}\n\nfunction collectAuthoringLeafPaths(\n  namespace: Readonly<Record<string, unknown>>,\n  isLeaf: (value: unknown) => boolean,\n  path: readonly string[] = [],\n): string[] {\n  const paths: string[] = [];\n  for (const [key, value] of Object.entries(namespace)) {\n    const currentPath = [...path, key];\n    if (isLeaf(value)) {\n      paths.push(currentPath.join('.'));\n      continue;\n    }\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      paths.push(\n        ...collectAuthoringLeafPaths(\n          value as Readonly<Record<string, unknown>>,\n          isLeaf,\n          currentPath,\n        ),\n      );\n    }\n  }\n  return paths;\n}\n\ninterface AuthoringLeafEntry {\n  readonly path: string;\n  readonly discriminator: string;\n}\n\nfunction collectAuthoringLeafDiscriminators(\n  namespace: Readonly<Record<string, unknown>>,\n  isLeaf: (value: unknown) => boolean,\n  label: string,\n  path: readonly string[] = [],\n): AuthoringLeafEntry[] {\n  const entries: AuthoringLeafEntry[] = [];\n  for (const [key, value] of Object.entries(namespace)) {\n    const currentPath = [...path, key];\n    if (isLeaf(value)) {\n      const record = blindCast<\n        Record<string, unknown>,\n        'discriminator extraction from a leaf already validated by isLeaf'\n      >(value);\n      const discriminator = record['discriminator'];\n      if (typeof discriminator === 'string' && discriminator.length > 0) {\n        entries.push({ path: currentPath.join('.'), discriminator });\n      }\n      continue;\n    }\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      const record = blindCast<\n        Readonly<Record<string, unknown>>,\n        'walker inspects a non-leaf value for descriptor-shaped keys before recursing'\n      >(value);\n      // A value carrying descriptor-shaped keys (`kind`/`keyword`/`discriminator`)\n      // but failing `isAuthoringPslBlockDescriptor` (e.g. missing `parameters`) is\n      // a malformed declarative descriptor. Descending into it as a sub-namespace\n      // would silently skip it, so a half-built contribution would pass validation.\n      // Reject it at load time instead, naming the path and what's wrong.\n      //\n      // A valid sub-namespace whose key happens to be named `kind`, `keyword`, or\n      // `discriminator` (but which does not look like a descriptor overall) must\n      // still descend normally — the check requires descriptor-shaped keys present\n      // AND the leaf guard rejecting it.\n      if (\n        (record['kind'] !== undefined ||\n          record['keyword'] !== undefined ||\n          record['discriminator'] !== undefined) &&\n        !isLeaf(value)\n      ) {\n        const hasKind = record['kind'] === 'pslBlock';\n        const hasKeyword = typeof record['keyword'] === 'string';\n        const hasDiscriminator = typeof record['discriminator'] === 'string';\n        if (hasKind || (hasKeyword && hasDiscriminator)) {\n          throw new Error(\n            `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          );\n        }\n      }\n      entries.push(...collectAuthoringLeafDiscriminators(record, isLeaf, label, currentPath));\n    }\n  }\n  return entries;\n}\n\n/**\n * Throws when two or more entries in the same namespace share a discriminator.\n * Duplicate discriminators within a namespace make dispatch ambiguous — the\n * lowering factory lookup dispatches by discriminator, so one would silently\n * shadow the other. Catch duplicates before building any dispatch map.\n */\nfunction assertUniqueDiscriminators(entries: readonly AuthoringLeafEntry[], label: string): void {\n  const seen = new Map<string, string>();\n  for (const { path, discriminator } of entries) {\n    const existing = seen.get(discriminator);\n    if (existing !== undefined) {\n      throw new Error(\n        `Duplicate ${label} discriminator \"${discriminator}\" registered at both \"${existing}\" and \"${path}\". Each ${label} contribution must use a unique discriminator.`,\n      );\n    }\n    seen.set(discriminator, path);\n  }\n}\n\n/**\n * Every `pslBlockDescriptors` entry needs a matching `entityTypes` factory\n * (same discriminator): the parser would otherwise produce an AST node\n * nothing can lower to an IR class instance. The link is one-directional\n * — an `entityTypes` factory may stand alone (e.g. `enum`, reachable from\n * the TypeScript builder without any PSL block).\n */\nfunction assertPslBlocksHaveFactories(\n  entityTypeNamespace: AuthoringEntityTypeNamespace,\n  pslBlockNamespace: AuthoringPslBlockDescriptorNamespace,\n): void {\n  const blockEntries = collectAuthoringLeafDiscriminators(\n    pslBlockNamespace,\n    isAuthoringPslBlockDescriptor,\n    'pslBlock',\n  );\n  const entityEntries = collectAuthoringLeafDiscriminators(\n    entityTypeNamespace,\n    isAuthoringEntityTypeDescriptor,\n    'entityType',\n  );\n\n  assertUniqueDiscriminators(blockEntries, 'pslBlock');\n  assertUniqueDiscriminators(entityEntries, 'entityType');\n\n  const entityDiscriminators = new Set(entityEntries.map((entry) => entry.discriminator));\n\n  for (const block of blockEntries) {\n    if (!entityDiscriminators.has(block.discriminator)) {\n      throw new Error(\n        `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      );\n    }\n  }\n}\n\nexport function assertNoCrossRegistryCollisions(\n  typeNamespace: AuthoringTypeNamespace,\n  fieldNamespace: AuthoringFieldNamespace,\n  entityTypeNamespace: AuthoringEntityTypeNamespace = {},\n  pslBlockNamespace: AuthoringPslBlockDescriptorNamespace = {},\n): void {\n  const typePaths = new Set(\n    collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),\n  );\n  const fieldPaths = new Set(\n    collectAuthoringLeafPaths(fieldNamespace, isAuthoringFieldPresetDescriptor),\n  );\n  const entityPaths = new Set(\n    collectAuthoringLeafPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor),\n  );\n  // Within-registry duplicate detection is handled upstream by the merge\n  // walker (`mergeAuthoringNamespaces` in control-stack.ts and\n  // `mergeHelperNamespaces` in composed-authoring-helpers.ts), which throws\n  // on same-path registrations within any single registry before this check\n  // runs. This function only handles the cross-registry case.\n  //\n  // Cross-registry collisions are checked among `type` / `field` /\n  // `entityTypes` only — these three are user-facing helper paths that PSL\n  // must resolve unambiguously. `pslBlockDescriptors` is an internal\n  // framework index consumed by parser and printer dispatch, not a\n  // user-facing helper path; the natural authoring pattern is the same\n  // path key in `entityTypes` and `pslBlockDescriptors` for a single\n  // contribution. The block→factory link is enforced by\n  // `assertPslBlocksHaveFactories` via the discriminator string, not by path.\n  const ambiguityHint =\n    'Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.';\n  for (const fieldPath of fieldPaths) {\n    if (typePaths.has(fieldPath)) {\n      throw new Error(\n        `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      );\n    }\n  }\n  for (const entityPath of entityPaths) {\n    if (typePaths.has(entityPath) || fieldPaths.has(entityPath)) {\n      throw new Error(\n        `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      );\n    }\n  }\n\n  assertPslBlocksHaveFactories(entityTypeNamespace, pslBlockNamespace);\n}\n\nexport function resolveAuthoringTemplateValue(\n  template: AuthoringTemplateValue,\n  args: readonly unknown[],\n): unknown {\n  if (isAuthoringArgRef(template)) {\n    let value = args[template.index];\n\n    for (const segment of template.path ?? []) {\n      if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) {\n        value = undefined;\n        break;\n      }\n      value = (value as Record<string, unknown>)[segment];\n    }\n\n    if (value === undefined && template.default !== undefined) {\n      return resolveAuthoringTemplateValue(template.default, args);\n    }\n\n    return value;\n  }\n  if (Array.isArray(template)) {\n    return template.map((value) => resolveAuthoringTemplateValue(value, args));\n  }\n  if (typeof template === 'object' && template !== null) {\n    const resolved: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(template)) {\n      const resolvedValue = resolveAuthoringTemplateValue(value, args);\n      if (resolvedValue !== undefined) {\n        resolved[key] = resolvedValue;\n      }\n    }\n    return resolved;\n  }\n  return template;\n}\n\nfunction validateAuthoringArgument(\n  descriptor: AuthoringArgumentDescriptor,\n  value: unknown,\n  path: string,\n): void {\n  if (value === undefined) {\n    if (descriptor.optional) {\n      return;\n    }\n    throw new Error(`Missing required authoring helper argument at ${path}`);\n  }\n\n  if (descriptor.kind === 'string') {\n    if (typeof value !== 'string') {\n      throw new Error(`Authoring helper argument at ${path} must be a string`);\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'boolean') {\n    if (typeof value !== 'boolean') {\n      throw new Error(`Authoring helper argument at ${path} must be a boolean`);\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'stringArray') {\n    if (!Array.isArray(value)) {\n      throw new Error(`Authoring helper argument at ${path} must be an array of strings`);\n    }\n    for (const entry of value) {\n      if (typeof entry !== 'string') {\n        throw new Error(`Authoring helper argument at ${path} must be an array of strings`);\n      }\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'object') {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n      throw new Error(`Authoring helper argument at ${path} must be an object`);\n    }\n\n    const input = value as Record<string, unknown>;\n    const expectedKeys = new Set(Object.keys(descriptor.properties));\n\n    for (const key of Object.keys(input)) {\n      if (!expectedKeys.has(key)) {\n        throw new Error(`Authoring helper argument at ${path} contains unknown property \"${key}\"`);\n      }\n    }\n\n    for (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) {\n      validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);\n    }\n\n    return;\n  }\n\n  if (typeof value !== 'number' || Number.isNaN(value)) {\n    throw new Error(`Authoring helper argument at ${path} must be a number`);\n  }\n\n  if (descriptor.integer && !Number.isInteger(value)) {\n    throw new Error(`Authoring helper argument at ${path} must be an integer`);\n  }\n  if (descriptor.minimum !== undefined && value < descriptor.minimum) {\n    throw new Error(\n      `Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`,\n    );\n  }\n  if (descriptor.maximum !== undefined && value > descriptor.maximum) {\n    throw new Error(\n      `Authoring helper argument at ${path} must be <= ${descriptor.maximum}, received ${value}`,\n    );\n  }\n}\n\nexport function validateAuthoringHelperArguments(\n  helperPath: string,\n  descriptors: readonly AuthoringArgumentDescriptor[] | undefined,\n  args: readonly unknown[],\n): void {\n  const expected = descriptors ?? [];\n  const minimumArgs = expected.reduce(\n    (count, descriptor, index) => (descriptor.optional ? count : index + 1),\n    0,\n  );\n  if (args.length < minimumArgs || args.length > expected.length) {\n    throw new Error(\n      `${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`,\n    );\n  }\n\n  expected.forEach((descriptor, index) => {\n    validateAuthoringArgument(descriptor, args[index], `${helperPath}[${index}]`);\n  });\n}\n\nfunction resolveAuthoringStorageTypeTemplate(\n  template: AuthoringStorageTypeTemplate,\n  args: readonly unknown[],\n): {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown>;\n} {\n  const nativeType = resolveAuthoringTemplateValue(template.nativeType, args);\n  if (typeof nativeType !== 'string') {\n    throw new Error(\n      `Resolved authoring nativeType must be a string for codec \"${template.codecId}\", received ${String(nativeType)}`,\n    );\n  }\n  const typeParams =\n    template.typeParams === undefined\n      ? undefined\n      : resolveAuthoringTemplateValue(template.typeParams, args);\n  if (typeParams !== undefined && !isAuthoringTemplateRecord(typeParams)) {\n    throw new Error(\n      `Resolved authoring typeParams must be an object for codec \"${template.codecId}\", received ${String(typeParams)}`,\n    );\n  }\n\n  return {\n    codecId: template.codecId,\n    nativeType,\n    ...(typeParams === undefined ? {} : { typeParams }),\n  };\n}\n\nfunction resolveAuthoringColumnDefaultTemplate(\n  template: AuthoringColumnDefaultTemplate,\n  args: readonly unknown[],\n): ColumnDefault {\n  if (template.kind === 'literal') {\n    const value = resolveAuthoringTemplateValue(template.value, args);\n    if (value === undefined) {\n      throw new Error('Resolved authoring literal default must not be undefined');\n    }\n    if (!isColumnDefaultLiteralInputValue(value)) {\n      throw new Error(\n        `Resolved authoring literal default must be a JSON-serializable value or Date, received ${String(value)}`,\n      );\n    }\n    return {\n      kind: 'literal',\n      value,\n    };\n  }\n\n  const expression = resolveAuthoringTemplateValue(template.expression, args);\n  if (expression === undefined || (typeof expression === 'object' && expression !== null)) {\n    throw new Error(\n      `Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`,\n    );\n  }\n  return {\n    kind: 'function',\n    expression: String(expression),\n  };\n}\n\nfunction resolveExecutionMutationDefaultPhase(\n  phase: 'onCreate' | 'onUpdate',\n  template: AuthoringTemplateValue,\n  args: readonly unknown[],\n): ExecutionMutationDefaultValue {\n  const value = resolveAuthoringTemplateValue(template, args);\n  if (!isExecutionMutationDefaultValue(value)) {\n    throw new Error(\n      `Authoring preset executionDefaults.${phase} did not resolve to a valid generator descriptor (kind: 'generator', id: string).`,\n    );\n  }\n  return value;\n}\n\nfunction resolveAuthoringExecutionDefaultsTemplate(\n  template: AuthoringExecutionDefaultsTemplate,\n  args: readonly unknown[],\n): ExecutionMutationDefaultPhases {\n  return {\n    ...ifDefined(\n      'onCreate',\n      template.onCreate !== undefined\n        ? resolveExecutionMutationDefaultPhase('onCreate', template.onCreate, args)\n        : undefined,\n    ),\n    ...ifDefined(\n      'onUpdate',\n      template.onUpdate !== undefined\n        ? resolveExecutionMutationDefaultPhase('onUpdate', template.onUpdate, args)\n        : undefined,\n    ),\n  };\n}\n\nexport function instantiateAuthoringTypeConstructor(\n  descriptor: AuthoringTypeConstructorDescriptor,\n  args: readonly unknown[],\n): {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown>;\n} {\n  return resolveAuthoringStorageTypeTemplate(descriptor.output, args);\n}\n\nexport function instantiateAuthoringEntityType(\n  helperPath: string,\n  descriptor: AuthoringEntityTypeDescriptor,\n  args: readonly unknown[],\n  ctx: AuthoringEntityContext,\n): unknown {\n  // Factory-output entities carry their input contract on the factory\n  // signature itself — TypeScript narrows callers via\n  // `EntityHelperFunction`'s extracted `input` parameter, and the factory\n  // is free to do its own runtime validation (e.g. arktype Type). The\n  // descriptor-level `args` validator is reserved for template-output\n  // entities (which mirror field/type's declarative argument shape).\n  if ('factory' in descriptor.output) {\n    const input = args[0];\n    // The base `AuthoringEntityTypeDescriptor`'s factory is typed\n    // `(input: never, ctx) => unknown` so concrete pack-literal factories\n    // with narrower input types remain assignable through the\n    // contravariant position (see the type's docstring). The runtime\n    // delegates input validation to the pack's factory itself, so we\n    // forward the supplied input here without a static input contract.\n    const factory = descriptor.output.factory as (\n      input: unknown,\n      ctx: AuthoringEntityContext,\n    ) => unknown;\n    return factory(input, ctx);\n  }\n  validateAuthoringHelperArguments(helperPath, descriptor.args, args);\n  return resolveAuthoringTemplateValue(descriptor.output.template, args);\n}\n\nexport function instantiateAuthoringFieldPreset(\n  descriptor: AuthoringFieldPresetDescriptor,\n  args: readonly unknown[],\n): {\n  readonly descriptor: {\n    readonly codecId: string;\n    readonly nativeType: string;\n    readonly typeParams?: Record<string, unknown>;\n  };\n  readonly nullable: boolean;\n  readonly default?: ColumnDefault;\n  readonly executionDefaults?: ExecutionMutationDefaultPhases;\n  readonly id: boolean;\n  readonly unique: boolean;\n} {\n  return {\n    descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),\n    nullable: descriptor.output.nullable ?? false,\n    ...ifDefined(\n      'default',\n      descriptor.output.default !== undefined\n        ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args)\n        : undefined,\n    ),\n    ...ifDefined(\n      'executionDefaults',\n      descriptor.output.executionDefaults !== undefined\n        ? resolveAuthoringExecutionDefaultsTemplate(descriptor.output.executionDefaults, args)\n        : undefined,\n    ),\n    id: descriptor.output.id ?? false,\n    unique: descriptor.output.unique ?? false,\n  };\n}\n"],"mappings":"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"}

package/dist/framework-authoring-R0TYCkvG.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-authoring-R0TYCkvG.d.mts","names":[],"sources":["../src/shared/psl-extension-block.ts","../src/shared/framework-authoring.ts"],"mappings":"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"}