@prisma-next/framework-components 0.5.0-dev.9 → 0.5.0

package/src/{framework-authoring.ts → shared/framework-authoring.ts}

@@ -1,3 +1,12 @@
+import type {
+  ColumnDefault,
+  ExecutionMutationDefaultPhases,
+  ExecutionMutationDefaultValue,
+} from '@prisma-next/contract/types';
+import {
+  isColumnDefaultLiteralInputValue,
+  isExecutionMutationDefaultValue,
+} from '@prisma-next/contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 
 export type AuthoringArgRef = {
@@ -24,6 +33,7 @@ interface AuthoringArgumentDescriptorCommon {
 export type AuthoringArgumentDescriptor = AuthoringArgumentDescriptorCommon &
   (
     | { readonly kind: 'string' }
+    | { readonly kind: 'boolean' }
     | {
         readonly kind: 'number';
         readonly integer?: boolean;
@@ -63,10 +73,15 @@ export type AuthoringColumnDefaultTemplate =
   | AuthoringColumnDefaultTemplateLiteral
   | AuthoringColumnDefaultTemplateFunction;
 
+export interface AuthoringExecutionDefaultsTemplate {
+  readonly onCreate?: AuthoringTemplateValue;
+  readonly onUpdate?: AuthoringTemplateValue;
+}
+
 export interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {
   readonly nullable?: boolean;
   readonly default?: AuthoringColumnDefaultTemplate;
-  readonly executionDefault?: AuthoringTemplateValue;
+  readonly executionDefaults?: AuthoringExecutionDefaultsTemplate;
   readonly id?: boolean;
   readonly unique?: boolean;
 }
@@ -132,6 +147,148 @@ export function isAuthoringFieldPresetDescriptor(
   );
 }
 
+/**
+ * Returns true when `namespace` is a non-leaf key in `contributions.field`.
+ *
+ * `AuthoringFieldNamespace` permits a leaf descriptor at any depth — including
+ * the root — so a top-level `field: { Foo: { kind: 'fieldPreset', ... } }`
+ * registration must NOT be treated as a "namespace" with sub-paths. Callers
+ * use this predicate to gate dot-namespaced lookups (e.g. PSL `@Foo.bar`).
+ */
+export function hasRegisteredFieldNamespace(
+  contributions: AuthoringContributions | undefined,
+  namespace: string,
+): boolean {
+  if (contributions?.field === undefined || !Object.hasOwn(contributions.field, namespace)) {
+    return false;
+  }
+  return !isAuthoringFieldPresetDescriptor(contributions.field[namespace]);
+}
+
+function isPlainNamespaceObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Merges `source` into `target` recursively at the descriptor-namespace
+ * level. `leafGuard` decides which values are descriptors (terminal
+ * merge points; same-path registrations across components are reported
+ * as duplicates) versus sub-namespaces (recursion targets).
+ *
+ * Path segments are validated against prototype-pollution names
+ * (`__proto__`, `constructor`, `prototype`). A value that is neither a
+ * recognized leaf nor a plain object — e.g. a malformed descriptor
+ * where the canonical leaf guard rejected it for missing `output` —
+ * is reported as an invalid contribution rather than recursed into,
+ * which would either silently mangle state or infinite-loop on
+ * primitive properties.
+ *
+ * Within-registry duplicate detection is this walker's job;
+ * cross-registry detection runs separately via
+ * `assertNoCrossRegistryCollisions` after merging completes.
+ */
+export function mergeAuthoringNamespaces(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+  path: readonly string[],
+  leafGuard: (value: unknown) => boolean,
+  label: string,
+): void {
+  const assertSafePath = (currentPath: readonly string[]) => {
+    const blockedSegment = currentPath.find(
+      (segment) => segment === '__proto__' || segment === 'constructor' || segment === 'prototype',
+    );
+    if (blockedSegment) {
+      throw new Error(
+        `Invalid authoring ${label} helper "${currentPath.join('.')}". Helper path segments must not use "${blockedSegment}".`,
+      );
+    }
+  };
+
+  for (const [key, sourceValue] of Object.entries(source)) {
+    const currentPath = [...path, key];
+    assertSafePath(currentPath);
+    const hasExistingValue = Object.hasOwn(target, key);
+    const existingValue = hasExistingValue ? target[key] : undefined;
+
+    if (!hasExistingValue) {
+      target[key] = sourceValue;
+      continue;
+    }
+
+    const existingIsLeaf = leafGuard(existingValue);
+    const sourceIsLeaf = leafGuard(sourceValue);
+
+    if (existingIsLeaf || sourceIsLeaf) {
+      throw new Error(
+        `Duplicate authoring ${label} helper "${currentPath.join('.')}". Helper names must be unique across composed packs.`,
+      );
+    }
+
+    if (!isPlainNamespaceObject(existingValue) || !isPlainNamespaceObject(sourceValue)) {
+      throw new Error(
+        `Invalid authoring ${label} helper "${currentPath.join('.')}". Expected a sub-namespace object or a recognized descriptor; received a malformed value.`,
+      );
+    }
+
+    mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, leafGuard, label);
+  }
+}
+
+function collectAuthoringLeafPaths(
+  namespace: Readonly<Record<string, unknown>>,
+  isLeaf: (value: unknown) => boolean,
+  path: readonly string[] = [],
+): string[] {
+  const paths: string[] = [];
+  for (const [key, value] of Object.entries(namespace)) {
+    const currentPath = [...path, key];
+    if (isLeaf(value)) {
+      paths.push(currentPath.join('.'));
+      continue;
+    }
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      paths.push(
+        ...collectAuthoringLeafPaths(
+          value as Readonly<Record<string, unknown>>,
+          isLeaf,
+          currentPath,
+        ),
+      );
+    }
+  }
+  return paths;
+}
+
+export function assertNoCrossRegistryCollisions(
+  typeNamespace: AuthoringTypeNamespace,
+  fieldNamespace: AuthoringFieldNamespace,
+): void {
+  const typePaths = new Set(
+    collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),
+  );
+  // Within-registry duplicate detection is handled upstream by the merge
+  // walker (`mergeAuthoringNamespaces` in control-stack.ts and
+  // `mergeHelperNamespaces` in composed-authoring-helpers.ts), which throws
+  // on same-path registrations within either registry before this check
+  // runs. This function only handles the cross-registry case — and an
+  // empty type namespace makes a cross-registry collision structurally
+  // impossible, so the early-out is sound.
+  if (typePaths.size === 0) {
+    return;
+  }
+  for (const fieldPath of collectAuthoringLeafPaths(
+    fieldNamespace,
+    isAuthoringFieldPresetDescriptor,
+  )) {
+    if (typePaths.has(fieldPath)) {
+      throw new Error(
+        `Ambiguous authoring registry path "${fieldPath}". The same path is registered as both a type constructor and a field preset; PSL resolution would be ambiguous. Register each path in only one of authoringContributions.field / authoringContributions.type.`,
+      );
+    }
+  }
+}
+
 export function resolveAuthoringTemplateValue(
   template: AuthoringTemplateValue,
   args: readonly unknown[],
@@ -188,6 +345,13 @@ function validateAuthoringArgument(
     return;
   }
 
+  if (descriptor.kind === 'boolean') {
+    if (typeof value !== 'boolean') {
+      throw new Error(`Authoring helper argument at ${path} must be a boolean`);
+    }
+    return;
+  }
+
   if (descriptor.kind === 'stringArray') {
     if (!Array.isArray(value)) {
       throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
@@ -295,20 +459,17 @@ function resolveAuthoringStorageTypeTemplate(
 function resolveAuthoringColumnDefaultTemplate(
   template: AuthoringColumnDefaultTemplate,
   args: readonly unknown[],
-):
-  | {
-      readonly kind: 'literal';
-      readonly value: unknown;
-    }
-  | {
-      readonly kind: 'function';
-      readonly expression: string;
-    } {
+): ColumnDefault {
   if (template.kind === 'literal') {
     const value = resolveAuthoringTemplateValue(template.value, args);
     if (value === undefined) {
       throw new Error('Resolved authoring literal default must not be undefined');
     }
+    if (!isColumnDefaultLiteralInputValue(value)) {
+      throw new Error(
+        `Resolved authoring literal default must be a JSON-serializable value or Date, received ${String(value)}`,
+      );
+    }
     return {
       kind: 'literal',
       value,
@@ -327,6 +488,40 @@ function resolveAuthoringColumnDefaultTemplate(
   };
 }
 
+function resolveExecutionMutationDefaultPhase(
+  phase: 'onCreate' | 'onUpdate',
+  template: AuthoringTemplateValue,
+  args: readonly unknown[],
+): ExecutionMutationDefaultValue {
+  const value = resolveAuthoringTemplateValue(template, args);
+  if (!isExecutionMutationDefaultValue(value)) {
+    throw new Error(
+      `Authoring preset executionDefaults.${phase} did not resolve to a valid generator descriptor (kind: 'generator', id: string).`,
+    );
+  }
+  return value;
+}
+
+function resolveAuthoringExecutionDefaultsTemplate(
+  template: AuthoringExecutionDefaultsTemplate,
+  args: readonly unknown[],
+): ExecutionMutationDefaultPhases {
+  return {
+    ...ifDefined(
+      'onCreate',
+      template.onCreate !== undefined
+        ? resolveExecutionMutationDefaultPhase('onCreate', template.onCreate, args)
+        : undefined,
+    ),
+    ...ifDefined(
+      'onUpdate',
+      template.onUpdate !== undefined
+        ? resolveExecutionMutationDefaultPhase('onUpdate', template.onUpdate, args)
+        : undefined,
+    ),
+  };
+}
+
 export function instantiateAuthoringTypeConstructor(
   descriptor: AuthoringTypeConstructorDescriptor,
   args: readonly unknown[],
@@ -348,16 +543,8 @@ export function instantiateAuthoringFieldPreset(
     readonly typeParams?: Record<string, unknown>;
   };
   readonly nullable: boolean;
-  readonly default?:
-    | {
-        readonly kind: 'literal';
-        readonly value: unknown;
-      }
-    | {
-        readonly kind: 'function';
-        readonly expression: string;
-      };
-  readonly executionDefault?: unknown;
+  readonly default?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
   readonly id: boolean;
   readonly unique: boolean;
 } {
@@ -371,9 +558,9 @@ export function instantiateAuthoringFieldPreset(
         : undefined,
     ),
     ...ifDefined(
-      'executionDefault',
-      descriptor.output.executionDefault !== undefined
-        ? resolveAuthoringTemplateValue(descriptor.output.executionDefault, args)
+      'executionDefaults',
+      descriptor.output.executionDefaults !== undefined
+        ? resolveAuthoringExecutionDefaultsTemplate(descriptor.output.executionDefaults, args)
         : undefined,
     ),
     id: descriptor.output.id ?? false,

package/src/{framework-components.ts → shared/framework-components.ts}

@@ -1,4 +1,4 @@
-import type { Codec } from './codec-types';
+import type { AnyCodecDescriptor } from './codec-descriptor';
 import type { AuthoringContributions } from './framework-authoring';
 import type { ControlMutationDefaults } from './mutation-default-types';
 import type { TypesImportSpec } from './types-import-spec';
@@ -13,10 +13,7 @@ export interface ComponentMetadata {
   /**
    * Capabilities this component provides.
    *
-   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into
-   * the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`);
-   * keep these declarations in sync. Targets are identifiers/descriptors and typically do not
-   * declare capabilities.
+   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`); keep these declarations in sync. Targets are identifiers/descriptors and typically do not declare capabilities.
    */
   readonly capabilities?: Record<string, unknown>;
 
@@ -24,31 +21,26 @@ export interface ComponentMetadata {
   readonly types?: {
     readonly codecTypes?: {
       /**
-       * Base codec types import spec.
-       * Optional: adapters typically provide this, extensions usually don't.
+       * Base codec types import spec. Optional: adapters typically provide this, extensions usually don't.
        */
       readonly import?: TypesImportSpec;
       /**
        * Additional type-only imports for parameterized codec branded types.
        *
-       * These imports are included in generated `contract.d.ts` but are NOT treated as
-       * codec type maps (i.e., they should not be intersected into `export type CodecTypes = ...`).
+       * These imports are included in generated `contract.d.ts` but are NOT treated as codec type maps (i.e., they should not be intersected into `export type CodecTypes = ...`).
        *
        * Example: `Vector<N>` for pgvector codecs that emit `Vector<1536>`
        */
       readonly typeImports?: ReadonlyArray<TypesImportSpec>;
       /**
-       * Optional control-plane hooks keyed by codecId.
-       * Used by family-specific planners/verifiers to handle storage types.
+       * Optional control-plane hooks keyed by codecId. Used by family-specific planners/verifiers to handle storage types.
        */
       readonly controlPlaneHooks?: Record<string, unknown>;
       /**
-       * Codec instances contributed by this component.
-       * Used to build a CodecLookup for codec-dispatched type rendering during emission.
+       * Codec descriptors contributed by this component. Source of truth for codec-id-keyed metadata (`traits`, `targetTypes`, `meta`, `renderOutputType`) consumed by `extractCodecLookup`, and used to materialize representative `Codec` instances for codec-dispatched type rendering during emission.
        */
-      readonly codecInstances?: ReadonlyArray<Codec>;
+      readonly codecDescriptors?: ReadonlyArray<AnyCodecDescriptor>;
     };
-    readonly operationTypes?: { readonly import: TypesImportSpec };
     readonly queryOperationTypes?: { readonly import: TypesImportSpec };
     readonly storage?: ReadonlyArray<{
       readonly typeId: string;
@@ -61,21 +53,17 @@ export interface ComponentMetadata {
   /**
    * Optional pure-data authoring contributions exposed by this component.
    *
-   * These contributions are safe to include on pack refs and descriptors because
-   * they contain only declarative metadata. Higher-level authoring packages may
-   * project them into concrete helper functions for TS-first workflows.
+   * These contributions are safe to include on pack refs and descriptors because they contain only declarative metadata. Higher-level authoring packages may project them into concrete helper functions for TS-first workflows.
    */
   readonly authoring?: AuthoringContributions;
 
   /**
-   * Scalar type name to codec ID mapping contributed by this component.
-   * Assembled by `createControlStack` with duplicate detection.
+   * Scalar type name to codec ID mapping contributed by this component. Assembled by `createControlStack` with duplicate detection.
    */
   readonly scalarTypeDescriptors?: ReadonlyMap<string, string>;
 
   /**
-   * Mutation default function handlers and generator descriptors contributed
-   * by this component. Assembled by `createControlStack` with duplicate detection.
+   * Mutation default function handlers and generator descriptors contributed by this component. Assembled by `createControlStack` with duplicate detection.
    */
   readonly controlMutationDefaults?: ControlMutationDefaults;
 }
@@ -83,13 +71,9 @@ export interface ComponentMetadata {
 /**
  * Base descriptor for any framework component.
  *
- * All component descriptors share these fundamental properties that identify
- * the component and provide its metadata. This interface is extended by
- * specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).
+ * All component descriptors share these fundamental properties that identify the component and provide its metadata. This interface is extended by specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).
  *
- * @template Kind - Discriminator literal identifying the component type.
- *   Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension',
- *   but the type accepts any string to allow ecosystem extensions.
+ * @template Kind - Discriminator literal identifying the component type. Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension', but the type accepts any string to allow ecosystem extensions.
  *
  * @example
  * ```ts
@@ -163,14 +147,12 @@ export function checkContractComponentRequirements(
 /**
  * Descriptor for a family component.
  *
- * A "family" represents a category of data sources with shared semantics
- * (e.g., SQL databases, document stores). Families define:
+ * A "family" represents a category of data sources with shared semantics (e.g., SQL databases, document stores). Families define:
  * - Query semantics and operations (SELECT, INSERT, find, aggregate, etc.)
  * - Contract structure (tables vs collections, columns vs fields)
  * - Type system and codecs
  *
- * Families are the top-level grouping. Each family contains multiple targets
- * (e.g., SQL family contains Postgres, MySQL, SQLite targets).
+ * Families are the top-level grouping. Each family contains multiple targets (e.g., SQL family contains Postgres, MySQL, SQLite targets).
  *
  * Extended by plane-specific descriptors:
  * - `ControlFamilyDescriptor` - adds `emission` for CLI/tooling operations
@@ -195,13 +177,11 @@ export interface FamilyDescriptor<TFamilyId extends string> extends ComponentDes
 /**
  * Descriptor for a target component.
  *
- * A "target" represents a specific database or data store within a family
- * (e.g., Postgres, MySQL, MongoDB). Targets define:
+ * A "target" represents a specific database or data store within a family (e.g., Postgres, MySQL, MongoDB). Targets define:
  * - Native type mappings (e.g., Postgres int4 → TypeScript number)
  * - Target-specific capabilities (e.g., RETURNING, LATERAL joins)
  *
- * Targets are bound to a family and provide the target-specific implementation
- * details that adapters and drivers use.
+ * Targets are bound to a family and provide the target-specific implementation details that adapters and drivers use.
  *
  * Extended by plane-specific descriptors:
  * - `ControlTargetDescriptor` - adds optional `migrations` capability
@@ -229,8 +209,7 @@ export interface TargetDescriptor<TFamilyId extends string, TTargetId extends st
 }
 
 /**
- * Base shape for any pack reference.
- * Pack refs are pure JSON-friendly objects safe to import in authoring flows.
+ * Base shape for any pack reference. Pack refs are pure JSON-friendly objects safe to import in authoring flows.
  */
 export interface PackRefBase<Kind extends string, TFamilyId extends string>
   extends ComponentMetadata {
@@ -274,14 +253,12 @@ export type DriverPackRef<
 /**
  * Descriptor for an adapter component.
  *
- * An "adapter" provides the protocol and dialect implementation for a target.
- * Adapters handle:
+ * An "adapter" provides the protocol and dialect implementation for a target. Adapters handle:
  * - SQL/query generation (lowering AST to target-specific syntax)
  * - Codec registration (encoding/decoding between JS and wire types)
  * - Type mappings and coercions
  *
- * Adapters are bound to a specific family+target combination and work with
- * any compatible driver for that target.
+ * Adapters are bound to a specific family+target combination and work with any compatible driver for that target.
  *
  * Extended by plane-specific descriptors:
  * - `ControlAdapterDescriptor` - control-plane factory
@@ -311,16 +288,13 @@ export interface AdapterDescriptor<TFamilyId extends string, TTargetId extends s
 /**
  * Descriptor for a driver component.
  *
- * A "driver" provides the connection and execution layer for a target.
- * Drivers handle:
+ * A "driver" provides the connection and execution layer for a target. Drivers handle:
  * - Connection management (pooling, timeouts, retries)
  * - Query execution (sending SQL/commands, receiving results)
  * - Transaction management
  * - Wire protocol communication
  *
- * Drivers are bound to a specific family+target and work with any compatible
- * adapter. Multiple drivers can exist for the same target (e.g., node-postgres
- * vs postgres.js for Postgres).
+ * Drivers are bound to a specific family+target and work with any compatible adapter. Multiple drivers can exist for the same target (e.g., node-postgres vs postgres.js for Postgres).
  *
  * Extended by plane-specific descriptors:
  * - `ControlDriverDescriptor` - creates driver from connection URL
@@ -355,8 +329,7 @@ export interface DriverDescriptor<TFamilyId extends string, TTargetId extends st
  * - Custom types and codecs (e.g., vector type)
  * - Extended query capabilities
  *
- * Extensions are bound to a specific family+target and are registered in the
- * config alongside the core components. Multiple extensions can be used together.
+ * Extensions are bound to a specific family+target and are registered in the config alongside the core components. Multiple extensions can be used together.
  *
  * Extended by plane-specific descriptors:
  * - `ControlExtensionDescriptor` - control-plane extension factory

package/src/{mutation-default-types.ts → shared/mutation-default-types.ts}

@@ -1,4 +1,8 @@
-import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  ExecutionMutationDefaultPhases,
+  ExecutionMutationDefaultValue,
+} from '@prisma-next/contract/types';
 
 interface SourcePosition {
   readonly offset: number;
@@ -60,7 +64,16 @@ export type DefaultFunctionRegistry = ReadonlyMap<string, DefaultFunctionRegistr
 
 export interface MutationDefaultGeneratorDescriptor {
   readonly id: string;
-  readonly applicableCodecIds: readonly string[];
+  /**
+   * Codec ids the generator is compatible with when the codec choice
+   * and the generator choice are made independently by the contract
+   * author. Set when the registry-coherence check is meaningful
+   * (the codec and the generator can be paired arbitrarily by the
+   * caller); omitted when the generator is only reachable through a
+   * descriptor that co-registers a fixed codec, so coherence is
+   * structural and the list would be tautological.
+   */
+  readonly applicableCodecIds?: readonly string[];
   readonly resolveGeneratedColumnDescriptor?: (input: {
     readonly generated: ExecutionMutationDefaultValue;
   }) =>
@@ -71,6 +84,13 @@ export interface MutationDefaultGeneratorDescriptor {
         readonly typeParams?: Record<string, unknown>;
       }
     | undefined;
+  /**
+   * Construct the `onCreate`/`onUpdate` phases value owned by this
+   * generator. Authoring layers (PSL `temporal.updatedAt()`, TS field presets) call
+   * this instead of building the literal inline so PSL/TS-authored
+   * contracts stay byte-equivalent for any future params-bearing generator.
+   */
+  readonly buildPhases?: (args?: Record<string, unknown>) => ExecutionMutationDefaultPhases;
 }
 
 export interface ControlMutationDefaultEntry {

package/dist/authoring.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"authoring.mjs","names":["resolved: Record<string, unknown>"],"sources":["../src/framework-authoring.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\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    | {\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 AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {\n  readonly nullable?: boolean;\n  readonly default?: AuthoringColumnDefaultTemplate;\n  readonly executionDefault?: AuthoringTemplateValue;\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\nexport interface AuthoringContributions {\n  readonly type?: AuthoringTypeNamespace;\n  readonly field?: AuthoringFieldNamespace;\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 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 === '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):\n  | {\n      readonly kind: 'literal';\n      readonly value: unknown;\n    }\n  | {\n      readonly kind: 'function';\n      readonly expression: string;\n    } {\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    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\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 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?:\n    | {\n        readonly kind: 'literal';\n        readonly value: unknown;\n      }\n    | {\n        readonly kind: 'function';\n        readonly expression: string;\n      };\n  readonly executionDefault?: unknown;\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      'executionDefault',\n      descriptor.output.executionDefault !== undefined\n        ? resolveAuthoringTemplateValue(descriptor.output.executionDefault, 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/codec-types-DQ1Agjom.d.mts

@@ -1,58 +0,0 @@
-import { JsonValue } from "@prisma-next/contract/types";
-
-//#region src/codec-types.d.ts
-type CodecTrait = 'equality' | 'order' | 'boolean' | 'numeric' | 'textual';
-/**
- * A codec is the contract between an application value and its on-wire and
- * on-contract-disk representations.
- *
- * The author's mental model is two JS-side types — `TInput` (the
- * application JS type) and `TWire` (the database driver wire format) —
- * plus `JsonValue` for build-time contract artifacts. The codec translates
- * `TInput` to `TWire` on writes and back on reads, and to/from `JsonValue`
- * during contract emission and loading.
- *
- * Three representations participate:
- * - **Input** (`TInput`): the JS type at the application boundary.
- * - **Wire** (`TWire`): the format exchanged with the database driver.
- * - **JSON** (`JsonValue`): a JSON-safe form used in contract artifacts.
- *
- * Codec methods split into two groups:
- *
- * - **Query-time** methods (`encode`, `decode`) run per row/parameter at the
- *   IO boundary; they are required and Promise-returning. The per-family
- *   codec factory accepts sync or async author functions and lifts sync
- *   ones to Promise-shaped methods automatically.
- * - **Build-time** methods (`encodeJson`, `decodeJson`, `renderOutputType`)
- *   run when the contract is serialized, loaded, or when client types are
- *   emitted. They stay synchronous so contract validation and client
- *   construction are synchronous.
- *
- * Target-family codec interfaces extend this base with target-shaped
- * metadata.
- */
-interface Codec<Id extends string = string, TTraits extends readonly CodecTrait[] = readonly CodecTrait[], TWire = unknown, TInput = unknown> {
-  /** Unique codec identifier in `namespace/name@version` format (e.g. `pg/timestamptz@1`). */
-  readonly id: Id;
-  /** Database-native type names this codec handles (e.g. `['timestamptz']`). */
-  readonly targetTypes: readonly string[];
-  /** Semantic traits for operator gating (e.g. equality, order, numeric). */
-  readonly traits?: TTraits;
-  /** Converts a JS value to the wire format expected by the database driver. Always Promise-returning at the boundary. */
-  encode(value: TInput): Promise<TWire>;
-  /** Converts a wire value from the database driver into the JS application type. Always Promise-returning at the boundary. */
-  decode(wire: TWire): Promise<TInput>;
-  /** Converts a JS value to a JSON-safe representation for contract serialization. Synchronous; called during contract emission. */
-  encodeJson(value: TInput): JsonValue;
-  /** Converts a JSON representation back to the JS input type. Synchronous; called during contract loading via `validateContract`. */
-  decodeJson(json: JsonValue): TInput;
-  /** Produces the TypeScript output type expression for a field given its `typeParams`. Synchronous; used during contract.d.ts emission. */
-  renderOutputType?(typeParams: Record<string, unknown>): string | undefined;
-}
-interface CodecLookup {
-  get(id: string): Codec | undefined;
-}
-declare const emptyCodecLookup: CodecLookup;
-//#endregion
-export { emptyCodecLookup as i, CodecLookup as n, CodecTrait as r, Codec as t };
-//# sourceMappingURL=codec-types-DQ1Agjom.d.mts.map

package/dist/codec-types-DQ1Agjom.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-DQ1Agjom.d.mts","names":[],"sources":["../src/codec-types.ts"],"sourcesContent":[],"mappings":";;;KAEY,UAAA;;AAAZ;AA+BA;;;;;;;;;;;;;;;;;AAwBA;AAIA;;;;;;;;;UA5BiB,2DAEU,wBAAwB;;eAKpC;;;;oBAIK;;gBAEJ,SAAS,QAAQ;;eAElB,QAAQ,QAAQ;;oBAEX,SAAS;;mBAEV,YAAY;;gCAEC;;UAGf,WAAA;mBACE;;cAGN,kBAAkB"}

package/dist/emission-types-BPAALJbF.d.mts

@@ -1,24 +0,0 @@
-import { t as TypesImportSpec } from "./types-import-spec-C4sc7wbb.mjs";
-import { Contract, ContractModel } from "@prisma-next/contract/types";
-
-//#region src/emission-types.d.ts
-interface GenerateContractTypesOptions {
-  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;
-}
-interface ValidationContext {
-  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
-  readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
-  readonly extensionIds?: ReadonlyArray<string>;
-}
-interface EmissionSpi {
-  readonly id: string;
-  generateStorageType(contract: Contract, storageHashTypeName: string): string;
-  generateModelStorageType(modelName: string, model: ContractModel): string;
-  getFamilyImports(): string[];
-  getFamilyTypeAliases(options?: GenerateContractTypesOptions): string;
-  getTypeMapsExpression(): string;
-  getContractWrapper(contractBaseName: string, typeMapsName: string): string;
-}
-//#endregion
-export { GenerateContractTypesOptions as n, ValidationContext as r, EmissionSpi as t };
-//# sourceMappingURL=emission-types-BPAALJbF.d.mts.map

package/dist/emission-types-BPAALJbF.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emission-types-BPAALJbF.d.mts","names":[],"sources":["../src/emission-types.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,4BAAA;uCACsB,cAAc;AADrD;AAIiB,UAAA,iBAAA,CAAiB;EACU,SAAA,gBAAA,CAAA,EAAd,aAAc,CAAA,eAAA,CAAA;EAAd,SAAA,oBAAA,CAAA,EACI,aADJ,CACkB,eADlB,CAAA;EACkB,SAAA,YAAA,CAAA,EACtB,aADsB,CAAA,MAAA,CAAA;;AACtB,UAGT,WAAA,CAHS;EAAa,SAAA,EAAA,EAAA,MAAA;EAGtB,mBAAW,CAAA,QAAA,EAGI,QAHJ,EAAA,mBAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAGI,wBAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,EAEqB,aAFrB,CAAA,EAAA,MAAA;EAEqB,gBAAA,EAAA,EAAA,MAAA,EAAA;EAIpB,oBAAA,CAAA,OAAA,CAAA,EAAA,4BAAA,CAAA,EAAA,MAAA;EAA4B,qBAAA,EAAA,EAAA,MAAA"}

package/dist/framework-authoring-D1-JZ37B.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-authoring-D1-JZ37B.d.mts","names":[],"sources":["../src/framework-authoring.ts"],"sourcesContent":[],"mappings":";KAEY,eAAA;EAAA,SAAA,IAAA,EAAA,KAAe;EAOf,SAAA,KAAA,EAAA,MAAA;EAKR,SAAA,IAAA,CAAA,EAAA,SAAA,MAAA,EAAA;EACS,SAAA,OAAA,CAAA,EATQ,sBASR;CACiB;AAAsB,KAPxC,sBAAA,GAOwC,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,GAFhD,eAEgD,GAAA,SADvC,sBACuC,EAAA,GAAA;EAE1C,UAAA,GAAA,EAAA,MAAA,CAAA,EAFoB,sBAEa;AAK3C,CAAA;UALU,iCAAA,CAKgC;EAYE,SAAA,IAAA,CAAA,EAAA,MAAA;EAAf,SAAA,QAAA,CAAA,EAAA,OAAA;;AAIZ,KAhBL,2BAAA,GAA8B,iCAgBG,GAAA,CAAA;EAEtB,SAAA,IAAA,EAAA,QAAA;CACgB,GAAA;EAAf,SAAA,IAAA,EAAA,QAAA;EAAM,SAAA,OAAA,CAAA,EAAA,OAAA;EAGb,SAAA,OAAA,CAAA,EAAA,MAAA;EAMA,SAAA,OAAA,CAAA,EAAA,MAAA;AAKjB,CAAA,GAAiB;EAKL,SAAA,IAAA,EAAA,aAAA;AAIZ,CAAA,GAAiB;EAEI,SAAA,IAAA,EAAA,QAAA;EACS,SAAA,UAAA,EAjCD,MAiCC,CAAA,MAAA,EAjCc,2BAiCd,CAAA;CAHsB,CAAA;AAA4B,UA1B/D,4BAAA,CA0B+D;EAQ/D,SAAA,OAAA,EAAA,MAAA;EAML,SAAA,UAAA,EAtCW,sBAuCI;EAGf,SAAA,UAAA,CAAA,EAzCY,MAyCW,CAAA,MAAA,EAzCI,sBA0CZ,CAAA;AAG3B;AAKgB,UA/CC,kCAAA,CA+C2C;EAkB5C,SAAA,IAAA,EAAA,iBAAA;EAYA,SAAA,IAAA,CAAA,EAAA,SA3EW,2BA6Ef,EAAA;EAUI,SAAA,MAAA,EAtFG,4BAuFP;AA2GZ;AAuFgB,UAtRC,qCAAA,CAuRH;EAUE,SAAA,IAAA,EAAA,SAAA;kBA/RE;;UAGD,sCAAA;;uBAEM;;KAGX,8BAAA,GACR,wCACA;UAEa,0BAAA,SAAmC;;qBAE/B;8BACS;;;;UAKb,8BAAA;;2BAEU;mBACR;;KAGP,sBAAA;2BACe,qCAAqC;;KAGpD,uBAAA;2BACe,iCAAiC;;UAG3C,sBAAA;kBACC;mBACC;;iBAGH,iBAAA,2BAA4C;iBAkB5C,oCAAA,2BAEJ;iBAUI,gCAAA,2BAEJ;iBAUI,6BAAA,WACJ;iBA2GI,gCAAA,2CAEQ;iBAqFR,mCAAA,aACF;;;wBAKU;;iBAKR,+BAAA,aACF;;;;0BAMY"}