@prisma/orm-framework 0.16.0

package/dist/framework-authoring-CDEvlouU-mlMWSksD.mjs

@@ -0,0 +1,698 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+import { t as ifDefined } from "./defined-BQWA85QH-BRSBMULx.mjs";
+import { l as isColumnDefaultLiteralInputValue, u as isExecutionMutationDefaultValue } from "./types-DgdgskBY.mjs";
+import { t as InternalError } from "./internal-error-BIc-ehme-ouBQPoEL.mjs";
+import { n as runtimeError } from "./runtime-error-BA9d7XjZ-BlT8t6LB.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/framework-authoring-CDEvlouU.mjs
+const AUTHORING_WARNING_BATCH_THRESHOLD = 5;
+/**
+* Emits collected authoring warnings once per build, grouped by `code`:
+* a group at or below the threshold itemizes every `message`; above it,
+* one summary — `"<count> <summary>"` followed by the `item` lines — so
+* a build with many hits of one kind does not wall-of-text, and warnings
+* of different codes never batch into each other's summary.
+*/
+function flushAuthoringWarnings(warnings) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const warning of warnings) {
+		const key = `${warning.code}\u0000${warning.summary}`;
+		const group = groups.get(key) ?? [];
+		group.push(warning);
+		groups.set(key, group);
+	}
+	for (const group of groups.values()) {
+		const first = group[0];
+		if (first === void 0) continue;
+		if (group.length <= AUTHORING_WARNING_BATCH_THRESHOLD) {
+			for (const warning of group) process.emitWarning(warning.message, { code: warning.code });
+			continue;
+		}
+		process.emitWarning(`${group.length} ${first.summary}\n${group.map((w) => `  - ${w.item}`).join("\n")}`, { code: first.code });
+	}
+}
+/**
+* Classifies an `enum` block's members (before codec decoding, which needs
+* the codec chosen first) into which default codec an omitted `@@type`
+* should resolve to:
+*
+* - every member is `bare`, or a `value` whose raw JSON is a string → `'text'`
+* - every member is a `value` whose raw JSON is an integer → `'int'`
+* - anything else (float, bigint, boolean, mixed, or a `ref`/`option`/`list`
+*   parameter) → `null`, meaning the caller must require an explicit `@@type`.
+*/
+function classifyEnumMemberType(block) {
+	let sawText = false;
+	let sawInt = false;
+	for (const paramValue of Object.values(block.parameters)) {
+		if (paramValue.kind === "bare") {
+			sawText = true;
+			continue;
+		}
+		if (paramValue.kind !== "value") return null;
+		let jsonValue;
+		try {
+			jsonValue = JSON.parse(paramValue.raw);
+		} catch {
+			return null;
+		}
+		if (typeof jsonValue === "string") sawText = true;
+		else if (typeof jsonValue === "number" && Number.isInteger(jsonValue)) sawInt = true;
+		else return null;
+	}
+	if (sawText && sawInt) return null;
+	if (sawText) return "text";
+	if (sawInt) return "int";
+	return null;
+}
+/**
+* Resolves the codec id for an `enum` block. When `@@type` is absent, the codec
+* is inferred from the members via {@link classifyEnumMemberType}; otherwise the
+* explicit `@@type("codec")` argument is parsed. Pushes the appropriate
+* diagnostic and returns `undefined` when neither yields a codec. `codecSpan` is
+* the span downstream codec-validation diagnostics should anchor to. Shared by
+* every family's enum factory so inference and the explicit path stay identical.
+*/
+function resolveEnumCodecId(block, ctx) {
+	const sourceId = ctx.sourceId ?? "unknown";
+	const typeAttr = block.blockAttributes.find((a) => a.name === "type");
+	if (typeAttr === void 0) {
+		const inferredKind = classifyEnumMemberType(block);
+		if (inferredKind === null || ctx.enumInferenceCodecs === void 0) {
+			ctx.diagnostics?.push({
+				code: "PSL_ENUM_CANNOT_INFER_TYPE",
+				message: `cannot infer @@type for enum "${block.name}"; add an explicit @@type(...)`,
+				sourceId,
+				span: block.span
+			});
+			return;
+		}
+		return {
+			codecId: ctx.enumInferenceCodecs[inferredKind],
+			codecSpan: block.span
+		};
+	}
+	const rawCodecArg = typeAttr.args[0]?.value;
+	const codecId = rawCodecArg?.startsWith("\"") && rawCodecArg.endsWith("\"") && rawCodecArg.length >= 2 ? rawCodecArg.slice(1, -1) : void 0;
+	if (codecId === void 0) {
+		ctx.diagnostics?.push({
+			code: "PSL_ENUM_MISSING_TYPE",
+			message: `enum "${block.name}" @@type attribute must have a quoted codec id argument`,
+			sourceId,
+			span: typeAttr.span
+		});
+		return;
+	}
+	return {
+		codecId,
+		codecSpan: typeAttr.args[0]?.span ?? typeAttr.span
+	};
+}
+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 isAuthoringSelectRef(value) {
+	if (!isAuthoringTemplateRecord(value) || value["kind"] !== "select") return false;
+	const index = value["index"];
+	const path = value["path"];
+	const cases = value["cases"];
+	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 typeof cases === "object" && cases !== null && !Array.isArray(cases);
+}
+function isAuthoringTemplateRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readTemplateArgumentValue(args, index, path) {
+	let value = args[index];
+	for (const segment of path ?? []) {
+		if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) return;
+		value = value[segment];
+	}
+	return value;
+}
+function isAuthoringTypeConstructorDescriptor(value) {
+	return "kind" in value && value.kind === "typeConstructor";
+}
+function isAuthoringFieldPresetDescriptor(value) {
+	return "kind" in value && value.kind === "fieldPreset";
+}
+function isAuthoringEntityTypeDescriptor(value) {
+	return "kind" in value && value.kind === "entity";
+}
+function isAuthoringPslBlockDescriptor(value) {
+	return "kind" in value && value.kind === "pslBlock";
+}
+function isAuthoringModelAttributeDescriptor(value) {
+	return "kind" in value && value.kind === "modelAttribute";
+}
+/**
+* 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;
+	const value = contributions.field[namespace];
+	return value !== void 0 && !isAuthoringFieldPresetDescriptor(value);
+}
+function isCopyableNamespaceObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Deep structural check run only at the composition boundary (the merge and
+* collect walkers) to classify a raw namespace-tree node as a leaf descriptor.
+* A node counts as a leaf iff its `kind` matches `descriptorKind` AND it
+* carries that kind's required fields.
+*
+* This is boundary validation over `unknown`, NOT a type-predicate: the four
+* exported `isAuthoring*Descriptor` predicates deliberately narrow on `kind`
+* alone and trust the static types. The walkers, by contrast, also receive
+* type-bypassing packs (`as unknown as never` in tests, untyped JS at runtime)
+* whose descriptor-shaped-but-incomplete nodes must be rejected rather than
+* silently treated as sub-namespaces — so the well-formedness check lives here.
+*/
+function isWellFormedDescriptor(value, descriptorKind) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("kind" in value) || value.kind !== descriptorKind) return false;
+	switch (descriptorKind) {
+		case "typeConstructor":
+		case "fieldPreset": {
+			if (!("output" in value)) return false;
+			const output = value.output;
+			return typeof output === "object" && output !== null;
+		}
+		case "entity": {
+			if (!("discriminator" in value) || typeof value.discriminator !== "string") return false;
+			if (value.discriminator.length === 0) return false;
+			if (!("output" in value)) return false;
+			const output = value.output;
+			if (typeof output !== "object" || output === null) return false;
+			const factory = "factory" in output ? output.factory : void 0;
+			const template = "template" in output ? output.template : void 0;
+			return typeof factory === "function" || template !== void 0;
+		}
+		case "pslBlock": {
+			if (!("keyword" in value) || typeof value.keyword !== "string" || value.keyword.length === 0) return false;
+			if (!("discriminator" in value) || typeof value.discriminator !== "string" || value.discriminator.length === 0) return false;
+			if (!("name" in value)) return false;
+			const name = value.name;
+			if (typeof name !== "object" || name === null) return false;
+			if (!("required" in name) || typeof name.required !== "boolean") return false;
+			if (!("parameters" in value)) return false;
+			const parameters = value.parameters;
+			return typeof parameters === "object" && parameters !== null && !Array.isArray(parameters);
+		}
+		case "modelAttribute":
+			if (!("attribute" in value) || typeof value.attribute !== "string" || value.attribute.length === 0) return false;
+			if (!("spec" in value)) return false;
+			return "lower" in value && typeof value.lower === "function";
+		default: return false;
+	}
+}
+function deepCopyNamespace(source, descriptorKind) {
+	const copy = {};
+	for (const [key, value] of Object.entries(source)) copy[key] = isCopyableNamespaceObject(value) && !isWellFormedDescriptor(value, descriptorKind) ? deepCopyNamespace(value, descriptorKind) : value;
+	return copy;
+}
+/**
+* Merges `source` into `target` recursively at the descriptor-namespace
+* level. `descriptorKind` is the `kind` value ('typeConstructor',
+* 'fieldPreset', 'entity', or 'pslBlock') that identifies a descriptor
+* (terminal merge point; same-path registrations across components are
+* reported as duplicates) as opposed to a sub-namespace (recursion target).
+*
+* 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, descriptorKind, label) {
+	const assertSafePath = (currentPath) => {
+		const blockedSegment = currentPath.find((segment) => segment === "__proto__" || segment === "constructor" || segment === "prototype");
+		if (blockedSegment) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `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] = isCopyableNamespaceObject(sourceValue) && !isWellFormedDescriptor(sourceValue, descriptorKind) ? deepCopyNamespace(sourceValue, descriptorKind) : sourceValue;
+			continue;
+		}
+		const existingIsLeaf = isWellFormedDescriptor(existingValue, descriptorKind);
+		const sourceIsLeaf = isWellFormedDescriptor(sourceValue, descriptorKind);
+		if (existingIsLeaf || sourceIsLeaf) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Duplicate authoring ${label} helper "${currentPath.join(".")}". Helper names must be unique across composed packs.`);
+		if (!isCopyableNamespaceObject(existingValue) || !isCopyableNamespaceObject(sourceValue)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Invalid authoring ${label} helper "${currentPath.join(".")}". Expected a sub-namespace object or a recognized descriptor; received a malformed value.`);
+		mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, descriptorKind, label);
+	}
+}
+/**
+* Collects the full dotted paths of every well-formed descriptor of
+* `descriptorKind` in a raw contribution tree, using the same boundary
+* classification as {@link mergeAuthoringNamespaces}. Lets assembly-level
+* callers attribute each contributed path to its contributing component
+* before merging, so a same-path collision can be reported naming both
+* contributors.
+*/
+function collectContributedDescriptorPaths(namespace, descriptorKind, path = []) {
+	const paths = [];
+	for (const [key, value] of Object.entries(namespace)) {
+		const currentPath = [...path, key];
+		if (isWellFormedDescriptor(value, descriptorKind)) {
+			paths.push(currentPath.join("."));
+			continue;
+		}
+		if (isCopyableNamespaceObject(value)) paths.push(...collectContributedDescriptorPaths(value, descriptorKind, currentPath));
+	}
+	return paths;
+}
+/**
+* Derives the scalar view of an assembled authoring type namespace: every
+* **top-level** type constructor that is instantiable with an empty argument
+* list — all declared args optional and no entity-ref argument. A bare type
+* name `T` in a schema is semantically the zero-arg instantiation `T()`, so
+* each entry is exactly what that call produces (defaulted template values
+* applied, absent optional-arg typeParams keys omitted). Constructors
+* registered under a namespace segment, constructors with required args, and
+* entity-ref constructors are not scalars and are excluded.
+*
+* Eligibility needs no template inspection: templates that cannot resolve
+* for their legal call shapes are rejected at the composition boundary by
+* {@link assertResolvableTypeConstructorTemplates}, so the zero-arg
+* instantiation below cannot fail for an eligible constructor.
+*/
+function collectScalarTypeConstructors(namespace) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(namespace)) {
+		if (!isAuthoringTypeConstructorDescriptor(value)) continue;
+		if (value.entityRefArg !== void 0) continue;
+		if (value.args?.some((arg) => arg.optional !== true)) continue;
+		result.set(name, instantiateAuthoringTypeConstructor(value, []));
+	}
+	return result;
+}
+function visitTemplateArgRefs(template, visit) {
+	if (template === void 0) return;
+	if (isAuthoringArgRef(template)) {
+		visit(template);
+		visitTemplateArgRefs(template.default, visit);
+		return;
+	}
+	if (Array.isArray(template)) {
+		for (const value of template) visitTemplateArgRefs(value, visit);
+		return;
+	}
+	if (typeof template === "object" && template !== null) for (const value of Object.values(template)) visitTemplateArgRefs(value, visit);
+}
+/**
+* Boundary validation for a contributed authoring type namespace, called
+* per contributing component at assembly (which supplies `contributedBy`
+* for attribution). Rejects what the types cannot express — entity-ref
+* constructors are skipped (their output derives from the referenced
+* entity): a plain constructor must declare its output storage type name,
+* and every `typeParams` arg-ref (including refs inside arg-ref defaults)
+* must point at a declared argument index.
+*/
+function assertResolvableTypeConstructorTemplates(namespace, contributedBy, path = []) {
+	for (const [name, value] of Object.entries(namespace)) {
+		const currentPath = [...path, name];
+		if (!isAuthoringTypeConstructorDescriptor(value)) {
+			assertResolvableTypeConstructorTemplates(value, contributedBy, currentPath);
+			continue;
+		}
+		if (value.entityRefArg !== void 0) continue;
+		const args = value.args ?? [];
+		const invalid = (detail) => /* @__PURE__ */ new Error(`Invalid authoring type constructor "${currentPath.join(".")}" contributed by descriptor "${contributedBy}". ${detail}`);
+		if (value.output.nativeType === void 0) throw invalid("The output declares no storage type template and no entityRefArg; a plain constructor must declare one.");
+		for (const [key, template] of Object.entries(value.output.typeParams ?? {})) visitTemplateArgRefs(template, (ref) => {
+			if (args[ref.index] === void 0) throw invalid(`output.typeParams.${key} references argument ${ref.index}, but the constructor declares ${args.length} argument(s). Declare the argument or correct the reference index.`);
+		});
+	}
+}
+function collectDescriptorPaths(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(...collectDescriptorPaths(value, isLeaf, currentPath));
+	}
+	return paths;
+}
+function collectDescriptorEntries(namespace, isLeaf, descriptorKind, label, path = []) {
+	const entries = [];
+	for (const [key, value] of Object.entries(namespace)) {
+		const currentPath = [...path, key];
+		if (isLeaf(value)) {
+			if (!isWellFormedDescriptor(value, descriptorKind)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Malformed authoring ${label} contribution at "${currentPath.join(".")}". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the ${label} descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);
+			if (value.discriminator.length > 0) entries.push({
+				path: currentPath.join("."),
+				discriminator: value.discriminator
+			});
+			continue;
+		}
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			const record = blindCast(value);
+			if ((record["kind"] !== void 0 || record["keyword"] !== void 0 || record["discriminator"] !== void 0) && !isLeaf(value)) {
+				const hasKind = record["kind"] === "pslBlock";
+				const hasKeyword = typeof record["keyword"] === "string";
+				const hasDiscriminator = typeof record["discriminator"] === "string";
+				if (hasKind || hasKeyword && hasDiscriminator) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Malformed authoring ${label} contribution at "${currentPath.join(".")}". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the ${label} descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);
+			}
+			entries.push(...collectDescriptorEntries(value, isLeaf, descriptorKind, label, currentPath));
+		}
+	}
+	return entries;
+}
+/**
+* Throws when two or more entries in the same namespace share a key. A
+* duplicate key makes dispatch ambiguous — the caller's lookup dispatches by
+* this key, so one entry would silently shadow the other. Catch duplicates
+* before building any dispatch map.
+*
+* `label` (e.g. `'pslBlock'`, `'entityType'`) names which namespace the
+* duplicate was found in and is carried in the structured error metadata;
+* the key itself is always called `key` in both the message and the
+* metadata, since what it semantically represents (a discriminator for
+* `entityType`, the parser's dispatch keyword for `pslBlock`) is the
+* caller's concern, not this function's.
+*/
+function assertUniqueDiscriminators(entries, label) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const { path, discriminator: key } of entries) {
+		const existing = seen.get(key);
+		if (existing !== void 0) throw runtimeError("RUNTIME.DUPLICATE_AUTHORING_DISCRIMINATOR", `Duplicate ${label} key "${key}" registered at both "${existing}" and "${path}". Each ${label} contribution must use a unique key.`, {
+			label,
+			key,
+			existingPath: existing,
+			path
+		});
+		seen.set(key, path);
+	}
+}
+function collectPslBlockDescriptorEntries(namespace, path = []) {
+	const entries = [];
+	for (const [key, value] of Object.entries(namespace)) {
+		const currentPath = [...path, key];
+		if (isAuthoringPslBlockDescriptor(value)) {
+			if (!isWellFormedDescriptor(value, "pslBlock")) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Malformed authoring pslBlock contribution at "${currentPath.join(".")}". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the pslBlock descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);
+			entries.push({
+				path: currentPath.join("."),
+				discriminator: value.discriminator,
+				keyword: value.keyword
+			});
+			continue;
+		}
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			const record = blindCast(value);
+			const hasKind = record["kind"] === "pslBlock";
+			const hasKeyword = typeof record["keyword"] === "string";
+			const hasDiscriminator = typeof record["discriminator"] === "string";
+			if (hasKind || hasKeyword && hasDiscriminator) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Malformed authoring pslBlock contribution at "${currentPath.join(".")}". The value carries descriptor keys (kind/keyword/discriminator) but does not satisfy the pslBlock descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);
+			entries.push(...collectPslBlockDescriptorEntries(value, currentPath));
+		}
+	}
+	return entries;
+}
+/**
+* Every `pslBlockDescriptors` entry requires a matching `entityTypes` factory
+* with the same discriminator. An `entityTypes` factory may stand alone (e.g.
+* `enum`, reachable from the TypeScript builder without any PSL block).
+*
+* Uniqueness for pslBlock entries is keyed on **keyword**, not discriminator:
+* several keywords (e.g. `policy_select`/`policy_insert`) may legitimately
+* share one discriminator, routing to the same `entityTypes` factory and the
+* same `entries[discriminator]` slot — that N:1 shape is exactly what lets
+* one entity kind be authored through several PSL keywords. What must stay
+* unique is the keyword itself, since that's what the parser dispatches on.
+*/
+function assertPslBlocksHaveFactories(entityTypeNamespace, pslBlockNamespace) {
+	const blockEntries = collectPslBlockDescriptorEntries(pslBlockNamespace);
+	const entityEntries = collectDescriptorEntries(entityTypeNamespace, isAuthoringEntityTypeDescriptor, "entity", "entityType");
+	assertUniqueDiscriminators(blockEntries.map((entry) => ({
+		path: entry.path,
+		discriminator: entry.keyword
+	})), "pslBlock");
+	assertUniqueDiscriminators(entityEntries, "entityType");
+	const entityDiscriminators = new Set(entityEntries.map((entry) => entry.discriminator));
+	for (const block of blockEntries) if (!entityDiscriminators.has(block.discriminator)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Incomplete extension contribution: pslBlock helper "${block.path}" registers discriminator "${block.discriminator}" but no entityType contribution shares that discriminator. An extension-contributed PSL block requires a matching entityType factory so the parsed AST node can lower to an IR class instance; add an entityType helper with discriminator "${block.discriminator}".`);
+}
+function collectModelAttributeEntries(namespace, path = []) {
+	const entries = [];
+	for (const [key, value] of Object.entries(namespace)) {
+		const currentPath = [...path, key];
+		if (isAuthoringModelAttributeDescriptor(value)) {
+			if (!isWellFormedDescriptor(value, "modelAttribute")) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Malformed authoring modelAttribute contribution at "${currentPath.join(".")}". The value carries descriptor keys (kind/attribute) but does not satisfy the modelAttribute descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);
+			entries.push({
+				path: currentPath.join("."),
+				discriminator: value.attribute
+			});
+			continue;
+		}
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			const record = blindCast(value);
+			if (typeof record["attribute"] === "string" && "spec" in record) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Malformed authoring modelAttribute contribution at "${currentPath.join(".")}". The value carries descriptor keys (kind/attribute) but does not satisfy the modelAttribute descriptor shape. Fix the contribution so it is a complete descriptor, or remove the stray keys if it was meant to be a sub-namespace.`);
+			entries.push(...collectModelAttributeEntries(value, currentPath));
+		}
+	}
+	return entries;
+}
+/**
+* Throws when two modelAttribute contributions — at any paths, even
+* different ones — claim the same bare `@@` attribute name. The family
+* interpreter dispatches by attribute name, not by registration path, so
+* two descriptors claiming the same name would have one silently shadow
+* the other.
+*/
+function assertUniqueModelAttributeNames(entries) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const { path, discriminator: attribute } of entries) {
+		const existing = seen.get(attribute);
+		if (existing !== void 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Duplicate modelAttribute "${attribute}" registered at both "${existing}" and "${path}". Each modelAttribute contribution must claim a unique attribute name.`);
+		seen.set(attribute, path);
+	}
+}
+function assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace = {}, pslBlockNamespace = {}, modelAttributeNamespace = {}) {
+	const typePaths = new Set(collectDescriptorPaths(typeNamespace, isAuthoringTypeConstructorDescriptor));
+	const fieldPaths = new Set(collectDescriptorPaths(fieldNamespace, isAuthoringFieldPresetDescriptor));
+	const entityPaths = new Set(collectDescriptorPaths(entityTypeNamespace, isAuthoringEntityTypeDescriptor));
+	const ambiguityHint = "Register each path in only one of authoringContributions.field / authoringContributions.type / authoringContributions.entityTypes.";
+	for (const fieldPath of fieldPaths) if (typePaths.has(fieldPath)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Ambiguous authoring registry path "${fieldPath}". The same path is registered as both a type constructor and a field preset; PSL resolution would be ambiguous. ${ambiguityHint}`);
+	for (const entityPath of entityPaths) if (typePaths.has(entityPath) || fieldPaths.has(entityPath)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Ambiguous authoring registry path "${entityPath}". The same path is registered as an entity contribution AND as a type constructor or field preset; PSL resolution would be ambiguous. ${ambiguityHint}`);
+	assertPslBlocksHaveFactories(entityTypeNamespace, pslBlockNamespace);
+	assertUniqueModelAttributeNames(collectModelAttributeEntries(modelAttributeNamespace));
+	assertSelectTemplatesMatchOptionArgs(typeNamespace, fieldNamespace, entityTypeNamespace);
+}
+function collectDescriptorNodes(namespace, isLeaf, path = []) {
+	const nodes = [];
+	for (const [key, value] of Object.entries(namespace)) {
+		const currentPath = [...path, key];
+		if (isLeaf(value)) {
+			nodes.push([currentPath.join("."), value]);
+			continue;
+		}
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) nodes.push(...collectDescriptorNodes(value, isLeaf, currentPath));
+	}
+	return nodes;
+}
+function collectSelectRefs(value, found) {
+	if (typeof value !== "object" || value === null) return;
+	if (isAuthoringSelectRef(value)) {
+		found.push(value);
+		for (const caseTemplate of Object.values(value.cases)) collectSelectRefs(caseTemplate, found);
+		return;
+	}
+	if (isAuthoringArgRef(value)) {
+		collectSelectRefs(value.default, found);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const entry of value) collectSelectRefs(entry, found);
+		return;
+	}
+	for (const entry of Object.values(value)) collectSelectRefs(entry, found);
+}
+function validateSelectRefsAgainstArgs(label, helperPath, args, templateRoot) {
+	const selects = [];
+	collectSelectRefs(templateRoot, selects);
+	for (const select of selects) {
+		const position = `#${select.index + 1}`;
+		let descriptor = args?.[select.index];
+		if (descriptor === void 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring ${label} helper "${helperPath}" select template references argument ${position}, but the helper declares no argument at that position.`);
+		for (const segment of select.path ?? []) {
+			descriptor = descriptor.kind === "object" ? descriptor.properties[segment] : void 0;
+			if (descriptor === void 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring ${label} helper "${helperPath}" select template references argument ${position} at path "${(select.path ?? []).join(".")}", which does not resolve to a declared argument property.`);
+		}
+		if (descriptor.kind !== "option") throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring ${label} helper "${helperPath}" select template references argument ${position}, which is kind "${descriptor.kind}"; select requires an option argument.`);
+		const argumentLabel = descriptor.name !== void 0 ? `"${descriptor.name}"` : position;
+		const missing = descriptor.values.filter((value) => !Object.hasOwn(select.cases, value));
+		if (missing.length > 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring ${label} helper "${helperPath}" option argument ${argumentLabel} allows [${descriptor.values.join(", ")}] but the select template has no case for: ${missing.join(", ")}.`);
+		const values = descriptor.values;
+		const unreachable = Object.keys(select.cases).filter((key) => !values.includes(key));
+		if (unreachable.length > 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring ${label} helper "${helperPath}" select template has case(s) not allowed by option argument ${argumentLabel}: ${unreachable.join(", ")}. Allowed values: [${values.join(", ")}].`);
+	}
+}
+/**
+* Every `select` template node must target an option argument whose `values`
+* exactly cover the node's `cases` — a legal token with no case and a case no
+* token can reach are both declaration bugs, caught here at pack-registration
+* time rather than at first resolution.
+*/
+function assertSelectTemplatesMatchOptionArgs(typeNamespace, fieldNamespace, entityTypeNamespace) {
+	for (const [helperPath, descriptor] of collectDescriptorNodes(fieldNamespace, isAuthoringFieldPresetDescriptor)) validateSelectRefsAgainstArgs("field", helperPath, descriptor.args, descriptor.output);
+	for (const [helperPath, descriptor] of collectDescriptorNodes(typeNamespace, isAuthoringTypeConstructorDescriptor)) validateSelectRefsAgainstArgs("type", helperPath, descriptor.args, descriptor.output);
+	for (const [helperPath, descriptor] of collectDescriptorNodes(entityTypeNamespace, isAuthoringEntityTypeDescriptor)) if ("template" in descriptor.output) validateSelectRefsAgainstArgs("entityType", helperPath, descriptor.args, descriptor.output.template);
+}
+function resolveAuthoringTemplateValue(template, args) {
+	if (template === void 0) return;
+	if (isAuthoringArgRef(template)) {
+		const value = readTemplateArgumentValue(args, template.index, template.path);
+		if (value === void 0 && template.default !== void 0) return resolveAuthoringTemplateValue(template.default, args);
+		return value;
+	}
+	if (isAuthoringSelectRef(template)) {
+		const value = readTemplateArgumentValue(args, template.index, template.path);
+		if (value === void 0) return;
+		if (typeof value !== "string" || !Object.hasOwn(template.cases, value)) throw new InternalError(`Authoring template select has no case for value "${String(value)}"`);
+		return resolveAuthoringTemplateValue(template.cases[value], args);
+	}
+	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 runtimeError("CONTRACT.ARGUMENT_INVALID", `Missing required authoring helper argument at ${path}`);
+	}
+	if (descriptor.kind === "string") {
+		if (typeof value !== "string") throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be a string`);
+		return;
+	}
+	if (descriptor.kind === "boolean") {
+		if (typeof value !== "boolean") throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be a boolean`);
+		return;
+	}
+	if (descriptor.kind === "stringArray") {
+		if (!Array.isArray(value)) throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be an array of strings`);
+		for (const entry of value) if (typeof entry !== "string") throw runtimeError("CONTRACT.ARGUMENT_INVALID", `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 runtimeError("CONTRACT.ARGUMENT_INVALID", `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 runtimeError("CONTRACT.ARGUMENT_INVALID", `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 (descriptor.kind === "option") {
+		if (typeof value !== "string" || !descriptor.values.includes(value)) throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be one of: ${descriptor.values.join(", ")}`);
+		return;
+	}
+	if (typeof value !== "number" || Number.isNaN(value)) throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be a number`);
+	if (descriptor.integer && !Number.isInteger(value)) throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be an integer`);
+	if (descriptor.minimum !== void 0 && value < descriptor.minimum) throw runtimeError("CONTRACT.ARGUMENT_INVALID", `Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`);
+	if (descriptor.maximum !== void 0 && value > descriptor.maximum) throw runtimeError("CONTRACT.ARGUMENT_INVALID", `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 runtimeError("CONTRACT.ARGUMENT_INVALID", `${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 = template.nativeType;
+	if (nativeType === void 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring output template for codec "${template.codecId}" declares no nativeType; only entity-ref constructors may omit it`);
+	const typeParams = template.typeParams === void 0 ? void 0 : resolveAuthoringTemplateValue(template.typeParams, args);
+	if (typeParams !== void 0 && !isAuthoringTemplateRecord(typeParams)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Resolved authoring typeParams must be an object for codec "${template.codecId}", received ${String(typeParams)}`);
+	const normalizedTypeParams = typeParams !== void 0 && Object.keys(typeParams).length === 0 ? void 0 : typeParams;
+	return {
+		codecId: template.codecId,
+		nativeType,
+		...ifDefined("typeParams", normalizedTypeParams)
+	};
+}
+function resolveAuthoringColumnDefaultTemplate(template, args) {
+	if (template.kind === "literal") {
+		const value = resolveAuthoringTemplateValue(template.value, args);
+		if (value === void 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", "Resolved authoring literal default must not be undefined");
+		if (!isColumnDefaultLiteralInputValue(value)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `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 runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `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 (value === void 0) return;
+	if (!isExecutionMutationDefaultValue(value)) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Authoring preset executionDefaults.${phase} did not resolve to a valid generator descriptor (kind: 'generator', id: string).`);
+	return value;
+}
+function resolveAuthoringExecutionDefaultsTemplate(template, args) {
+	const phases = {
+		...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)
+	};
+	return Object.keys(phases).length === 0 ? void 0 : phases;
+}
+function instantiateAuthoringTypeConstructor(descriptor, args) {
+	return resolveAuthoringStorageTypeTemplate(descriptor.output, args);
+}
+function instantiateAuthoringEntityType(helperPath, descriptor, args, ctx) {
+	if ("factory" in descriptor.output) {
+		const input = args[0];
+		return blindCast(descriptor.output.factory)(input, ctx);
+	}
+	validateAuthoringHelperArguments(helperPath, descriptor.args, args);
+	return blindCast(resolveAuthoringTemplateValue(descriptor.output.template, 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 { mergeAuthoringNamespaces as _, collectScalarTypeConstructors as a, validateAuthoringHelperArguments as b, instantiateAuthoringEntityType as c, isAuthoringArgRef as d, isAuthoringEntityTypeDescriptor as f, isAuthoringTypeConstructorDescriptor as g, isAuthoringPslBlockDescriptor as h, collectContributedDescriptorPaths as i, instantiateAuthoringFieldPreset as l, isAuthoringModelAttributeDescriptor as m, assertResolvableTypeConstructorTemplates as n, flushAuthoringWarnings as o, isAuthoringFieldPresetDescriptor as p, classifyEnumMemberType as r, hasRegisteredFieldNamespace as s, assertNoCrossRegistryCollisions as t, instantiateAuthoringTypeConstructor as u, resolveAuthoringTemplateValue as v, resolveEnumCodecId as y };
+
+//# sourceMappingURL=framework-authoring-CDEvlouU-mlMWSksD.mjs.map