@prisma-next/framework-components 0.5.0-dev.51 → 0.5.0-dev.53

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

@@ -0,0 +1 @@
+{"version":3,"file":"framework-authoring-DJbiXhmf.d.mts","names":[],"sources":["../src/shared/framework-authoring.ts"],"sourcesContent":[],"mappings":";;;KAWY,eAAA;;EAAA,SAAA,KAAA,EAAA,MAAe;EAOf,SAAA,IAAA,CAAA,EAAA,SAAsB,MAAA,EAAA;EAK9B,SAAA,OAAA,CAAA,EARiB,sBAQjB;CACS;AACiB,KAPlB,sBAAA,GAOkB,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,GAF1B,eAE0B,GAAA,SADjB,sBACiB,EAAA,GAAA;EAAsB,UAAA,GAAA,EAAA,MAAA,CAAA,EAAtB,sBAAsB;AAAG,CAAA;AAOvD,UALU,iCAAA,CAK6B;EAAG,SAAA,IAAA,CAAA,EAAA,MAAA;EAYE,SAAA,QAAA,CAAA,EAAA,OAAA;;AAAT,KAZvB,2BAAA,GAA8B,iCAYP,GAAA,CAAA;EAIlB,SAAA,IAAA,EAAA,QAAA;CAEM,GAAA;EACgB,SAAA,IAAA,EAAA,QAAA;EAAf,SAAA,OAAA,CAAA,EAAA,OAAA;EAAM,SAAA,OAAA,CAAA,EAAA,MAAA;EAGb,SAAA,OAAA,CAAA,EAAA,MAAA;AAMjB,CAAA,GAAiB;EAKA,SAAA,IAAA,EAAA,aAAA;AAKjB,CAAA,GAAY;EAIK,SAAA,IAAA,EAAA,QAAA;EAKA,SAAA,UAAA,EAnCY,MAmCZ,CAAA,MAA2B,EAnCA,2BAmCA,CAAA;CAEvB,CAAA;AACU,UAlCd,4BAAA,CAkCc;EAHqB,SAAA,OAAA,EAAA,MAAA;EAA4B,SAAA,UAAA,EA7BzD,sBA6ByD;EAQ/D,SAAA,UAAA,CAAA,EApCO,MAoCP,CAAA,MAA8B,EApCR,sBAsCZ,CAAA;AAI3B;AAIY,UA3CK,kCAAA,CA4CU;EAGV,SAAA,IAAA,EAAA,iBAAsB;EAKvB,SAAA,IAAA,CAAA,EAAA,SAlDW,2BAkDgD,EAAA;EAkB3D,SAAA,MAAA,EAnEG,4BAmEiC;AAYpD;AAoBgB,UAhGC,qCAAA,CAiGA;EA+BD,SAAA,IAAA,EAAA,SAAA;EAyEA,SAAA,KAAA,EAvME,sBAuM6B;AA6B/C;AA4GgB,UA7UC,sCAAA,CA+UO;EAoHR,SAAA,IAAA,EAAA,UAAA;EAWA,SAAA,UAAA,EA5cO,sBA4cwB;;AAOrB,KAhdd,8BAAA,GACR,qCA+csB,GA9ctB,sCA8csB;AAGL,UA/cJ,kCAAA,CA+cI;EACU,SAAA,QAAA,CAAA,EA/cT,sBA+cS;EAA8B,SAAA,QAAA,CAAA,EA9cvC,sBA8cuC;;UA3c5C,0BAAA,SAAmC;;qBAE/B;+BACU;;;;UAKd,8BAAA;;2BAEU;mBACR;;KAGP,sBAAA;2BACe,qCAAqC;;KAGpD,uBAAA;2BACe,iCAAiC;;UAG3C,sBAAA;kBACC;mBACC;;iBAGH,iBAAA,2BAA4C;iBAkB5C,oCAAA,2BAEJ;iBAUI,gCAAA,2BAEJ;;;;;;;;;iBAkBI,2BAAA,gBACC;;;;;;;;;;;;;;;;;;;iBA+BD,wBAAA,SACN,iCACA;iBAuEM,+BAAA,gBACC,wCACC;iBA2BF,6BAAA,WACJ;iBA2GI,gCAAA,2CAEQ;iBAoHR,mCAAA,aACF;;;wBAKU;;iBAKR,+BAAA,aACF;;;;0BAMY;;;qBAGL;+BACU"}

package/dist/framework-authoring-gi_BJlNO.mjs

@@ -0,0 +1,206 @@
+import { isColumnDefaultLiteralInputValue, isExecutionMutationDefaultValue } from "@prisma-next/contract/types";
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/shared/framework-authoring.ts
+function isAuthoringArgRef(value) {
+	if (typeof value !== "object" || value === null || value.kind !== "arg") return false;
+	const { index, path } = value;
+	if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return false;
+	if (path !== void 0 && (!Array.isArray(path) || path.some((s) => typeof s !== "string"))) return false;
+	return true;
+}
+function isAuthoringTemplateRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAuthoringTypeConstructorDescriptor(value) {
+	return typeof value === "object" && value !== null && value.kind === "typeConstructor" && typeof value.output === "object" && value.output !== null;
+}
+function isAuthoringFieldPresetDescriptor(value) {
+	return typeof value === "object" && value !== null && value.kind === "fieldPreset" && typeof value.output === "object" && value.output !== null;
+}
+/**
+* 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`).
+*/
+function hasRegisteredFieldNamespace(contributions, namespace) {
+	if (contributions?.field === void 0 || !Object.hasOwn(contributions.field, namespace)) return false;
+	return !isAuthoringFieldPresetDescriptor(contributions.field[namespace]);
+}
+function isPlainNamespaceObject(value) {
+	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.
+*/
+function mergeAuthoringNamespaces(target, source, path, leafGuard, label) {
+	const assertSafePath = (currentPath) => {
+		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] : void 0;
+		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, isLeaf, path = []) {
+	const paths = [];
+	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, isLeaf, currentPath));
+	}
+	return paths;
+}
+function assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace) {
+	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.`);
+}
+function resolveAuthoringTemplateValue(template, args) {
+	if (isAuthoringArgRef(template)) {
+		let value = args[template.index];
+		for (const segment of template.path ?? []) {
+			if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) {
+				value = void 0;
+				break;
+			}
+			value = value[segment];
+		}
+		if (value === void 0 && template.default !== void 0) return resolveAuthoringTemplateValue(template.default, args);
+		return value;
+	}
+	if (Array.isArray(template)) return template.map((value) => resolveAuthoringTemplateValue(value, args));
+	if (typeof template === "object" && template !== null) {
+		const resolved = {};
+		for (const [key, value] of Object.entries(template)) {
+			const resolvedValue = resolveAuthoringTemplateValue(value, args);
+			if (resolvedValue !== void 0) resolved[key] = resolvedValue;
+		}
+		return resolved;
+	}
+	return template;
+}
+function validateAuthoringArgument(descriptor, value, path) {
+	if (value === void 0) {
+		if (descriptor.optional) return;
+		throw new Error(`Missing required authoring helper argument at ${path}`);
+	}
+	if (descriptor.kind === "string") {
+		if (typeof value !== "string") throw new Error(`Authoring helper argument at ${path} must be a string`);
+		return;
+	}
+	if (descriptor.kind === "stringArray") {
+		if (!Array.isArray(value)) throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
+		for (const entry of value) if (typeof entry !== "string") throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
+		return;
+	}
+	if (descriptor.kind === "object") {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Authoring helper argument at ${path} must be an object`);
+		const input = value;
+		const expectedKeys = new Set(Object.keys(descriptor.properties));
+		for (const key of Object.keys(input)) if (!expectedKeys.has(key)) throw new Error(`Authoring helper argument at ${path} contains unknown property "${key}"`);
+		for (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);
+		return;
+	}
+	if (typeof value !== "number" || Number.isNaN(value)) throw new Error(`Authoring helper argument at ${path} must be a number`);
+	if (descriptor.integer && !Number.isInteger(value)) throw new Error(`Authoring helper argument at ${path} must be an integer`);
+	if (descriptor.minimum !== void 0 && value < descriptor.minimum) throw new Error(`Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`);
+	if (descriptor.maximum !== void 0 && value > descriptor.maximum) throw new Error(`Authoring helper argument at ${path} must be <= ${descriptor.maximum}, received ${value}`);
+}
+function validateAuthoringHelperArguments(helperPath, descriptors, args) {
+	const expected = descriptors ?? [];
+	const minimumArgs = expected.reduce((count, descriptor, index) => descriptor.optional ? count : index + 1, 0);
+	if (args.length < minimumArgs || args.length > expected.length) throw new Error(`${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`);
+	expected.forEach((descriptor, index) => {
+		validateAuthoringArgument(descriptor, args[index], `${helperPath}[${index}]`);
+	});
+}
+function resolveAuthoringStorageTypeTemplate(template, args) {
+	const nativeType = resolveAuthoringTemplateValue(template.nativeType, args);
+	if (typeof nativeType !== "string") throw new Error(`Resolved authoring nativeType must be a string for codec "${template.codecId}", received ${String(nativeType)}`);
+	const typeParams = template.typeParams === void 0 ? void 0 : resolveAuthoringTemplateValue(template.typeParams, args);
+	if (typeParams !== void 0 && !isAuthoringTemplateRecord(typeParams)) throw new Error(`Resolved authoring typeParams must be an object for codec "${template.codecId}", received ${String(typeParams)}`);
+	return {
+		codecId: template.codecId,
+		nativeType,
+		...typeParams === void 0 ? {} : { typeParams }
+	};
+}
+function resolveAuthoringColumnDefaultTemplate(template, args) {
+	if (template.kind === "literal") {
+		const value = resolveAuthoringTemplateValue(template.value, args);
+		if (value === void 0) 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
+		};
+	}
+	const expression = resolveAuthoringTemplateValue(template.expression, args);
+	if (expression === void 0 || typeof expression === "object" && expression !== null) throw new Error(`Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`);
+	return {
+		kind: "function",
+		expression: String(expression)
+	};
+}
+function resolveExecutionMutationDefaultPhase(phase, template, args) {
+	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, args) {
+	return {
+		...ifDefined("onCreate", template.onCreate !== void 0 ? resolveExecutionMutationDefaultPhase("onCreate", template.onCreate, args) : void 0),
+		...ifDefined("onUpdate", template.onUpdate !== void 0 ? resolveExecutionMutationDefaultPhase("onUpdate", template.onUpdate, args) : void 0)
+	};
+}
+function instantiateAuthoringTypeConstructor(descriptor, args) {
+	return resolveAuthoringStorageTypeTemplate(descriptor.output, args);
+}
+function instantiateAuthoringFieldPreset(descriptor, args) {
+	return {
+		descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),
+		nullable: descriptor.output.nullable ?? false,
+		...ifDefined("default", descriptor.output.default !== void 0 ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args) : void 0),
+		...ifDefined("executionDefaults", descriptor.output.executionDefaults !== void 0 ? resolveAuthoringExecutionDefaultsTemplate(descriptor.output.executionDefaults, args) : void 0),
+		id: descriptor.output.id ?? false,
+		unique: descriptor.output.unique ?? false
+	};
+}
+
+//#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 };
+//# sourceMappingURL=framework-authoring-gi_BJlNO.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"framework-authoring-gi_BJlNO.mjs","names":["paths: string[]","resolved: Record<string, unknown>"],"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    | {\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\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\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): void {\n  const typePaths = new Set(\n    collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),\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 either registry before this check\n  // runs. This function only handles the cross-registry case — and an\n  // empty type namespace makes a cross-registry collision structurally\n  // impossible, so the early-out is sound.\n  if (typePaths.size === 0) {\n    return;\n  }\n  for (const fieldPath of collectAuthoringLeafPaths(\n    fieldNamespace,\n    isAuthoringFieldPresetDescriptor,\n  )) {\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.`,\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 === '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 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-AHI6V96G.d.mts → framework-components-BvzjH6Pt.d.mts}

@@ -1,7 +1,7 @@
-import { i as AuthoringContributions } from "./framework-authoring-BdrFDx4x.mjs";
-import { t as Codec } from "./codec-types-CB0jWeHU.mjs";
-import { t as TypesImportSpec } from "./types-import-spec-D-O6GotH.mjs";
-import { ColumnDefault, ExecutionMutationDefaultValue } from "@prisma-next/contract/types";
+import { i as AuthoringContributions } from "./framework-authoring-DJbiXhmf.mjs";
+import { t as Codec } from "./codec-types-MWvfFmu1.mjs";
+import { t as TypesImportSpec } from "./types-import-spec-CPhrNJIV.mjs";
+import { ColumnDefault, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue } from "@prisma-next/contract/types";
 
 //#region src/shared/mutation-default-types.d.ts
 interface SourcePosition {
@@ -61,7 +61,16 @@ interface DefaultFunctionRegistryEntry {
 type DefaultFunctionRegistry = ReadonlyMap<string, DefaultFunctionRegistryEntry>;
 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;
   }) => {
@@ -70,6 +79,13 @@ interface MutationDefaultGeneratorDescriptor {
     readonly typeRef?: string;
     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;
 }
 interface ControlMutationDefaultEntry {
   readonly lower: (input: {
@@ -421,4 +437,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-AHI6V96G.d.mts.map
+//# sourceMappingURL=framework-components-BvzjH6Pt.d.mts.map

package/dist/framework-components-BvzjH6Pt.d.mts.map

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

package/dist/{psl-ast-9X5rwo98.d.mts → psl-ast-BlDveJZ4.d.mts}

@@ -156,4 +156,4 @@ interface ParsePslDocumentResult {
 }
 //#endregion
 export { PslPosition as C, PslTypesBlock as D, PslTypeConstructorCall as E, PslUniqueConstraint as O, PslNamedTypeDeclaration as S, PslSpan as T, PslField as _, PslAttributeNamedArgument as a, PslModel as b, PslCompositeType as c, PslDefaultValue as d, PslDiagnostic as f, PslEnumValue as g, PslEnum as h, PslAttributeArgument as i, PslDefaultFunctionValue as l, PslDocumentAst as m, ParsePslDocumentResult as n, PslAttributePositionalArgument as o, PslDiagnosticCode as p, PslAttribute as r, PslAttributeTarget as s, ParsePslDocumentInput as t, PslDefaultLiteralValue as u, PslFieldAttribute as v, PslReferentialAction as w, PslModelAttribute as x, PslIndexConstraint as y };
-//# sourceMappingURL=psl-ast-9X5rwo98.d.mts.map
+//# sourceMappingURL=psl-ast-BlDveJZ4.d.mts.map

package/dist/{psl-ast-9X5rwo98.d.mts.map → psl-ast-BlDveJZ4.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"psl-ast-9X5rwo98.d.mts","names":[],"sources":["../src/control/psl-ast.ts"],"sourcesContent":[],"mappings":";UAAiB,WAAA;EAAA,SAAA,MAAW,EAAA,MAAA;EAMX,SAAA,IAAO,EAAA,MAAA;EAKZ,SAAA,MAAA,EAAA,MAAiB;AAa7B;AAOiB,UAzBA,OAAA,CAyBA;EAKA,SAAA,KAAA,EA7BC,WA6BqB;EAK3B,SAAA,GAAA,EAjCI,WAiCW;AAE3B;AAEiB,KAlCL,iBAAA,GAkCK,wBAGA,GAAO,iCAAA,GAAA,8BAAA,GAAA,0BAAA,GAAA,iCAAA,GAAA,iCAAA,GAAA,gCAAA,GAAA,gCAAA,GAAA,2BAAA,GAAA,yBAAA,GAAA,0BAAA;AAGP,UA3BA,aAAA,CA2BA;EAOL,SAAA,IAAA,EAjCK,iBAiCe;EAEf,SAAA,OAAA,EAAA,MAAA;EAOA,SAAA,QAAY,EAAA,MAAA;EAEV,SAAA,IAAA,EAzCF,OAyCE;;AAGF,UAzCA,uBAAA,CAyCA;EAAO,SAAA,IAAA,EAAA,UAAA;EAGZ,SAAA,IAAA,EAAA,eAAoB,GAAA,KAAA;AAEhC;AAEiB,UA3CA,sBAAA,CA2CQ;EAII,SAAA,IAAA,EAAA,SAAA;EAIG,SAAA,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,OAAA;;AACR,KA/CZ,eAAA,GAAkB,uBA+CN,GA/CgC,sBA+ChC;AAGP,KAhDL,kBAAA,GAgDwB,OAGnB,GAAA,OAAO,GAAA,MAAA,GAAA,WAAA;AAGP,UApDA,8BAAA,CAuDO;EAGZ,SAAA,IAAA,EAAA,YAAiB;EAEZ,SAAA,KAAQ,EAAA,MAAA;EAGG,SAAA,IAAA,EA5DX,OA4DW;;AAEX,UA3DA,yBAAA,CA2DA;EAAO,SAAA,IAAA,EAAA,OAAA;EAWP,SAAA,IAAA,EAAY,MAAA;EAgBZ,SAAA,KAAO,EAAA,MAAA;EAGI,SAAA,IAAA,EArFX,OAqFW;;AAEX,KApFL,oBAAA,GAAuB,8BAoFlB,GApFmD,yBAoFnD;AAAO,UAlFP,sBAAA,CAkFO;EAGP,SAAA,IAAA,EAAA,iBAAgB;EAGL,SAAA,IAAA,EAAA,SAAA,MAAA,EAAA;EACI,SAAA,IAAA,EAAA,SAtFN,oBAsFM,EAAA;EACf,SAAA,IAAA,EAtFA,OAsFA;;AAGA,UAtFA,YAAA,CAsFuB;EASX,SAAA,IAAA,EAAA,WAAA;EACG,SAAA,MAAA,EA9Fb,kBA8Fa;EACf,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,IAAA,EAAA,SA7FE,oBA6FF,EAAA;EAGP,SAAA,IAAA,EA/FA,OA+Fa;AAM9B;AAG4B,KArGhB,oBAAA,GAqGgB,MAAA;AACD,KApGf,iBAAA,GAAoB,YAoGL;AACS,UAnGnB,QAAA,CAmGmB;EACjB,SAAA,IAAA,EAAA,OAAA;EACF,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,QAAA,EAAA,MAAA;EAGP,SAAA,eAAqB,CAAA,EApGT,sBAoGS;EAKrB,SAAA,QAAA,EAAA,OAAsB;;;gCArGP;iBACf;;UAGA,mBAAA;;;iBAGA;;UAGA,kBAAA;;;iBAGA;;KAGL,iBAAA,GAAoB;UAEf,QAAA;;;4BAGW;gCACI;iBACf;;;;;;;;;;UAWA,YAAA;;;;;;;;;;;;;iBAaA;;UAGA,OAAA;;;4BAGW;gCACI;iBACf;;UAGA,gBAAA;;;4BAGW;gCACI;iBACf;;UAGA,uBAAA;;;;;;;;;6BASY;gCACG;iBACf;;UAGA,aAAA;;kCAEiB;iBACjB;;UAGA,cAAA;;;4BAGW;2BACD;oCACS;mBACjB;iBACF;;UAGA,qBAAA;;;;UAKA,sBAAA;gBACD;iCACiB"}
+{"version":3,"file":"psl-ast-BlDveJZ4.d.mts","names":[],"sources":["../src/control/psl-ast.ts"],"sourcesContent":[],"mappings":";UAAiB,WAAA;EAAA,SAAA,MAAW,EAAA,MAAA;EAMX,SAAA,IAAO,EAAA,MAAA;EAKZ,SAAA,MAAA,EAAA,MAAiB;AAa7B;AAOiB,UAzBA,OAAA,CAyBA;EAKA,SAAA,KAAA,EA7BC,WA6BqB;EAK3B,SAAA,GAAA,EAjCI,WAiCW;AAE3B;AAEiB,KAlCL,iBAAA,GAkCK,wBAGA,GAAO,iCAAA,GAAA,8BAAA,GAAA,0BAAA,GAAA,iCAAA,GAAA,iCAAA,GAAA,gCAAA,GAAA,gCAAA,GAAA,2BAAA,GAAA,yBAAA,GAAA,0BAAA;AAGP,UA3BA,aAAA,CA2BA;EAOL,SAAA,IAAA,EAjCK,iBAiCe;EAEf,SAAA,OAAA,EAAA,MAAA;EAOA,SAAA,QAAY,EAAA,MAAA;EAEV,SAAA,IAAA,EAzCF,OAyCE;;AAGF,UAzCA,uBAAA,CAyCA;EAAO,SAAA,IAAA,EAAA,UAAA;EAGZ,SAAA,IAAA,EAAA,eAAoB,GAAA,KAAA;AAEhC;AAEiB,UA3CA,sBAAA,CA2CQ;EAII,SAAA,IAAA,EAAA,SAAA;EAIG,SAAA,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,OAAA;;AACR,KA/CZ,eAAA,GAAkB,uBA+CN,GA/CgC,sBA+ChC;AAGP,KAhDL,kBAAA,GAgDwB,OAGnB,GAAA,OAAO,GAAA,MAAA,GAAA,WAAA;AAGP,UApDA,8BAAA,CAuDO;EAGZ,SAAA,IAAA,EAAA,YAAiB;EAEZ,SAAA,KAAQ,EAAA,MAAA;EAGG,SAAA,IAAA,EA5DX,OA4DW;;AAEX,UA3DA,yBAAA,CA2DA;EAAO,SAAA,IAAA,EAAA,OAAA;EAWP,SAAA,IAAA,EAAY,MAAA;EAgBZ,SAAA,KAAO,EAAA,MAAA;EAGI,SAAA,IAAA,EArFX,OAqFW;;AAEX,KApFL,oBAAA,GAAuB,8BAoFlB,GApFmD,yBAoFnD;AAAO,UAlFP,sBAAA,CAkFO;EAGP,SAAA,IAAA,EAAA,iBAAgB;EAGL,SAAA,IAAA,EAAA,SAAA,MAAA,EAAA;EACI,SAAA,IAAA,EAAA,SAtFN,oBAsFM,EAAA;EACf,SAAA,IAAA,EAtFA,OAsFA;;AAGA,UAtFA,YAAA,CAsFuB;EASX,SAAA,IAAA,EAAA,WAAA;EACG,SAAA,MAAA,EA9Fb,kBA8Fa;EACf,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,IAAA,EAAA,SA7FE,oBA6FF,EAAA;EAGP,SAAA,IAAA,EA/FA,OA+Fa;AAM9B;AAG4B,KArGhB,oBAAA,GAqGgB,MAAA;AACD,KApGf,iBAAA,GAAoB,YAoGL;AACS,UAnGnB,QAAA,CAmGmB;EACjB,SAAA,IAAA,EAAA,OAAA;EACF,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,QAAA,EAAA,MAAA;EAGP,SAAA,eAAqB,CAAA,EApGT,sBAoGS;EAKrB,SAAA,QAAA,EAAA,OAAsB;;;gCArGP;iBACf;;UAGA,mBAAA;;;iBAGA;;UAGA,kBAAA;;;iBAGA;;KAGL,iBAAA,GAAoB;UAEf,QAAA;;;4BAGW;gCACI;iBACf;;;;;;;;;;UAWA,YAAA;;;;;;;;;;;;;iBAaA;;UAGA,OAAA;;;4BAGW;gCACI;iBACf;;UAGA,gBAAA;;;4BAGW;gCACI;iBACf;;UAGA,uBAAA;;;;;;;;;6BASY;gCACG;iBACf;;UAGA,aAAA;;kCAEiB;iBACjB;;UAGA,cAAA;;;4BAGW;2BACD;oCACS;mBACjB;iBACF;;UAGA,qBAAA;;;;UAKA,sBAAA;gBACD;iCACiB"}

package/dist/psl-ast.d.mts

@@ -1,2 +1,2 @@
-import { C as PslPosition, D as PslTypesBlock, E as PslTypeConstructorCall, O as PslUniqueConstraint, S as PslNamedTypeDeclaration, T as PslSpan, _ as PslField, a as PslAttributeNamedArgument, b as PslModel, c as PslCompositeType, d as PslDefaultValue, f as PslDiagnostic, g as PslEnumValue, h as PslEnum, i as PslAttributeArgument, l as PslDefaultFunctionValue, m as PslDocumentAst, n as ParsePslDocumentResult, o as PslAttributePositionalArgument, p as PslDiagnosticCode, r as PslAttribute, s as PslAttributeTarget, t as ParsePslDocumentInput, u as PslDefaultLiteralValue, v as PslFieldAttribute, w as PslReferentialAction, x as PslModelAttribute, y as PslIndexConstraint } from "./psl-ast-9X5rwo98.mjs";
+import { C as PslPosition, D as PslTypesBlock, E as PslTypeConstructorCall, O as PslUniqueConstraint, S as PslNamedTypeDeclaration, T as PslSpan, _ as PslField, a as PslAttributeNamedArgument, b as PslModel, c as PslCompositeType, d as PslDefaultValue, f as PslDiagnostic, g as PslEnumValue, h as PslEnum, i as PslAttributeArgument, l as PslDefaultFunctionValue, m as PslDocumentAst, n as ParsePslDocumentResult, o as PslAttributePositionalArgument, p as PslDiagnosticCode, r as PslAttribute, s as PslAttributeTarget, t as ParsePslDocumentInput, u as PslDefaultLiteralValue, v as PslFieldAttribute, w as PslReferentialAction, x as PslModelAttribute, y as PslIndexConstraint } from "./psl-ast-BlDveJZ4.mjs";
 export { ParsePslDocumentInput, ParsePslDocumentResult, PslAttribute, PslAttributeArgument, PslAttributeNamedArgument, PslAttributePositionalArgument, PslAttributeTarget, PslCompositeType, PslDefaultFunctionValue, PslDefaultLiteralValue, PslDefaultValue, PslDiagnostic, PslDiagnosticCode, PslDocumentAst, PslEnum, PslEnumValue, PslField, PslFieldAttribute, PslIndexConstraint, PslModel, PslModelAttribute, PslNamedTypeDeclaration, PslPosition, PslReferentialAction, PslSpan, PslTypeConstructorCall, PslTypesBlock, PslUniqueConstraint };

package/dist/runtime.d.mts

@@ -1,4 +1,4 @@
-import { n as CodecCallContext } from "./codec-types-CB0jWeHU.mjs";
+import { n as CodecCallContext } from "./codec-types-MWvfFmu1.mjs";
 import { PlanMeta } from "@prisma-next/contract/types";
 
 //#region src/execution/async-iterable-result.d.ts

package/dist/{types-import-spec-D-O6GotH.d.mts → types-import-spec-CPhrNJIV.d.mts}

@@ -10,4 +10,4 @@ interface TypesImportSpec {
 }
 //#endregion
 export { TypesImportSpec as t };
-//# sourceMappingURL=types-import-spec-D-O6GotH.d.mts.map
+//# sourceMappingURL=types-import-spec-CPhrNJIV.d.mts.map

package/dist/types-import-spec-CPhrNJIV.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-import-spec-CPhrNJIV.d.mts","names":[],"sources":["../src/shared/types-import-spec.ts"],"sourcesContent":[],"mappings":";;AAIA;;;UAAiB,eAAA"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@prisma-next/framework-components",
-  "version": "0.5.0-dev.51",
+  "version": "0.5.0-dev.53",
   "type": "module",
   "sideEffects": false,
   "description": "Framework component types, assembly logic, and stack creation for Prisma Next",
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "@prisma-next/contract": "0.5.0-dev.51",
-    "@prisma-next/operations": "0.5.0-dev.51",
-    "@prisma-next/utils": "0.5.0-dev.51"
+    "@prisma-next/contract": "0.5.0-dev.53",
+    "@prisma-next/operations": "0.5.0-dev.53",
+    "@prisma-next/utils": "0.5.0-dev.53"
   },
   "devDependencies": {
     "tsdown": "0.18.4",

package/src/control/control-stack.ts

@@ -2,10 +2,14 @@ import type { CodecLookup } from '../shared/codec-types';
 import type {
   AuthoringContributions,
   AuthoringFieldNamespace,
-  AuthoringFieldPresetDescriptor,
-  AuthoringTypeConstructorDescriptor,
   AuthoringTypeNamespace,
 } from '../shared/framework-authoring';
+import {
+  assertNoCrossRegistryCollisions,
+  isAuthoringFieldPresetDescriptor,
+  isAuthoringTypeConstructorDescriptor,
+  mergeAuthoringNamespaces,
+} from '../shared/framework-authoring';
 import type { ComponentMetadata } from '../shared/framework-components';
 import type {
   ControlMutationDefaultEntry,
@@ -153,70 +157,6 @@ export function extractComponentIds(
   return ids;
 }
 
-function isTypeConstructorDescriptor(value: unknown): value is AuthoringTypeConstructorDescriptor {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    (value as { kind?: unknown }).kind === 'typeConstructor'
-  );
-}
-
-function isFieldPresetDescriptor(value: unknown): value is AuthoringFieldPresetDescriptor {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    (value as { kind?: unknown }).kind === 'fieldPreset'
-  );
-}
-
-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('.')}". Descriptor contributions must be unique across composed components.`,
-      );
-    }
-
-    mergeAuthoringNamespaces(
-      existingValue as Record<string, unknown>,
-      sourceValue as Record<string, unknown>,
-      currentPath,
-      leafGuard,
-      label,
-    );
-  }
-}
-
 export function assembleAuthoringContributions(
   descriptors: ReadonlyArray<{ readonly authoring?: AuthoringContributions }>,
 ): AssembledAuthoringContributions {
@@ -229,7 +169,7 @@ export function assembleAuthoringContributions(
         field,
         descriptor.authoring.field,
         [],
-        isFieldPresetDescriptor,
+        isAuthoringFieldPresetDescriptor,
         'field',
       );
     }
@@ -240,14 +180,18 @@ export function assembleAuthoringContributions(
       type,
       descriptor.authoring.type,
       [],
-      isTypeConstructorDescriptor,
+      isAuthoringTypeConstructorDescriptor,
       'type',
     );
   }
 
+  const fieldNamespace = field as AuthoringFieldNamespace;
+  const typeNamespace = type as AuthoringTypeNamespace;
+  assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace);
+
   return {
-    field: field as AuthoringFieldNamespace,
-    type: type as AuthoringTypeNamespace,
+    field: fieldNamespace,
+    type: typeNamespace,
   };
 }
 

package/src/exports/authoring.ts

@@ -12,11 +12,14 @@ export type {
   AuthoringTypeNamespace,
 } from '../shared/framework-authoring';
 export {
+  assertNoCrossRegistryCollisions,
+  hasRegisteredFieldNamespace,
   instantiateAuthoringFieldPreset,
   instantiateAuthoringTypeConstructor,
   isAuthoringArgRef,
   isAuthoringFieldPresetDescriptor,
   isAuthoringTypeConstructorDescriptor,
+  mergeAuthoringNamespaces,
   resolveAuthoringTemplateValue,
   validateAuthoringHelperArguments,
 } from '../shared/framework-authoring';