@prisma-next/framework-components 0.7.0 → 0.8.0-dev.1

package/dist/{framework-authoring-DxXcjyJX.mjs → framework-authoring-DcEZ5Lin.mjs}

@@ -17,6 +17,16 @@ function isAuthoringTypeConstructorDescriptor(value) {
 function isAuthoringFieldPresetDescriptor(value) {
 	return typeof value === "object" && value !== null && value.kind === "fieldPreset" && typeof value.output === "object" && value.output !== null;
 }
+function isAuthoringEntityTypeDescriptor(value) {
+	if (typeof value !== "object" || value === null || value.kind !== "entity") return false;
+	const discriminator = value.discriminator;
+	if (typeof discriminator !== "string" || discriminator.length === 0) return false;
+	const output = value.output;
+	if (typeof output !== "object" || output === null) return false;
+	const factory = output.factory;
+	const template = output.template;
+	return typeof factory === "function" || template !== void 0;
+}
 /**
 * Returns true when `namespace` is a non-leaf key in `contributions.field`.
 *
@@ -83,10 +93,12 @@ function collectAuthoringLeafPaths(namespace, isLeaf, path = []) {
 	}
 	return paths;
 }
-function assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace) {
+function assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace = {}) {
 	const typePaths = new Set(collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor));
-	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.`);
+	const fieldPaths = new Set(collectAuthoringLeafPaths(fieldNamespace, isAuthoringFieldPresetDescriptor));
+	const entityPaths = new Set(collectAuthoringLeafPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor));
+	for (const fieldPath of fieldPaths) 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 / authoringContributions.entityTypes.`);
+	for (const entityPath of entityPaths) if (typePaths.has(entityPath) || fieldPaths.has(entityPath)) throw new Error(`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. Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.`);
 }
 function resolveAuthoringTemplateValue(template, args) {
 	if (isAuthoringArgRef(template)) {
@@ -193,6 +205,15 @@ function resolveAuthoringExecutionDefaultsTemplate(template, args) {
 function instantiateAuthoringTypeConstructor(descriptor, args) {
 	return resolveAuthoringStorageTypeTemplate(descriptor.output, args);
 }
+function instantiateAuthoringEntityType(helperPath, descriptor, args, ctx) {
+	if ("factory" in descriptor.output) {
+		const input = args[0];
+		const factory = descriptor.output.factory;
+		return factory(input, ctx);
+	}
+	validateAuthoringHelperArguments(helperPath, descriptor.args, args);
+	return resolveAuthoringTemplateValue(descriptor.output.template, args);
+}
 function instantiateAuthoringFieldPreset(descriptor, args) {
 	return {
 		descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),
@@ -204,6 +225,6 @@ function instantiateAuthoringFieldPreset(descriptor, args) {
 	};
 }
 //#endregion
-export { isAuthoringArgRef as a, mergeAuthoringNamespaces as c, instantiateAuthoringTypeConstructor as i, resolveAuthoringTemplateValue as l, hasRegisteredFieldNamespace as n, isAuthoringFieldPresetDescriptor as o, instantiateAuthoringFieldPreset as r, isAuthoringTypeConstructorDescriptor as s, assertNoCrossRegistryCollisions as t, validateAuthoringHelperArguments as u };
+export { instantiateAuthoringTypeConstructor as a, isAuthoringFieldPresetDescriptor as c, resolveAuthoringTemplateValue as d, validateAuthoringHelperArguments as f, instantiateAuthoringFieldPreset as i, isAuthoringTypeConstructorDescriptor as l, hasRegisteredFieldNamespace as n, isAuthoringArgRef as o, instantiateAuthoringEntityType as r, isAuthoringEntityTypeDescriptor as s, assertNoCrossRegistryCollisions as t, mergeAuthoringNamespaces as u };
 
-//# sourceMappingURL=framework-authoring-DxXcjyJX.mjs.map
+//# sourceMappingURL=framework-authoring-DcEZ5Lin.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"framework-authoring-DcEZ5Lin.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 { 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    | { 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\nexport type AuthoringEntityTypeNamespace = {\n  readonly [name: string]: AuthoringEntityTypeDescriptor | AuthoringEntityTypeNamespace;\n};\n\nexport interface AuthoringContributions {\n  readonly type?: AuthoringTypeNamespace;\n  readonly field?: AuthoringFieldNamespace;\n  readonly entityTypes?: AuthoringEntityTypeNamespace;\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\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\nexport function assertNoCrossRegistryCollisions(\n  typeNamespace: AuthoringTypeNamespace,\n  fieldNamespace: AuthoringFieldNamespace,\n  entityTypeNamespace: AuthoringEntityTypeNamespace = {},\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  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. Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.`,\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. Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.`,\n      );\n    }\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 === '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-components-DwkHnl-e.d.mts → framework-components-DQRRmQOH.d.mts}

@@ -1,4 +1,4 @@
-import { i as AuthoringContributions } from "./framework-authoring-DGIQbNPt.mjs";
+import { i as AuthoringContributions } from "./framework-authoring-Bb_GEnzj.mjs";
 import { r as AnyCodecDescriptor } from "./codec-DcjlJbcO.mjs";
 import { t as TypesImportSpec } from "./types-import-spec-BxI5cSQy.mjs";
 import { ColumnDefault, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue } from "@prisma-next/contract/types";
@@ -408,4 +408,4 @@ interface ExtensionInstance<TFamilyId extends string, TTargetId extends string>
 }
 //#endregion
 export { LoweredDefaultResult as A, ControlMutationDefaultEntry as C, DefaultFunctionLoweringHandler as D, DefaultFunctionLoweringContext as E, SourceSpan as F, MutationDefaultGeneratorDescriptor as M, ParsedDefaultFunctionCall as N, DefaultFunctionRegistry as O, SourceDiagnostic as P, checkContractComponentRequirements as S, ControlMutationDefaults as T, PackRefBase as _, ComponentMetadata as a, TargetInstance as b, DriverDescriptor as c, ExtensionDescriptor as d, ExtensionInstance as f, FamilyPackRef as g, FamilyInstance as h, ComponentDescriptor as i, LoweredDefaultValue as j, DefaultFunctionRegistryEntry as k, DriverInstance as l, FamilyDescriptor as m, AdapterInstance as n, ContractComponentRequirementsCheckInput as o, ExtensionPackRef as p, AdapterPackRef as r, ContractComponentRequirementsCheckResult as s, AdapterDescriptor as t, DriverPackRef as u, TargetBoundComponentDescriptor as v, ControlMutationDefaultRegistry as w, TargetPackRef as x, TargetDescriptor as y };
-//# sourceMappingURL=framework-components-DwkHnl-e.d.mts.map
+//# sourceMappingURL=framework-components-DQRRmQOH.d.mts.map

package/dist/{framework-components-DwkHnl-e.d.mts.map → framework-components-DQRRmQOH.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"framework-components-DwkHnl-e.d.mts","names":[],"sources":["../src/shared/mutation-default-types.ts","../src/shared/framework-components.ts"],"mappings":"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"}
+{"version":3,"file":"framework-components-DQRRmQOH.d.mts","names":[],"sources":["../src/shared/mutation-default-types.ts","../src/shared/framework-components.ts"],"mappings":"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"}

package/dist/ir.d.mts

@@ -0,0 +1,161 @@
+//#region src/ir/ir-node.d.ts
+/**
+ * Framework-level IR alphabet.
+ *
+ * The framework's contribution to Contract IR / Schema IR is a common
+ * root for the IR class hierarchy and a freeze affordance. Family
+ * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet
+ * for their family shape; targets ship the concrete classes.
+ *
+ * `kind` is an optional discriminator on the base. Families and leaves
+ * that benefit from discriminated-union dispatch declare their own
+ * literal `kind` at the level that earns it — Mongo leaves carry
+ * per-class literals (`readonly kind = 'mongo-collection' as const`)
+ * because Mongo IR has polymorphic walkers; SQL declares a single
+ * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no
+ * polymorphic dispatch today. No framework consumer dispatches on
+ * `IRNode.kind` at the BASE type — every dispatch site narrows
+ * through a union of leaves where each leaf carries a literal kind, so
+ * requiring `kind` at the base would be unearned. Future leaves that
+ * earn polymorphic dispatch override with a required literal at that
+ * leaf (e.g. `override readonly kind = 'postgres-enum' as const`).
+ *
+ * `IRNodeBase` carries no methods: the freeze-and-assign affordance
+ * lives in the free `freezeNode` helper below. Keeping `freezeNode` out
+ * of the class type means an emitted contract literal type
+ * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal
+ * like `{ nativeType, codecId, nullable }`) is structurally assignable
+ * to its class type — a `protected freeze()` instance method would
+ * otherwise leak into the public type surface and require the literal
+ * to carry it too.
+ *
+ * Subclasses construct fields then call `freezeNode(this)` to seal the
+ * instance. Frozen instances + plain readonly fields keep IR nodes
+ * JSON-clean by construction, so `JSON.stringify(node)` produces canonical
+ * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles
+ * round-trip from canonical JSON back to typed class instances.
+ *
+ * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:
+ * this base is the common root for both Contract IR and Schema IR class
+ * hierarchies, not a Schema-IR-specific alphabet.
+ */
+interface IRNode {
+  readonly kind?: string;
+}
+declare abstract class IRNodeBase implements IRNode {
+  abstract readonly kind?: string;
+}
+/**
+ * Seal an IR class instance after its constructor has assigned all
+ * fields. The free-helper form (rather than a `protected freeze()`
+ * instance method) keeps the class type structurally narrow so emitted
+ * contract literal types remain assignable to their class types.
+ *
+ * The helper name stays `freezeNode` — it operates on IR nodes
+ * regardless of root naming.
+ */
+declare function freezeNode<T extends IRNode>(node: T): T;
+//#endregion
+//#region src/ir/namespace.d.ts
+/**
+ * Reserved sentinel namespace id meaning
+ * "no namespace bound at authoring time; resolve from connection context".
+ *
+ * Materialised target-side as a singleton subclass of the target's
+ * `NamespaceBase` concretion that overrides the namespace's
+ * qualifier-emission methods to elide the prefix entirely. Call sites
+ * stay polymorphic and never branch on `id === UNSPECIFIED_NAMESPACE_ID`
+ * — the singleton's overrides drop the qualifier so emitted SQL / Mongo
+ * commands look unqualified.
+ *
+ * Encoded as an exported const (rather than scattered string literals)
+ * so the sentinel-id invariant is single-sourced: any production-source
+ * site that constructs an unspecified-namespace singleton imports this
+ * constant.
+ */
+declare const UNSPECIFIED_NAMESPACE_ID: "__unspecified__";
+/**
+ * Framework-level building block for a "namespace" — the database-level
+ * grouping under which storage objects (tables, collections, enums, …)
+ * reside. Each target's namespace concretion maps the framework concept to
+ * a target-native binding:
+ *
+ * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `"<schema>"`.
+ * - SQLite: the singleton `UNSPECIFIED_NAMESPACE_ID`; emitted SQL has no qualifier.
+ * - Mongo: the connection's `db` field; addressed as a database name.
+ *
+ * See `UNSPECIFIED_NAMESPACE_ID` above for the sentinel id and the
+ * singleton-subclass pattern that materialises it.
+ */
+interface Namespace extends IRNode {
+  readonly id: string;
+}
+declare abstract class NamespaceBase extends IRNodeBase implements Namespace {
+  abstract readonly id: string;
+}
+//#endregion
+//#region src/ir/storage.d.ts
+/**
+ * Framework-level promise that every Contract IR / Schema IR carries a
+ * collection of namespaces keyed by namespace id. Family storage
+ * concretions (`SqlStorage`, `MongoStorage`) refine the shape with
+ * family-specific fields (tables, collections, enums, …); target
+ * concretions add target fields where the family vocabulary doesn't
+ * reach.
+ *
+ * Keeping `namespaces` at the framework layer enforces that every storage
+ * object — across any target — is namespace-scoped. The framework can
+ * therefore walk the namespace map without knowing the family alphabet, and
+ * the `(namespace.id, name)` keying that the verifier and planner depend on
+ * is honest at every layer.
+ *
+ * Extends `IRNode` so the framework's IR-walking surfaces (verifiers,
+ * serializers) can dispatch on `Storage`-typed slots through the same
+ * IR-node alphabet as every other node — the structural dual already
+ * holds in code (every concrete storage class extends an IR-node base);
+ * the interface promotion makes the typing honest.
+ *
+ * **Persisted envelope shape is target-owned, not framework-promised.**
+ * Whether the `namespaces` map appears in the on-disk JSON envelope is
+ * a per-target decision made by `ContractSerializer.serializeContract`.
+ * Some targets emit a JSON-clean namespace shape that round-trips
+ * through `JSON.stringify` cleanly (SQL today via the family-layer
+ * identity serializer); others ship runtime-only fields on their
+ * namespace concretions and override `serializeContract` to strip
+ * them (Mongo). Future open (F16): extend the per-target
+ * `ContractSerializer` integration-test surface with an explicit
+ * envelope-shape assertion for each target, so the strip-vs-pass-through
+ * choice is locked at test time rather than implied by the override
+ * presence/absence. Earned by PR2's per-target namespace lift, when
+ * `PostgresSchema` / `SqliteUnspecifiedDatabase` start carrying
+ * target-specific fields.
+ */
+interface Storage extends IRNode {
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+}
+//#endregion
+//#region src/ir/storage-type.d.ts
+/**
+ * Framework-level alphabet for entries in a storage `types` slot.
+ *
+ * The slot is polymorphic at the framework level: a family or target can
+ * persist either a JSON-clean codec-triple object literal (carrying
+ * `kind: 'codec-instance'`) or a class-instance IR node with a narrower
+ * kind discriminator (e.g. `'postgres-enum'`). Hydration walkers,
+ * verifiers, and planners dispatch on the `kind` literal to recover the
+ * precise variant.
+ *
+ * The `kind` field is required at this layer (in contrast with
+ * `IRNode.kind` which is optional) because the slot's downstream
+ * consumers dispatch on it — without a guaranteed discriminator the
+ * polymorphic walk cannot pick the right reader. Concrete variants
+ * narrow `kind` to their literal and add their own field set;
+ * downstream consumers use `kind`-discriminator helpers to recover
+ * the precise shape.
+ */
+interface StorageType extends IRNode {
+  readonly kind: string;
+}
+//#endregion
+export { type IRNode, IRNodeBase, type Namespace, NamespaceBase, type Storage, type StorageType, UNSPECIFIED_NAMESPACE_ID, freezeNode };
+//# sourceMappingURL=ir.d.mts.map

package/dist/ir.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/ir/ir-node.ts","../src/ir/namespace.ts","../src/ir/storage.ts","../src/ir/storage-type.ts"],"mappings":";;AAyCA;;;;;AAIA;;;;;AAaA;;;;;;;;;;;;;;;;;;ACxCA;;;;;AAeA;;;;;AAIA;UDIiB,MAAA;EAAA,SACN,IAAA;AAAA;AAAA,uBAGW,UAAA,YAAsB,MAAA;EAAA,kBACxB,IAAA;AAAA;;;;;;AERpB;;;;iBFoBgB,UAAA,WAAqB,MAAA,CAAA,CAAQ,IAAA,EAAM,CAAA,GAAI,CAAA;;;AAjBvD;;;;;AAIA;;;;;AAaA;;;;;;AAjBA,cCvBa,wBAAA;;;;;;;;;;;;AAAb;;UAeiB,SAAA,SAAkB,MAAA;EAAA,SACxB,EAAA;AAAA;AAAA,uBAGW,aAAA,SAAsB,UAAA,YAAsB,SAAA;EAAA,kBAC9C,EAAA;AAAA;;;;;;;ADOpB;;;;;AAaA;;;;;;;;;;;;;;;;;;ACxCA;;;;;AAeA;;;UCKiB,OAAA,SAAgB,MAAA;EAAA,SACtB,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,SAAA;AAAA;;;AFE/C;;;;;AAIA;;;;;AAaA;;;;;;;;AAjBA,UGrBiB,WAAA,SAAoB,MAAA;EAAA,SAC1B,IAAA;AAAA"}

package/dist/ir.mjs

@@ -0,0 +1,39 @@
+//#region src/ir/ir-node.ts
+var IRNodeBase = class {};
+/**
+* Seal an IR class instance after its constructor has assigned all
+* fields. The free-helper form (rather than a `protected freeze()`
+* instance method) keeps the class type structurally narrow so emitted
+* contract literal types remain assignable to their class types.
+*
+* The helper name stays `freezeNode` — it operates on IR nodes
+* regardless of root naming.
+*/
+function freezeNode(node) {
+	Object.freeze(node);
+	return node;
+}
+//#endregion
+//#region src/ir/namespace.ts
+/**
+* Reserved sentinel namespace id meaning
+* "no namespace bound at authoring time; resolve from connection context".
+*
+* Materialised target-side as a singleton subclass of the target's
+* `NamespaceBase` concretion that overrides the namespace's
+* qualifier-emission methods to elide the prefix entirely. Call sites
+* stay polymorphic and never branch on `id === UNSPECIFIED_NAMESPACE_ID`
+* — the singleton's overrides drop the qualifier so emitted SQL / Mongo
+* commands look unqualified.
+*
+* Encoded as an exported const (rather than scattered string literals)
+* so the sentinel-id invariant is single-sourced: any production-source
+* site that constructs an unspecified-namespace singleton imports this
+* constant.
+*/
+const UNSPECIFIED_NAMESPACE_ID = "__unspecified__";
+var NamespaceBase = class extends IRNodeBase {};
+//#endregion
+export { IRNodeBase, NamespaceBase, UNSPECIFIED_NAMESPACE_ID, freezeNode };
+
+//# sourceMappingURL=ir.mjs.map

package/dist/ir.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.mjs","names":[],"sources":["../src/ir/ir-node.ts","../src/ir/namespace.ts"],"sourcesContent":["/**\n * Framework-level IR alphabet.\n *\n * The framework's contribution to Contract IR / Schema IR is a common\n * root for the IR class hierarchy and a freeze affordance. Family\n * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet\n * for their family shape; targets ship the concrete classes.\n *\n * `kind` is an optional discriminator on the base. Families and leaves\n * that benefit from discriminated-union dispatch declare their own\n * literal `kind` at the level that earns it — Mongo leaves carry\n * per-class literals (`readonly kind = 'mongo-collection' as const`)\n * because Mongo IR has polymorphic walkers; SQL declares a single\n * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no\n * polymorphic dispatch today. No framework consumer dispatches on\n * `IRNode.kind` at the BASE type — every dispatch site narrows\n * through a union of leaves where each leaf carries a literal kind, so\n * requiring `kind` at the base would be unearned. Future leaves that\n * earn polymorphic dispatch override with a required literal at that\n * leaf (e.g. `override readonly kind = 'postgres-enum' as const`).\n *\n * `IRNodeBase` carries no methods: the freeze-and-assign affordance\n * lives in the free `freezeNode` helper below. Keeping `freezeNode` out\n * of the class type means an emitted contract literal type\n * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal\n * like `{ nativeType, codecId, nullable }`) is structurally assignable\n * to its class type — a `protected freeze()` instance method would\n * otherwise leak into the public type surface and require the literal\n * to carry it too.\n *\n * Subclasses construct fields then call `freezeNode(this)` to seal the\n * instance. Frozen instances + plain readonly fields keep IR nodes\n * JSON-clean by construction, so `JSON.stringify(node)` produces canonical\n * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles\n * round-trip from canonical JSON back to typed class instances.\n *\n * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:\n * this base is the common root for both Contract IR and Schema IR class\n * hierarchies, not a Schema-IR-specific alphabet.\n */\n\nexport interface IRNode {\n  readonly kind?: string;\n}\n\nexport abstract class IRNodeBase implements IRNode {\n  abstract readonly kind?: string;\n}\n\n/**\n * Seal an IR class instance after its constructor has assigned all\n * fields. The free-helper form (rather than a `protected freeze()`\n * instance method) keeps the class type structurally narrow so emitted\n * contract literal types remain assignable to their class types.\n *\n * The helper name stays `freezeNode` — it operates on IR nodes\n * regardless of root naming.\n */\nexport function freezeNode<T extends IRNode>(node: T): T {\n  Object.freeze(node);\n  return node;\n}\n","import { type IRNode, IRNodeBase } from './ir-node';\n\n/**\n * Reserved sentinel namespace id meaning\n * \"no namespace bound at authoring time; resolve from connection context\".\n *\n * Materialised target-side as a singleton subclass of the target's\n * `NamespaceBase` concretion that overrides the namespace's\n * qualifier-emission methods to elide the prefix entirely. Call sites\n * stay polymorphic and never branch on `id === UNSPECIFIED_NAMESPACE_ID`\n * — the singleton's overrides drop the qualifier so emitted SQL / Mongo\n * commands look unqualified.\n *\n * Encoded as an exported const (rather than scattered string literals)\n * so the sentinel-id invariant is single-sourced: any production-source\n * site that constructs an unspecified-namespace singleton imports this\n * constant.\n */\nexport const UNSPECIFIED_NAMESPACE_ID = '__unspecified__' as const;\n\n/**\n * Framework-level building block for a \"namespace\" — the database-level\n * grouping under which storage objects (tables, collections, enums, …)\n * reside. Each target's namespace concretion maps the framework concept to\n * a target-native binding:\n *\n * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `\"<schema>\"`.\n * - SQLite: the singleton `UNSPECIFIED_NAMESPACE_ID`; emitted SQL has no qualifier.\n * - Mongo: the connection's `db` field; addressed as a database name.\n *\n * See `UNSPECIFIED_NAMESPACE_ID` above for the sentinel id and the\n * singleton-subclass pattern that materialises it.\n */\nexport interface Namespace extends IRNode {\n  readonly id: string;\n}\n\nexport abstract class NamespaceBase extends IRNodeBase implements Namespace {\n  abstract readonly id: string;\n}\n"],"mappings":";AA6CA,IAAsB,aAAtB,MAAmD;;;;;;;;;;AAanD,SAAgB,WAA6B,MAAY;CACvD,OAAO,OAAO,KAAK;CACnB,OAAO;;;;;;;;;;;;;;;;;;;;AC1CT,MAAa,2BAA2B;AAmBxC,IAAsB,gBAAtB,cAA4C,WAAgC"}