@prisma/orm-framework 0.16.0

package/dist/control-CBvTj7Ia.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-CBvTj7Ia.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/control.d.mts"],"mappings":"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"}

package/dist/control-DTouE89s.mjs

@@ -0,0 +1,621 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+import { t as InternalError } from "./internal-error-BIc-ehme-ouBQPoEL.mjs";
+import { _ as mergeAuthoringNamespaces, a as collectScalarTypeConstructors, i as collectContributedDescriptorPaths, n as assertResolvableTypeConstructorTemplates, t as assertNoCrossRegistryCollisions } from "./framework-authoring-CDEvlouU-mlMWSksD.mjs";
+import { n as materializeCodec, r as resolveCodecDescriptorOrThrow, t as CONTRACT_CODEC_DESCRIPTOR_MISSING } from "./resolve-codec-BZF8TZh_-D-xORT9Q.mjs";
+import { t as mergeCapabilityMatrices } from "./capabilities-CPj7MfXO-GRkp0Q_D.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/control.mjs
+const CONTRACT_SNAPSHOTS_DIRNAME = "snapshots";
+const STORAGE_HASH_PATTERN = /^[0-9a-f]{64}$/;
+/** Validate a storage hash for use as a directory name. */
+function storageHashHex(storageHash) {
+	if (!STORAGE_HASH_PATTERN.test(storageHash)) throw new InternalError(`Invalid storage hash "${storageHash}": expected 64 lowercase hex characters`);
+	return storageHash;
+}
+/** Module specifier for the store's `contract.json`, POSIX separators. */
+function contractSnapshotJsonSpecifier(snapshotsImportPath, storageHash) {
+	return `${snapshotsImportPath}/${storageHashHex(storageHash)}/contract.json`;
+}
+/** Type-only module specifier for the store's `contract.d.ts` (no extension). */
+function contractSnapshotTypesSpecifier(snapshotsImportPath, storageHash) {
+	return `${snapshotsImportPath}/${storageHashHex(storageHash)}/contract`;
+}
+function hasMigrations(target) {
+	return "migrations" in target && !!target["migrations"];
+}
+function hasSchemaView(instance) {
+	return "toSchemaView" in instance && typeof instance["toSchemaView"] === "function";
+}
+function hasPslContractInfer(instance) {
+	return "inferPslContract" in instance && typeof instance["inferPslContract"] === "function";
+}
+function hasOperationPreview(instance) {
+	return "toOperationPreview" in instance && typeof instance["toOperationPreview"] === "function";
+}
+function hasSchemaSubjectClassifier(instance) {
+	return "classifySubjectGranularity" in instance && typeof instance["classifySubjectGranularity"] === "function" && "classifyEntityKind" in instance && typeof instance["classifyEntityKind"] === "function";
+}
+const VERIFY_CODE_MARKER_MISSING = "CONTRACT.MARKER_MISSING";
+const VERIFY_CODE_HASH_MISMATCH = "CONTRACT.MARKER_MISMATCH";
+const VERIFY_CODE_TARGET_MISMATCH = "CONTRACT.TARGET_MISMATCH";
+const VERIFY_CODE_SCHEMA_FAILURE = "CONTRACT.SCHEMA_VERIFICATION_FAILED";
+var SchemaTreeNode = class {
+	kind;
+	id;
+	label;
+	meta;
+	children;
+	constructor(options) {
+		this.kind = options.kind;
+		this.id = options.id;
+		this.label = options.label;
+		if (options.meta !== void 0) this.meta = options.meta;
+		if (options.children !== void 0) this.children = options.children;
+		Object.freeze(this);
+	}
+	accept(visitor) {
+		return visitor.visit(this);
+	}
+};
+/**
+* Canonical control-plane identifiers for contract spaces.
+*
+* A contract space is the disjoint `(contract.json, migration-graph)` unit
+* the per-space planner / runner / verifier (project: extension contract
+* spaces, TML-2397) operates on. The application owns one well-known
+* space — the value below — and each loaded extension that contributes
+* schema owns a uniquely-named space.
+*
+* Lives in `framework-components/control` so every layer that has to
+* reason about space identity (the migration tooling, the SQL runtime's
+* marker reader, target-side statement builders, target-side adapters)
+* can import a single value rather than duplicating the literal. Raw
+* `'app'` string literals in framework / target / runtime / adapter
+* source code are forbidden and policed by
+* `scripts/lint-app-space-id.mjs` (wired into `pnpm lint:deps`).
+*
+* @see specs/framework-mechanism.spec.md § 3 — Layout convention (γ).
+*/
+const APP_SPACE_ID = "app";
+function addUniqueId(ids, seen, id) {
+	if (!seen.has(id)) {
+		ids.push(id);
+		seen.add(id);
+	}
+}
+function assertUniqueCodecOwner(options) {
+	const existingOwner = options.owners.get(options.codecId);
+	if (existingOwner !== void 0) throw new InternalError(`Duplicate ${options.entityLabel} for codecId "${options.codecId}". Descriptor "${options.descriptorId}" conflicts with "${existingOwner}". Each codecId can only have one ${options.entityOwnershipLabel}.`);
+}
+function extractCodecTypeImports(descriptors) {
+	const imports = [];
+	for (const descriptor of descriptors) {
+		const codecTypes = descriptor.types?.codecTypes;
+		if (codecTypes?.import) imports.push(codecTypes.import);
+		if (codecTypes?.typeImports) imports.push(...codecTypes.typeImports);
+	}
+	return imports;
+}
+function extractQueryOperationTypeImports(descriptors) {
+	const imports = [];
+	for (const descriptor of descriptors) {
+		const queryOperationTypes = descriptor.types?.queryOperationTypes;
+		if (queryOperationTypes?.import) imports.push(queryOperationTypes.import);
+	}
+	return imports;
+}
+function extractComponentIds(family, target, adapter, extensions) {
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	addUniqueId(ids, seen, family.id);
+	addUniqueId(ids, seen, target.id);
+	if (adapter) addUniqueId(ids, seen, adapter.id);
+	for (const ext of extensions) addUniqueId(ids, seen, ext.id);
+	return ids;
+}
+function assembleAuthoringContributions(descriptors) {
+	const field = {};
+	const type = {};
+	const entityTypes = {};
+	const pslBlockDescriptors = {};
+	const modelAttributes = {};
+	const pathOwners = /* @__PURE__ */ new Map();
+	const claimContributedPaths = (namespace, descriptorKind, label, descriptorId) => {
+		for (const path of collectContributedDescriptorPaths(namespace, descriptorKind)) {
+			const key = `${label}:${path}`;
+			const existingOwner = pathOwners.get(key);
+			if (existingOwner !== void 0) throw new InternalError(`Duplicate authoring ${label} helper "${path}". Descriptor "${descriptorId}" conflicts with "${existingOwner}".`);
+			pathOwners.set(key, descriptorId);
+		}
+	};
+	let valueObjectStorageDeclaration;
+	for (const descriptor of descriptors) {
+		const descriptorId = descriptor.id ?? "<unknown>";
+		const declaredValueObjectStorageType = descriptor.authoring?.valueObjectStorageType;
+		if (declaredValueObjectStorageType !== void 0) {
+			if (valueObjectStorageDeclaration !== void 0) throw new InternalError(`Duplicate authoring valueObjectStorageType declaration. Descriptor "${descriptorId}" conflicts with "${valueObjectStorageDeclaration.ownerId}". Exactly one composed component may declare the value-object storage type.`);
+			valueObjectStorageDeclaration = {
+				name: declaredValueObjectStorageType,
+				ownerId: descriptorId
+			};
+		}
+		if (descriptor.authoring?.field) {
+			claimContributedPaths(descriptor.authoring.field, "fieldPreset", "field", descriptorId);
+			mergeAuthoringNamespaces(field, descriptor.authoring.field, [], "fieldPreset", "field");
+		}
+		if (descriptor.authoring?.type) {
+			claimContributedPaths(descriptor.authoring.type, "typeConstructor", "type", descriptorId);
+			assertResolvableTypeConstructorTemplates(descriptor.authoring.type, descriptorId);
+			mergeAuthoringNamespaces(type, descriptor.authoring.type, [], "typeConstructor", "type");
+		}
+		if (descriptor.authoring?.entityTypes) {
+			claimContributedPaths(descriptor.authoring.entityTypes, "entity", "entity", descriptorId);
+			mergeAuthoringNamespaces(entityTypes, descriptor.authoring.entityTypes, [], "entity", "entity");
+		}
+		if (descriptor.authoring?.pslBlockDescriptors) {
+			claimContributedPaths(descriptor.authoring.pslBlockDescriptors, "pslBlock", "pslBlock", descriptorId);
+			mergeAuthoringNamespaces(pslBlockDescriptors, descriptor.authoring.pslBlockDescriptors, [], "pslBlock", "pslBlock");
+		}
+		if (descriptor.authoring?.modelAttributes) mergeAuthoringNamespaces(modelAttributes, descriptor.authoring.modelAttributes, [], "modelAttribute", "modelAttribute");
+	}
+	const fieldNamespace = field;
+	const typeNamespace = type;
+	const entityTypeNamespace = entityTypes;
+	const pslBlockDescriptorNamespace = blindCast(pslBlockDescriptors);
+	const modelAttributeNamespace = blindCast(modelAttributes);
+	assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace, pslBlockDescriptorNamespace, modelAttributeNamespace);
+	if (valueObjectStorageDeclaration !== void 0 && !collectScalarTypeConstructors(typeNamespace).has(valueObjectStorageDeclaration.name)) throw new InternalError(`Invalid authoring valueObjectStorageType "${valueObjectStorageDeclaration.name}" declared by descriptor "${valueObjectStorageDeclaration.ownerId}". The name must be a top-level bare-eligible type constructor in the assembled authoring namespace.`);
+	return {
+		field: fieldNamespace,
+		type: typeNamespace,
+		entityTypes: entityTypeNamespace,
+		pslBlockDescriptors: pslBlockDescriptorNamespace,
+		modelAttributes: modelAttributeNamespace,
+		...valueObjectStorageDeclaration !== void 0 ? { valueObjectStorageType: valueObjectStorageDeclaration.name } : {}
+	};
+}
+function assembleControlMutationDefaults(descriptors) {
+	const defaultFunctionRegistry = /* @__PURE__ */ new Map();
+	const functionOwners = /* @__PURE__ */ new Map();
+	const generatorMap = /* @__PURE__ */ new Map();
+	const generatorOwners = /* @__PURE__ */ new Map();
+	for (const descriptor of descriptors) {
+		const contributions = descriptor.controlMutationDefaults;
+		if (!contributions) continue;
+		const descriptorId = descriptor.id ?? "<unknown>";
+		for (const generatorDescriptor of contributions.generatorDescriptors) {
+			const existingOwner = generatorOwners.get(generatorDescriptor.id);
+			if (existingOwner !== void 0) throw new InternalError(`Duplicate mutation default generator id "${generatorDescriptor.id}". Descriptor "${descriptorId}" conflicts with "${existingOwner}".`);
+			generatorMap.set(generatorDescriptor.id, generatorDescriptor);
+			generatorOwners.set(generatorDescriptor.id, descriptorId);
+		}
+		for (const [functionName, handler] of contributions.defaultFunctionRegistry) {
+			const existingOwner = functionOwners.get(functionName);
+			if (existingOwner !== void 0) throw new InternalError(`Duplicate mutation default function "${functionName}". Descriptor "${descriptorId}" conflicts with "${existingOwner}".`);
+			defaultFunctionRegistry.set(functionName, handler);
+			functionOwners.set(functionName, descriptorId);
+		}
+	}
+	return {
+		defaultFunctionRegistry,
+		generatorDescriptors: Array.from(generatorMap.values())
+	};
+}
+function extractCodecLookup(descriptors) {
+	const byId = /* @__PURE__ */ new Map();
+	const descriptorsById = /* @__PURE__ */ new Map();
+	const targetTypesById = /* @__PURE__ */ new Map();
+	const renderersById = /* @__PURE__ */ new Map();
+	const inputRenderersById = /* @__PURE__ */ new Map();
+	const valueLiteralRenderersById = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Map();
+	for (const descriptor of descriptors) {
+		const codecTypes = descriptor.types?.codecTypes;
+		const descriptorId = descriptor.id;
+		for (const codecDescriptor of codecTypes?.codecDescriptors ?? []) {
+			assertUniqueCodecOwner({
+				codecId: codecDescriptor.codecId,
+				owners,
+				descriptorId,
+				entityLabel: "codec descriptor",
+				entityOwnershipLabel: "codec descriptor provider"
+			});
+			owners.set(codecDescriptor.codecId, descriptorId);
+			descriptorsById.set(codecDescriptor.codecId, codecDescriptor);
+			if (Array.isArray(codecDescriptor.targetTypes)) targetTypesById.set(codecDescriptor.codecId, codecDescriptor.targetTypes);
+			if (typeof codecDescriptor.renderOutputType === "function") renderersById.set(codecDescriptor.codecId, codecDescriptor.renderOutputType);
+			if (typeof codecDescriptor.renderInputType === "function") inputRenderersById.set(codecDescriptor.codecId, codecDescriptor.renderInputType);
+			if (typeof codecDescriptor.renderValueLiteral === "function") valueLiteralRenderersById.set(codecDescriptor.codecId, codecDescriptor.renderValueLiteral);
+			if (!byId.has(codecDescriptor.codecId)) if (codecDescriptor.isParameterized) try {
+				const representative = codecDescriptor.factory({})({ name: `<lookup:${codecDescriptor.codecId}>` });
+				byId.set(codecDescriptor.codecId, representative);
+			} catch {}
+			else {
+				const representative = codecDescriptor.factory(void 0)({ name: `<lookup:${codecDescriptor.codecId}>` });
+				byId.set(codecDescriptor.codecId, representative);
+			}
+		}
+	}
+	return {
+		get: (id) => byId.get(id),
+		forCodecRef(ref) {
+			return materializeCodec(resolveCodecDescriptorOrThrow((id) => descriptorsById.get(id), ref, CONTRACT_CODEC_DESCRIPTOR_MISSING), ref, { name: `<ref:${ref.codecId}>` });
+		},
+		forColumn: () => void 0,
+		targetTypesFor: (id) => targetTypesById.get(id),
+		renderOutputTypeFor: (id, params) => renderersById.get(id)?.(params),
+		renderInputTypeFor: (id, params) => inputRenderersById.get(id)?.(params),
+		renderValueLiteralFor: (id, value, side) => valueLiteralRenderersById.get(id)?.(value, side),
+		descriptorFor: (id) => descriptorsById.get(id)
+	};
+}
+function assembleExtensionContracts(extensions) {
+	const result = /* @__PURE__ */ new Map();
+	for (const ext of extensions) {
+		if (ext.contractSpace === void 0) continue;
+		result.set(ext.id, ext.contractSpace.contractJson);
+	}
+	return result;
+}
+function readDeclaredDependencyIds(descriptor) {
+	const packs = descriptor.contractSpace?.contractJson?.extensions;
+	if (packs === null || typeof packs !== "object") return [];
+	return Object.keys(packs);
+}
+/**
+* Builds a dependency-respecting load order for the given extension descriptors
+* using Kahn's topological sort algorithm. Dependencies (packs declared in
+* `contractSpace.contractJson.extensions`) are placed before the extensions
+* that depend on them.
+*
+* Throws if the dependency graph contains a cycle, with an error message that
+* names every extension involved in the cycle.
+*
+* Throws if any extension declares a dependency on a pack ID that is not present
+* in the provided list — add the missing pack to the `extensions` list to
+* resolve the error.
+*/
+function buildExtensionLoadOrder(extensions) {
+	if (extensions.length === 0) return [];
+	const idSet = new Set(extensions.map((e) => e.id));
+	const inDegree = /* @__PURE__ */ new Map();
+	const dependents = /* @__PURE__ */ new Map();
+	for (const ext of extensions) {
+		if (!inDegree.has(ext.id)) inDegree.set(ext.id, 0);
+		if (!dependents.has(ext.id)) dependents.set(ext.id, []);
+	}
+	for (const ext of extensions) for (const depId of readDeclaredDependencyIds(ext)) {
+		if (!idSet.has(depId)) throw new InternalError(`Extension "${ext.id}" declares a dependency on "${depId}", but "${depId}" is not in the provided extension set. Add the missing space to extensions.`);
+		inDegree.set(ext.id, (inDegree.get(ext.id) ?? 0) + 1);
+		const list = dependents.get(depId);
+		if (list !== void 0) list.push(ext.id);
+	}
+	const queue = [];
+	for (const [id, deg] of inDegree) if (deg === 0) queue.push(id);
+	queue.sort();
+	const result = [];
+	while (queue.length > 0) {
+		const id = queue.shift();
+		if (id === void 0) break;
+		result.push(id);
+		const children = dependents.get(id) ?? [];
+		children.sort();
+		for (const childId of children) {
+			const newDeg = (inDegree.get(childId) ?? 1) - 1;
+			inDegree.set(childId, newDeg);
+			if (newDeg === 0) queue.push(childId);
+		}
+	}
+	if (result.length < extensions.length) throw new InternalError(`Extension dependency cycle detected. Cycle members: ${extensions.map((e) => e.id).filter((id) => !result.includes(id)).sort().map((id) => `"${id}"`).join(", ")}.`);
+	return result;
+}
+function createControlStack(input) {
+	const { family, target, adapter, driver, extensions = [] } = input;
+	const orderedIds = buildExtensionLoadOrder(extensions);
+	const extensionById = new Map(extensions.map((ext) => [ext.id, ext]));
+	const orderedExtensions = orderedIds.map((id) => extensionById.get(id)).filter((ext) => ext !== void 0);
+	const allDescriptors = [
+		family,
+		target,
+		...adapter ? [adapter] : [],
+		...orderedExtensions
+	];
+	const codecLookup = extractCodecLookup(allDescriptors);
+	const authoringContributions = assembleAuthoringContributions(allDescriptors);
+	return {
+		family,
+		target,
+		adapter,
+		driver,
+		extensions: orderedExtensions,
+		extensionContracts: assembleExtensionContracts(orderedExtensions),
+		codecTypeImports: extractCodecTypeImports(allDescriptors),
+		queryOperationTypeImports: extractQueryOperationTypeImports(allDescriptors),
+		extensionIds: extractComponentIds(family, target, adapter, orderedExtensions),
+		codecLookup,
+		authoringContributions,
+		scalarTypes: [...collectScalarTypeConstructors(authoringContributions.type).keys()],
+		controlMutationDefaults: assembleControlMutationDefaults(allDescriptors),
+		capabilities: mergeCapabilityMatrices({}, [
+			target,
+			...adapter ? [adapter] : [],
+			...orderedExtensions
+		])
+	};
+}
+const PATH_DELIMITER = " ";
+function pathKey(path) {
+	return path.join(PATH_DELIMITER);
+}
+/**
+* Whether an issue's op builds its subject up (create or alter) rather than
+* only tearing it down. The differ sets `expected` on every create (`not-found`)
+* and alter (`not-equal`) issue and leaves it absent on a pure drop
+* (`not-expected`). This is the single signal the ordering law reads for edge
+* direction — never `reason`.
+*/
+function buildsUp(issue) {
+	return issue.expected !== void 0;
+}
+/**
+* The nearest strict-ancestor bucket of `path` — the surviving parent entity a
+* child is contained by. Walks the path's proper prefixes from longest to
+* shortest and returns the first prefix that maps to a bucket; a gap (a prefix
+* with no bucket) is skipped so containment always attaches to the closest real
+* parent.
+*
+* Returns a list because a path prefix can be shared by two siblings of
+* different `nodeKind` (a role and a namespace named alike); linking the child
+* to every candidate over-constrains safely (the extra edge points at a same-
+* direction op and never forms a cycle, since a parent never depends on its
+* child) rather than risk picking the wrong one.
+*/
+function nearestAncestors(path, byPath) {
+	for (let end = path.length - 1; end >= 1; end -= 1) {
+		const bucket = byPath.get(pathKey(path.slice(0, end)));
+		if (bucket !== void 0) return bucket;
+	}
+	return [];
+}
+/**
+* Orders schema-diff issues so that every dependency's op precedes its
+* dependent on the way up and follows it on the way down, breaking ties
+* deterministically by path.
+*
+* Edges come from two sources:
+* - **`dependsOn` cross-links** — the resolved issue-to-issue paths the differ
+*   mirrors onto each issue (a node's declared structural prerequisites). A
+*   path that resolves to no issue in this list is skipped (the dependency is
+*   satisfied by reality); a path shared by two same-id/different-kind siblings
+*   links to every match, over-constraining safely.
+* - **containment** — every issue depends on its nearest strict-ancestor issue
+*   (a child entity on the parent entity that owns it). Subtree coalescing has
+*   already removed the descendants of a whole create/drop, so this only links
+*   the parent/child pairs that legitimately survive together.
+*
+* The ordering law reads each dependent's presence for direction: an issue that
+* builds up (`expected` present — a create or alter) needs its dependency
+* first; a pure drop needs its dependent removed first, so the edge reverses.
+* The graph is a DAG by construction (dependencies point from dependents to
+* their prerequisites, and prerequisites never point back), so a cycle is a
+* derivation or authoring bug: the topological sort asserts acyclicity and
+* throws, naming the issues it could not place.
+*/
+function orderIssuesByDependencies(issues) {
+	if (issues.length <= 1) return issues;
+	const nodes = issues.map((issue) => ({
+		issue,
+		key: pathKey(issue.path),
+		buildsUp: buildsUp(issue),
+		outgoing: /* @__PURE__ */ new Set(),
+		inDegree: 0
+	}));
+	const nodesByPath = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const bucket = nodesByPath.get(node.key);
+		if (bucket === void 0) nodesByPath.set(node.key, [node]);
+		else bucket.push(node);
+	}
+	const addEdge = (before, after) => {
+		if (before.outgoing.has(after)) return;
+		before.outgoing.add(after);
+		after.inDegree += 1;
+	};
+	const addDependency = (dependent, dependency) => {
+		if (dependent === dependency) return;
+		if (dependent.buildsUp) addEdge(dependency, dependent);
+		else addEdge(dependent, dependency);
+	};
+	for (const node of nodes) {
+		for (const targetPath of node.issue.dependsOn ?? []) for (const target of nodesByPath.get(pathKey(targetPath)) ?? []) addDependency(node, target);
+		for (const ancestor of nearestAncestors(node.issue.path, nodesByPath)) addDependency(node, ancestor);
+	}
+	const ready = nodes.filter((node) => node.inDegree === 0);
+	const order = [];
+	while (ready.length > 0) {
+		let best;
+		for (const candidate of ready) if (best === void 0 || candidate.key < best.key) best = candidate;
+		if (best === void 0) break;
+		ready.splice(ready.indexOf(best), 1);
+		order.push(best);
+		for (const next of best.outgoing) {
+			next.inDegree -= 1;
+			if (next.inDegree === 0) ready.push(next);
+		}
+	}
+	if (order.length !== nodes.length) {
+		const placed = new Set(order);
+		throw new InternalError(`orderIssuesByDependencies: dependency cycle among schema-diff issues (unresolved: ${nodes.filter((node) => !placed.has(node)).map((node) => node.issue.path.join("/")).join(", ")})`);
+	}
+	return order.map((node) => node.issue);
+}
+/**
+* The outcome an issue represents, discriminated by presence rather than any
+* stored field — the single source of truth every consumer reads. An issue
+* always carries at least one side by construction; neither is a malformed
+* issue and throws.
+*/
+function issueOutcome(issue) {
+	const hasExpected = issue.expected !== void 0;
+	const hasActual = issue.actual !== void 0;
+	if (hasExpected && hasActual) return "not-equal";
+	if (hasExpected) return "not-found";
+	if (hasActual) return "not-expected";
+	throw new InternalError(`issueOutcome: issue at "${issue.path.join("/")}" carries neither an expected nor an actual node`);
+}
+/** Delimiter joining `nodeKind` and `id` into one sibling-map key. Every `nodeKind` is a code-defined literal (kebab-case-style), so a null character can never appear in one. */
+const SIBLING_KEY_DELIMITER = "\0";
+function siblingKey(node) {
+	return `${node.nodeKind}${SIBLING_KEY_DELIMITER}${node.id}`;
+}
+function insertNode(map, node) {
+	const key = siblingKey(node);
+	if (map.has(key)) throw new InternalError(`diffSchemas: duplicate id among siblings: ${node.nodeKind}/${node.id}`);
+	map.set(key, node);
+}
+function emitMissingSubtree(node, parentPath) {
+	const path = [...parentPath, node.id];
+	return [{
+		path,
+		expected: node
+	}, ...node.children().flatMap((c) => emitMissingSubtree(c, path))];
+}
+function emitExtraSubtree(node, parentPath) {
+	const path = [...parentPath, node.id];
+	return [{
+		path,
+		actual: node
+	}, ...node.children().flatMap((c) => emitExtraSubtree(c, path))];
+}
+/**
+* Diff two schema trees starting from their roots.
+*
+* The differ is **total**: every node-level difference is reported. An unmatched
+* non-leaf node emits its own issue and descends, emitting an issue for every
+* node in the missing/extra subtree. Coalescing a parent change over its
+* children is the planner's responsibility. Ownership filtering (dropping `extra`
+* issues in namespaces a contract doesn't own) is the caller's responsibility.
+*/
+function diffSchemas(expected, actual) {
+	return mirrorDependsOnOntoIssues(diffPair(expected, actual, []));
+}
+function schemaNodeRefKey(ref) {
+	return ref.map((step) => step.id).join(SIBLING_KEY_DELIMITER);
+}
+function issuePathKey(path) {
+	return path.join(SIBLING_KEY_DELIMITER);
+}
+function terminalNodeKind(issue) {
+	return (issue.expected ?? issue.actual)?.nodeKind;
+}
+/**
+* Copies each issue's node's `dependsOn` refs onto the issue itself, as
+* issue-to-issue path references. A ref is kept only when some emitted issue
+* sits at that exact path AND that issue's node `nodeKind` matches the ref's
+* last step — otherwise the ref is dropped (its target either didn't
+* change, or was never part of either tree; either way the dependency is
+* satisfied by reality, not by an operation this diff will produce).
+*
+* The path index is a multimap: two siblings may share an `id` under
+* different `nodeKind`s (a role and a namespace named alike), so an id-path
+* alone is ambiguous. The ref's terminal `nodeKind` disambiguates — the ref
+* resolves only against a same-path issue whose own node carries that kind.
+*/
+function mirrorDependsOnOntoIssues(issues) {
+	const issuesByPath = /* @__PURE__ */ new Map();
+	for (const issue of issues) {
+		const key = issuePathKey(issue.path);
+		const bucket = issuesByPath.get(key);
+		if (bucket === void 0) issuesByPath.set(key, [issue]);
+		else bucket.push(issue);
+	}
+	return issues.map((issue) => {
+		const refs = (issue.expected ?? issue.actual)?.dependsOn;
+		if (refs === void 0 || refs.length === 0) return issue;
+		const dependsOn = refs.flatMap((ref) => {
+			const lastStep = ref[ref.length - 1];
+			if (lastStep === void 0) return [];
+			if (!(issuesByPath.get(schemaNodeRefKey(ref)) ?? []).some((c) => terminalNodeKind(c) === lastStep.nodeKind)) return [];
+			return [ref.map((step) => step.id)];
+		});
+		if (dependsOn.length === 0) return issue;
+		return {
+			...issue,
+			dependsOn
+		};
+	});
+}
+function diffPair(expected, actual, parentPath) {
+	const path = [...parentPath, expected.id];
+	const issues = [];
+	if (!expected.isEqualTo(actual)) issues.push({
+		path,
+		expected,
+		actual
+	});
+	issues.push(...diffChildren(expected.children(), actual.children(), path));
+	return issues;
+}
+/**
+* Align one level of nodes by `(nodeKind, id)`; emit issues in input order
+* and recurse.
+*
+* A missing node emits one issue for itself and one for every node in its
+* subtree (total descent). Same for extra nodes. A matched pair recurses via
+* `diffPair`.
+*/
+function diffChildren(expected, actual, parentPath) {
+	const expectedMap = /* @__PURE__ */ new Map();
+	for (const node of expected) insertNode(expectedMap, node);
+	const actualMap = /* @__PURE__ */ new Map();
+	for (const node of actual) insertNode(actualMap, node);
+	const issues = [];
+	for (const [key, expectedNode] of expectedMap) {
+		const actualNode = actualMap.get(key);
+		if (actualNode === void 0) issues.push(...emitMissingSubtree(expectedNode, parentPath));
+		else issues.push(...diffPair(expectedNode, actualNode, parentPath));
+	}
+	for (const [key, actualNode] of actualMap) if (!expectedMap.has(key)) issues.push(...emitExtraSubtree(actualNode, parentPath));
+	return issues;
+}
+/**
+* The result of diffing a contract's expected schema against the introspected
+* actual schema: one node-typed issue list. Carries no verdict, verification
+* tree, or counts — those are the verifier's own presentation, built from the
+* same underlying comparison.
+*
+* `TNode` is the concrete schema-IR node the issues carry; it defaults to
+* `DiffableNode`, so this is purely additive — a caller that wants the
+* concrete node opts in (the Postgres planner uses the concrete node type),
+* everyone else keeps the default unchanged.
+*/
+var SchemaDiff = class SchemaDiff {
+	issues;
+	constructor(issues) {
+		this.issues = issues;
+	}
+	/** Returns a new `SchemaDiff` narrowed to the issues `keep` returns true for. */
+	filter(keep) {
+		return new SchemaDiff(this.issues.filter(keep));
+	}
+};
+/**
+* Grades a target-neutral issue category against a control policy.
+*
+* - `observed` warns on everything.
+* - `tolerated` suppresses only an extra nested element (everything else fails).
+* - `external` suppresses every extra category and value drift (existence and
+*   declared-shape divergences still fail).
+* - `managed` (and any other) fails.
+*/
+function dispositionForCategory(controlPolicy, category) {
+	if (controlPolicy === "observed") return "warn";
+	if (controlPolicy === "tolerated" && category === "extraNestedElement") return "suppress";
+	if (controlPolicy === "external") {
+		if (category === "extraNestedElement" || category === "extraAuxiliary" || category === "extraTopLevelObject" || category === "valueDrift") return "suppress";
+	}
+	return "fail";
+}
+//#endregion
+export { hasOperationPreview as C, issueOutcome as D, hasSchemaView as E, orderIssuesByDependencies as O, hasMigrations as S, hasSchemaSubjectClassifier as T, dispositionForCategory as _, VERIFY_CODE_HASH_MISMATCH as a, extractComponentIds as b, VERIFY_CODE_TARGET_MISMATCH as c, assertUniqueCodecOwner as d, buildExtensionLoadOrder as f, diffSchemas as g, createControlStack as h, SchemaTreeNode as i, storageHashHex as k, assembleAuthoringContributions as l, contractSnapshotTypesSpecifier as m, CONTRACT_SNAPSHOTS_DIRNAME as n, VERIFY_CODE_MARKER_MISSING as o, contractSnapshotJsonSpecifier as p, SchemaDiff as r, VERIFY_CODE_SCHEMA_FAILURE as s, APP_SPACE_ID as t, assembleControlMutationDefaults as u, extractCodecLookup as v, hasPslContractInfer as w, extractQueryOperationTypeImports as x, extractCodecTypeImports as y };
+
+//# sourceMappingURL=control-DTouE89s.mjs.map