qubu 0.0.0 → 0.3.3

package/dist/diff.mjs

@@ -0,0 +1,883 @@
+import { a as toSnapshotJsonValue, i as schemaSnapshotDigest, l as decodeSchemaSnapshot, n as canonicalJson } from "./canonical-BbnqavJm.mjs";
+import { c as decodeCompleteSchemaSnapshot, s as completeSchemaSnapshotDigest } from "./complete-D5Djh-zo.mjs";
+//#region src/diff/diff.ts
+const objectKinds = /* @__PURE__ */ new Set([
+	"namespace",
+	"table",
+	"column",
+	"constraint",
+	"index",
+	"view",
+	"materialized-view",
+	"sequence",
+	"enum",
+	"domain",
+	"collation",
+	"trigger",
+	"routine",
+	"partition",
+	"policy",
+	"extension",
+	"comment",
+	"ownership",
+	"deferred-object",
+	"opaque-object"
+]);
+const operationOrder = /* @__PURE__ */ new Map([
+	["remove", 0],
+	["physical-rename", 1],
+	["property-change", 2],
+	["add", 3]
+]);
+/**
+* Compare Snapshot v1 or v2 values and return immutable, reviewable data.
+*
+* The function never opens a connection, renders SQL, or turns a heuristic
+* match into a rename. Invalid input and malformed hints are represented by
+* diagnostics in the returned value.
+*/
+function diffSnapshots(beforeInput, afterInput, options = {}) {
+	const diagnostics = [];
+	const before = decodeSnapshot(beforeInput);
+	const after = decodeSnapshot(afterInput);
+	diagnostics.push(...before.diagnostics, ...after.diagnostics);
+	const hintResult = validateSnapshotRenameHints(options.renameHints ?? options.renames ?? []);
+	diagnostics.push(...hintResult.diagnostics);
+	const validHints = hintResult.value;
+	if (!before.snapshot || !after.snapshot) return freezeDiff({
+		equal: false,
+		operations: [],
+		changes: [],
+		additions: [],
+		removals: [],
+		propertyChanges: [],
+		renames: [],
+		added: [],
+		removed: [],
+		changed: [],
+		physicalRenames: [],
+		suggestions: [],
+		diagnostics: sortDiagnostics(diagnostics),
+		issues: sortDiagnostics(diagnostics),
+		renameHints: validHints,
+		hints: validHints,
+		...before.snapshot ? {
+			beforeVersion: before.snapshot.version,
+			beforeDialect: before.snapshot.value.dialect,
+			beforeDigest: before.snapshot.digest
+		} : {},
+		...after.snapshot ? {
+			afterVersion: after.snapshot.version,
+			afterDialect: after.snapshot.value.dialect,
+			afterDigest: after.snapshot.digest
+		} : {}
+	});
+	const left = before.snapshot;
+	const right = after.snapshot;
+	if (left.value.dialect.name !== right.value.dialect.name) diagnostics.push(diffDiagnostic("dialect-mismatch", `Snapshots use different dialects: "${left.value.dialect.name}" and "${right.value.dialect.name}"`, [], { dialect: right.value.dialect }));
+	const beforeByKey = groupByKey(left.records);
+	const afterByKey = groupByKey(right.records);
+	for (const [key, records] of [...beforeByKey, ...afterByKey]) {
+		if (records.length < 2) continue;
+		diagnostics.push(diffDiagnostic("ambiguous", `Multiple ${records[0].object.kind} records share one logical identity; stable matching is disabled for this key`, records[0].object.path, {
+			kind: records[0].object.kind,
+			namespace: records[0].object.namespace,
+			logicalId: records[0].object.id,
+			physicalName: records[0].object.physicalName,
+			dialect: records[0].object.dialect,
+			relatedPaths: records.slice(1).map((record) => record.object.path),
+			evidence: [evidence("ambiguity", void 0, void 0, void 0, `Duplicate stable key ${key}`)]
+		}));
+	}
+	const usedBefore = /* @__PURE__ */ new Set();
+	const usedAfter = /* @__PURE__ */ new Set();
+	const matches = [];
+	for (const hint of validHints) {
+		const beforeCandidates = resolveHintTarget(left.records, hint.kind, hint.namespace, hint.from);
+		const afterCandidates = resolveHintTarget(right.records, hint.kind, hint.namespace, hint.to);
+		if (beforeCandidates.length !== 1 || afterCandidates.length !== 1) {
+			const candidates = [...beforeCandidates, ...afterCandidates];
+			diagnostics.push(diffDiagnostic(beforeCandidates.length === 0 || afterCandidates.length === 0 ? "invalid-rename-hint" : "ambiguous", `Rename hint for ${hint.kind} did not resolve to one object on each side`, [], {
+				kind: hint.kind,
+				namespace: hint.namespace,
+				relatedPaths: candidates.map((candidate) => candidate.object.path),
+				evidence: [evidence("explicit-hint", void 0, void 0, 1, "Hint target")]
+			}));
+			continue;
+		}
+		const beforeObject = beforeCandidates[0];
+		const afterObject = afterCandidates[0];
+		if (usedBefore.has(beforeObject) || usedAfter.has(afterObject)) {
+			diagnostics.push(diffDiagnostic("rename-conflict", `Rename hint for ${hint.kind} reuses an object already mapped by another hint`, beforeObject.object.path, {
+				kind: hint.kind,
+				namespace: hint.namespace,
+				relatedPaths: [afterObject.object.path]
+			}));
+			continue;
+		}
+		usedBefore.add(beforeObject);
+		usedAfter.add(afterObject);
+		matches.push({
+			before: beforeObject,
+			after: afterObject,
+			source: "explicit-hint",
+			evidence: [evidence("explicit-hint", void 0, toSnapshotJsonValue(hint), 1, "Explicit rename hint")]
+		});
+	}
+	for (const [key, beforeCandidates] of beforeByKey) {
+		const afterCandidates = afterByKey.get(key) ?? [];
+		if (beforeCandidates.length !== 1 || afterCandidates.length !== 1) continue;
+		const beforeObject = beforeCandidates[0];
+		const afterObject = afterCandidates[0];
+		if (usedBefore.has(beforeObject) || usedAfter.has(afterObject)) continue;
+		usedBefore.add(beforeObject);
+		usedAfter.add(afterObject);
+		matches.push({
+			before: beforeObject,
+			after: afterObject,
+			source: "stable-id",
+			evidence: [evidence("logical-id", [...beforeObject.object.path, "id"], beforeObject.object.id, 1, "Stable logical ID match")]
+		});
+	}
+	const suggestions = [];
+	const suggestionThreshold = clampThreshold(options.suggestionThreshold);
+	const unmatchedBefore = left.records.filter((record) => !usedBefore.has(record));
+	const unmatchedAfter = right.records.filter((record) => !usedAfter.has(record));
+	if (options.suggestions !== false) for (const beforeObject of unmatchedBefore) {
+		if (beforeObject.lossy || beforeObject.unsupported) continue;
+		const candidates = unmatchedAfter.filter((candidate) => !candidate.lossy && !candidate.unsupported && candidate.scopeKey === beforeObject.scopeKey).map((candidate) => ({
+			candidate,
+			score: structuralScore(beforeObject, candidate)
+		})).filter((candidate) => candidate.score >= suggestionThreshold).sort((leftCandidate, rightCandidate) => rightCandidate.score - leftCandidate.score || compareObject(leftCandidate.candidate, rightCandidate.candidate));
+		if (candidates.length === 0) continue;
+		const best = candidates[0];
+		const tied = candidates.filter((candidate) => Math.abs(candidate.score - best.score) < 1e-6);
+		if (tied.length > 1) {
+			diagnostics.push(diffDiagnostic("ambiguous", `Multiple structural matches are possible for ${beforeObject.object.kind} "${beforeObject.object.id}"; no rename was inferred`, beforeObject.object.path, {
+				kind: beforeObject.object.kind,
+				namespace: beforeObject.object.namespace,
+				logicalId: beforeObject.object.id,
+				physicalName: beforeObject.object.physicalName,
+				dialect: beforeObject.object.dialect,
+				relatedPaths: tied.map((item) => item.candidate.object.path),
+				evidence: [evidence("ambiguity", void 0, void 0, best.score, `${tied.length} candidates scored ${best.score.toFixed(3)}`)]
+			}));
+			continue;
+		}
+		suggestions.push({
+			type: "rename-suggestion",
+			operation: "rename-suggestion",
+			kind: beforeObject.object.kind,
+			objectKind: beforeObject.object.kind,
+			namespace: beforeObject.object.namespace,
+			before: beforeObject.object,
+			after: best.candidate.object,
+			confidence: best.score,
+			evidence: [evidence("structural", void 0, void 0, best.score, "Stable structure matched after removing identity evidence")]
+		});
+	}
+	const operations = [];
+	for (const match of matches) {
+		const operation = operationForMatch(match, diagnostics);
+		if (operation !== void 0) operations.push(operation);
+	}
+	for (const record of unmatchedBefore) {
+		const operation = operationForUnmatched("remove", record.object);
+		operations.push(operation);
+		diagnostics.push(diffDiagnostic("destructive", `Removing ${record.object.kind} "${record.object.id}" is destructive`, record.object.path, {
+			kind: record.object.kind,
+			namespace: record.object.namespace,
+			logicalId: record.object.id,
+			physicalName: record.object.physicalName,
+			dialect: record.object.dialect,
+			evidence: record.object.evidence
+		}));
+	}
+	for (const record of unmatchedAfter) operations.push(operationForUnmatched("add", record.object));
+	for (const record of [...left.records, ...right.records]) {
+		if (!record.lossy && !record.unsupported) continue;
+		diagnostics.push(diffDiagnostic(record.lossy ? "lossy" : "unsupported", record.lossy ? `${record.object.kind} "${record.object.id}" contains opaque or deferred facts` : `${record.object.kind} "${record.object.id}" is outside the supported comparison surface`, record.object.path, {
+			kind: record.object.kind,
+			namespace: record.object.namespace,
+			logicalId: record.object.id,
+			physicalName: record.object.physicalName,
+			dialect: record.object.dialect,
+			evidence: record.object.evidence
+		}));
+		if (record.lossy && record.unsupported) diagnostics.push(diffDiagnostic("unsupported", `${record.object.kind} "${record.object.id}" cannot be structurally compared yet`, record.object.path, {
+			kind: record.object.kind,
+			namespace: record.object.namespace,
+			logicalId: record.object.id,
+			physicalName: record.object.physicalName,
+			dialect: record.object.dialect,
+			evidence: record.object.evidence
+		}));
+		if (record.object.kind === "deferred-object") diagnostics.push(diffDiagnostic("unknown", `${record.object.kind} "${record.object.id}" retains an observed object without a complete model`, record.object.path, {
+			kind: record.object.kind,
+			namespace: record.object.namespace,
+			logicalId: record.object.id,
+			physicalName: record.object.physicalName,
+			dialect: record.object.dialect,
+			evidence: record.object.evidence
+		}));
+	}
+	const sortedOperations = operations.sort(compareOperation);
+	const frozenSuggestions = suggestions.sort(compareSuggestion);
+	const additions = sortedOperations.filter((operation) => operation.type === "add");
+	const removals = sortedOperations.filter((operation) => operation.type === "remove");
+	const propertyChanges = sortedOperations.filter((operation) => operation.type === "property-change");
+	const renames = sortedOperations.filter((operation) => operation.type === "physical-rename");
+	const frozenDiagnostics = sortDiagnostics(diagnostics);
+	return freezeDiff({
+		equal: sortedOperations.length === 0,
+		beforeVersion: left.version,
+		afterVersion: right.version,
+		beforeDialect: left.value.dialect,
+		afterDialect: right.value.dialect,
+		beforeDigest: left.digest,
+		afterDigest: right.digest,
+		operations: sortedOperations,
+		changes: sortedOperations,
+		additions,
+		removals,
+		propertyChanges,
+		renames,
+		added: additions,
+		removed: removals,
+		changed: sortedOperations,
+		physicalRenames: renames,
+		suggestions: frozenSuggestions,
+		diagnostics: frozenDiagnostics,
+		issues: frozenDiagnostics,
+		renameHints: validHints,
+		hints: validHints
+	});
+}
+/** Alias that reads naturally in comparison-oriented callers. */
+const compareSnapshots = diffSnapshots;
+/** Decode and normalize a Snapshot v1 or v2 value without throwing. */
+function decodeSnapshotForDiff(input) {
+	const decoded = decodeSnapshot(input);
+	if (!decoded.snapshot) return {
+		ok: false,
+		diagnostics: decoded.diagnostics
+	};
+	return {
+		ok: true,
+		version: decoded.snapshot.version,
+		value: decoded.snapshot.value
+	};
+}
+/** Validate rename hints and return a frozen, serializable list. */
+function validateSnapshotRenameHints(hints) {
+	const diagnostics = [];
+	const values = [];
+	if (!Array.isArray(hints)) {
+		diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename hints must be an array", ["renameHints"]));
+		return {
+			ok: false,
+			value: [],
+			diagnostics: freeze(diagnostics)
+		};
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, value] of hints.entries()) {
+		const path = ["renameHints", index];
+		const diagnosticCount = diagnostics.length;
+		if (!isRecord(value)) {
+			diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename hint must be an object", path));
+			continue;
+		}
+		for (const key of Object.keys(value)) if (key !== "kind" && key !== "namespace" && key !== "from" && key !== "to") diagnostics.push(diffDiagnostic("invalid-rename-hint", `Unknown rename hint field "${key}"`, [...path, key]));
+		const kind = value.kind;
+		const namespace = value.namespace;
+		if (!isObjectKind(kind)) diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename hint kind is not a supported snapshot object kind", [...path, "kind"]));
+		if (namespace !== void 0 && (typeof namespace !== "string" || namespace.length === 0)) diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename hint namespace must be a non-empty string when provided", [...path, "namespace"]));
+		const from = normalizeRenameTarget(value.from, [...path, "from"], diagnostics);
+		const to = normalizeRenameTarget(value.to, [...path, "to"], diagnostics);
+		if (!isObjectKind(kind) || typeof namespace !== "string" && namespace !== void 0 || namespace === "" || from === void 0 || to === void 0 || diagnostics.length !== diagnosticCount) continue;
+		const hint = freeze({
+			kind,
+			...typeof namespace === "string" ? { namespace } : {},
+			from: typeof value.from === "string" ? value.from : from,
+			to: typeof value.to === "string" ? value.to : to
+		});
+		const key = `${kind}\u0000${namespace ?? ""}\u0000${targetKey(from)}\u0000${targetKey(to)}`;
+		if (seen.has(key)) {
+			diagnostics.push(diffDiagnostic("rename-conflict", "Duplicate rename hint", path, {
+				kind,
+				namespace: typeof namespace === "string" ? namespace : void 0
+			}));
+			continue;
+		}
+		seen.add(key);
+		values.push(hint);
+	}
+	const frozenValues = freeze(values.sort(compareHint));
+	if (diagnostics.length > 0) return {
+		ok: false,
+		value: frozenValues,
+		diagnostics: freeze(sortDiagnostics(diagnostics))
+	};
+	return {
+		ok: true,
+		value: frozenValues,
+		diagnostics: freeze([])
+	};
+}
+/** Serialize validated rename hints as deterministic JSON. */
+function encodeSnapshotRenameHints(hints) {
+	const result = validateSnapshotRenameHints(hints);
+	if (!result.ok) throw new TypeError(result.diagnostics.map((item) => item.message).join("\n"));
+	return canonicalJson(toSnapshotJsonValue(result.value));
+}
+/** Decode deterministic rename-hint JSON without throwing. */
+function decodeSnapshotRenameHints(input) {
+	let value = input;
+	if (typeof input === "string") try {
+		value = JSON.parse(input);
+	} catch (error) {
+		return {
+			ok: false,
+			value: [],
+			diagnostics: freeze([diffDiagnostic("invalid-rename-hint", `Rename hint JSON could not be parsed: ${error instanceof Error ? error.message : String(error)}`, [])])
+		};
+	}
+	return validateSnapshotRenameHints(value);
+}
+/** Short aliases for callers that keep rename helpers beside `diffSnapshots`. */
+const validateRenameHints = validateSnapshotRenameHints;
+const encodeRenameHints = encodeSnapshotRenameHints;
+const decodeRenameHints = decodeSnapshotRenameHints;
+function decodeSnapshot(input) {
+	const diagnostics = [];
+	let value = input;
+	if (typeof input === "string") try {
+		value = JSON.parse(input);
+	} catch (error) {
+		diagnostics.push(diffDiagnostic("invalid-snapshot", `Snapshot JSON could not be parsed: ${error instanceof Error ? error.message : String(error)}`, []));
+		return { diagnostics };
+	}
+	if (!isRecord(value)) {
+		diagnostics.push(diffDiagnostic("invalid-snapshot", "Snapshot must be an object", []));
+		return { diagnostics };
+	}
+	const version = value.version;
+	const normalized = sortSnapshotArrays(value, version === 2 ? 2 : 1);
+	if (version === 2) {
+		const result = decodeCompleteSchemaSnapshot(normalized);
+		if (!result.ok) {
+			diagnostics.push(...mapSnapshotDiagnostics(result.diagnostics));
+			return { diagnostics };
+		}
+		const snapshot = result.value;
+		return {
+			diagnostics,
+			snapshot: {
+				version: 2,
+				value: snapshot,
+				records: extractCompleteObjects(snapshot),
+				digest: completeSchemaSnapshotDigest(snapshot)
+			}
+		};
+	}
+	if (version === 1) {
+		const result = decodeSchemaSnapshot(normalized);
+		if (!result.ok) {
+			diagnostics.push(...mapSnapshotDiagnostics(result.diagnostics));
+			return { diagnostics };
+		}
+		const snapshot = result.value;
+		return {
+			diagnostics,
+			snapshot: {
+				version: 1,
+				value: snapshot,
+				records: extractV1Objects(snapshot),
+				digest: schemaSnapshotDigest(snapshot)
+			}
+		};
+	}
+	diagnostics.push(diffDiagnostic("invalid-snapshot", `Unsupported schema snapshot version: ${String(version)}`, ["version"]));
+	return { diagnostics };
+}
+function extractV1Objects(snapshot) {
+	const records = [];
+	const namespace = snapshot.namespace;
+	for (const [tableIndex, table] of snapshot.tables.entries()) {
+		const tableObject = addInternalObject(records, "table", table, ["tables", tableIndex], namespace, void 0, snapshot);
+		for (const [columnIndex, column] of table.columns.entries()) addInternalObject(records, "column", column, [
+			"tables",
+			tableIndex,
+			"columns",
+			columnIndex
+		], namespace, tableObject, snapshot);
+		for (const [constraintIndex, constraint] of table.constraints.entries()) addInternalObject(records, "constraint", constraint, [
+			"tables",
+			tableIndex,
+			"constraints",
+			constraintIndex
+		], namespace, tableObject, snapshot);
+		for (const [indexIndex, index] of table.indexes.entries()) addInternalObject(records, "index", index, [
+			"tables",
+			tableIndex,
+			"indexes",
+			indexIndex
+		], namespace, tableObject, snapshot);
+	}
+	return freeze(records.sort(compareObject));
+}
+function extractCompleteObjects(snapshot) {
+	const records = [];
+	const namespace = snapshot.namespace.name;
+	addInternalObject(records, "namespace", snapshot.namespace, ["namespace"], namespace, void 0, snapshot);
+	for (const [tableIndex, table] of snapshot.tables.entries()) {
+		const tableObject = addInternalObject(records, "table", table, ["tables", tableIndex], namespace, void 0, snapshot);
+		for (const [columnIndex, column] of table.columns.entries()) addInternalObject(records, "column", column, [
+			"tables",
+			tableIndex,
+			"columns",
+			columnIndex
+		], namespace, tableObject, snapshot);
+		for (const [constraintIndex, constraint] of table.constraints.entries()) addInternalObject(records, "constraint", constraint, [
+			"tables",
+			tableIndex,
+			"constraints",
+			constraintIndex
+		], namespace, tableObject, snapshot);
+		for (const [indexIndex, index] of table.indexes.entries()) addInternalObject(records, "index", index, [
+			"tables",
+			tableIndex,
+			"indexes",
+			indexIndex
+		], namespace, tableObject, snapshot);
+	}
+	for (const [group, defaultKind] of [
+		["views", "view"],
+		["sequences", "sequence"],
+		["enums", "enum"],
+		["domains", "domain"],
+		["collations", "collation"],
+		["triggers", "trigger"],
+		["routines", "routine"],
+		["partitions", "partition"],
+		["policies", "policy"],
+		["extensions", "extension"],
+		["deferredObjects", "deferred-object"],
+		["opaqueObjects", "opaque-object"],
+		["comments", "comment"],
+		["ownership", "ownership"]
+	]) {
+		const values = snapshot[group];
+		if (!Array.isArray(values)) continue;
+		for (const [index, value] of values.entries()) {
+			const kind = defaultKind === "view" && value.kind === "materialized-view" ? "materialized-view" : defaultKind;
+			const object = addInternalObject(records, kind, value, [String(group), index], namespace, void 0, snapshot);
+			if (kind === "view" || kind === "materialized-view") {
+				const columns = value.columns;
+				for (const [columnIndex, column] of columns.entries()) addInternalObject(records, "column", column, [
+					String(group),
+					index,
+					"columns",
+					columnIndex
+				], namespace, object, snapshot);
+			}
+		}
+	}
+	return freeze(records.sort(compareObject));
+}
+function addInternalObject(records, kind, value, path, namespace, parent, snapshot) {
+	const record = value;
+	const id = typeof record.id === "string" ? record.id : kind === "namespace" && typeof record.name === "string" ? record.name : typeof record.physicalName === "string" ? record.physicalName : `${kind}:${path.join(".")}`;
+	const physicalName = typeof record.physicalName === "string" ? record.physicalName : kind === "namespace" && typeof record.name === "string" ? record.name : void 0;
+	const physicalReference = record.physicalReference;
+	const provenance = record.provenance;
+	const observedKind = kind === "deferred-object" || kind === "opaque-object" ? typeof record.objectKind === "string" ? record.objectKind : void 0 : void 0;
+	const dialect = snapshot.dialect;
+	const internal = {
+		object: freeze({
+			kind,
+			...observedKind === void 0 ? {} : { observedKind },
+			...namespace === void 0 ? {} : { namespace },
+			path: freeze([...path]),
+			...parent === void 0 ? {} : { parent: freeze({
+				kind: parent.object.kind,
+				id: parent.object.id,
+				...namespace === void 0 ? {} : { namespace }
+			}) },
+			id,
+			...physicalName === void 0 ? {} : { physicalName },
+			...physicalReference === void 0 ? {} : { physicalReference },
+			dialect,
+			...provenance === void 0 ? {} : { provenance },
+			value: record,
+			evidence: makeEvidence(record, path, id, physicalName, dialect)
+		}),
+		key: objectKey(kind, namespace, parent, id),
+		scopeKey: `${kind}\u0000${namespace ?? ""}\u0000${parent?.object.id ?? ""}`,
+		signature: structuralSignature(record),
+		lossy: kind === "opaque-object" || kind === "deferred-object",
+		unsupported: kind === "opaque-object" || kind === "deferred-object"
+	};
+	records.push(internal);
+	return internal;
+}
+function operationForMatch(match, diagnostics) {
+	const before = match.before.object;
+	const after = match.after.object;
+	const changedProperties = propertyChangesBetween(before.value, after.value);
+	const physicalRename = before.physicalName !== void 0 && after.physicalName !== void 0 && before.physicalName !== after.physicalName;
+	const blockedRename = match.before.lossy || match.after.lossy;
+	const effectiveChanges = physicalRename && blockedRename && changedProperties.length === 0 ? freeze([{
+		path: freeze(["physicalName"]),
+		before: before.physicalName,
+		after: after.physicalName
+	}]) : changedProperties;
+	if (physicalRename && blockedRename) diagnostics.push(diffDiagnostic("lossy", `Physical-name change for ${before.kind} "${before.id}" is not promoted to a rename because the record is opaque or deferred`, before.path, {
+		kind: before.kind,
+		namespace: before.namespace,
+		logicalId: before.id,
+		physicalName: before.physicalName,
+		dialect: after.dialect,
+		relatedPaths: [after.path],
+		evidence: [...before.evidence, ...after.evidence]
+	}));
+	if (physicalRename && !blockedRename) return freeze({
+		type: "physical-rename",
+		operation: "physical-rename",
+		classification: "physical-rename",
+		changeKind: "physical-rename",
+		kind: before.kind,
+		objectKind: before.kind,
+		namespace: before.namespace ?? after.namespace,
+		path: after.path,
+		dialect: after.dialect,
+		...after.physicalReference === void 0 ? {} : { physicalReference: after.physicalReference },
+		...after.provenance === void 0 ? {} : { provenance: after.provenance },
+		before,
+		after,
+		object: after,
+		logicalId: after.id,
+		physicalName: after.physicalName,
+		...changedProperties.length === 0 ? {} : { changedProperties },
+		evidence: freeze([
+			...match.evidence,
+			evidence("physical-name", [...before.path, "physicalName"], before.physicalName, 1, "Physical name changed while the logical match remained stable"),
+			evidence("physical-name", [...after.path, "physicalName"], after.physicalName, 1, "New physical name")
+		]),
+		source: match.source,
+		destructive: false
+	});
+	if (effectiveChanges.length === 0) return void 0;
+	const destructive = effectiveChanges.some(isDestructiveProperty);
+	if (destructive) diagnostics.push(diffDiagnostic("destructive", `Property changes on ${before.kind} "${before.id}" may remove or narrow existing data`, before.path, {
+		kind: before.kind,
+		namespace: before.namespace,
+		logicalId: before.id,
+		physicalName: before.physicalName,
+		dialect: after.dialect,
+		relatedPaths: [after.path],
+		evidence: match.evidence
+	}));
+	return freeze({
+		type: "property-change",
+		operation: "property-change",
+		classification: "property-change",
+		changeKind: "property-change",
+		kind: before.kind,
+		objectKind: before.kind,
+		namespace: before.namespace ?? after.namespace,
+		path: after.path,
+		dialect: after.dialect,
+		...after.physicalReference === void 0 ? {} : { physicalReference: after.physicalReference },
+		...after.provenance === void 0 ? {} : { provenance: after.provenance },
+		before,
+		after,
+		object: after,
+		logicalId: after.id,
+		physicalName: after.physicalName,
+		changedProperties: effectiveChanges,
+		evidence: match.evidence,
+		source: match.source,
+		destructive
+	});
+}
+function operationForUnmatched(type, object) {
+	return freeze({
+		type,
+		operation: type,
+		classification: type,
+		changeKind: type,
+		kind: object.kind,
+		objectKind: object.kind,
+		namespace: object.namespace,
+		path: object.path,
+		dialect: object.dialect,
+		...object.physicalReference === void 0 ? {} : { physicalReference: object.physicalReference },
+		...object.provenance === void 0 ? {} : { provenance: object.provenance },
+		...type === "remove" ? { before: object } : { after: object },
+		object,
+		logicalId: object.id,
+		physicalName: object.physicalName,
+		evidence: object.evidence,
+		source: "stable-id",
+		destructive: type === "remove"
+	});
+}
+function resolveHintTarget(records, kind, namespace, target) {
+	const scalarTarget = typeof target === "string" ? target : void 0;
+	const normalized = typeof target === "string" ? void 0 : target;
+	return records.filter((record) => {
+		if (record.object.kind !== kind || namespace !== void 0 && record.object.namespace !== namespace) return false;
+		if (scalarTarget !== void 0 && record.object.id !== scalarTarget && record.object.physicalName !== scalarTarget) return false;
+		if (normalized === void 0) return true;
+		if (normalized.path !== void 0 && !samePath(record.object.path, normalized.path)) return false;
+		if (normalized.id !== void 0 && record.object.id !== normalized.id) return false;
+		if (normalized.physicalName !== void 0 && record.object.physicalName !== normalized.physicalName) return false;
+		return true;
+	});
+}
+function structuralScore(left, right) {
+	if (left.signature === right.signature) return 1;
+	const leftRecord = stripIdentity(left.object.value);
+	const rightRecord = stripIdentity(right.object.value);
+	if (!isSnapshotRecord(leftRecord) || !isSnapshotRecord(rightRecord)) return 0;
+	const leftKeys = new Set(Object.keys(leftRecord));
+	const rightKeys = new Set(Object.keys(rightRecord));
+	const keys = /* @__PURE__ */ new Set([...leftKeys, ...rightKeys]);
+	if (keys.size === 0) return 0;
+	let equal = 0;
+	for (const key of keys) if (key in leftRecord && key in rightRecord && canonicalEquivalent(leftRecord[key], rightRecord[key])) equal += 1;
+	return equal / keys.size;
+}
+function structuralSignature(value) {
+	return canonicalJson(stripIdentity(value));
+}
+function stripIdentity(value) {
+	if (Array.isArray(value)) return value.map((item) => stripIdentity(item));
+	if (value === null || typeof value !== "object") return value;
+	const result = {};
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "id" || key === "physicalName" || key === "physicalReference" || key === "provenance") continue;
+		result[key] = stripIdentity(child);
+	}
+	return result;
+}
+function propertyChangesBetween(before, after) {
+	const changes = [];
+	compareValues(before, after, [], changes);
+	return freeze(changes);
+}
+function compareValues(before, after, path, changes) {
+	const key = path[path.length - 1];
+	if (key === "id" || key === "physicalName" || key === "physicalReference") return;
+	if (path.length === 1 && (key === "columns" || key === "constraints" || key === "indexes")) return;
+	if (canonicalEquivalent(before, after)) return;
+	if (isSnapshotRecord(before) && isSnapshotRecord(after)) {
+		const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+		for (const childKey of [...keys].sort()) compareValues(before[childKey], after[childKey], [...path, childKey], changes);
+		return;
+	}
+	if (Array.isArray(before) && Array.isArray(after)) {
+		const length = Math.max(before.length, after.length);
+		for (let index = 0; index < length; index += 1) compareValues(before[index], after[index], [...path, index], changes);
+		return;
+	}
+	changes.push({
+		path: freeze([...path]),
+		...before === void 0 ? {} : { before },
+		...after === void 0 ? {} : { after }
+	});
+}
+function isDestructiveProperty(change) {
+	if (change.after === void 0) return true;
+	const key = change.path[change.path.length - 1];
+	if (key === "nullable") return change.after === false;
+	if (key === "storage" || key === "default" || key === "generatedColumn") return true;
+	if (key === "columns" || key === "terms" || key === "constraints") return true;
+	return false;
+}
+function makeEvidence(record, path, id, physicalName, dialect) {
+	const result = [evidence("logical-id", [...path, "id"], id, 1, "Stable logical ID"), evidence("dialect", void 0, toSnapshotJsonValue(dialect), 1, "Snapshot dialect")];
+	if (physicalName !== void 0) result.push(evidence("physical-name", [...path, "physicalName"], physicalName, 1, "Physical name evidence"));
+	if (record.physicalReference !== void 0) result.push(evidence("physical-reference", [...path, "physicalReference"], record.physicalReference, 1, "Physical reference evidence"));
+	if (record.provenance !== void 0) result.push(evidence("provenance", [...path, "provenance"], record.provenance, 1, "Catalog or decompiler provenance"));
+	return freeze(result);
+}
+function evidence(kind, path, value, confidence, message) {
+	return freeze({
+		kind,
+		...path === void 0 ? {} : { path: freeze([...path]) },
+		...value === void 0 ? {} : { value },
+		...confidence === void 0 ? {} : { confidence },
+		...message === void 0 ? {} : { message }
+	});
+}
+function diffDiagnostic(code, message, path, options = {}) {
+	return {
+		code,
+		category: code,
+		severity: code === "ambiguous" || code === "invalid-snapshot" || code === "invalid-rename-hint" || code === "rename-conflict" || code === "dialect-mismatch" ? "error" : "warning",
+		message,
+		path: freeze([...path]),
+		...options.relatedPaths === void 0 ? {} : { relatedPaths: freeze(options.relatedPaths.map((item) => freeze([...item]))) },
+		...options.kind === void 0 ? {} : {
+			kind: options.kind,
+			objectKind: options.kind
+		},
+		...options.namespace === void 0 ? {} : { namespace: options.namespace },
+		...options.logicalId === void 0 ? {} : { logicalId: options.logicalId },
+		...options.physicalName === void 0 ? {} : { physicalName: options.physicalName },
+		...options.dialect === void 0 ? {} : { dialect: options.dialect },
+		...options.evidence === void 0 ? {} : { evidence: freeze([...options.evidence]) }
+	};
+}
+function mapSnapshotDiagnostics(diagnostics) {
+	return diagnostics.map((item) => {
+		return diffDiagnostic(item.code === "unknown-field" ? "unknown" : item.code === "future-version" || item.code === "unsupported-expression" || item.code === "unsupported-dialect-option" ? "unsupported" : "invalid-snapshot", item.message, item.path, { relatedPaths: item.relatedPaths });
+	});
+}
+function groupByKey(records) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const values = groups.get(record.key);
+		if (values === void 0) groups.set(record.key, [record]);
+		else values.push(record);
+	}
+	return groups;
+}
+function objectKey(kind, namespace, parent, id) {
+	return `${kind}\u0000${namespace ?? ""}\u0000${parent?.object.kind ?? ""}\u0000${parent?.object.id ?? ""}\u0000${id}`;
+}
+function sortSnapshotArrays(value, version) {
+	const visit = (current, key) => {
+		if (Array.isArray(current)) {
+			const values = current.map((item) => visit(item, key));
+			if (key !== void 0 && isObjectArrayKey(key, version) && values.every(isRecord)) return values.sort(compareUnknownRecords);
+			if (key === "dependencies" || key === "roles" || key === "events" || key === "includedColumns") return values.sort(compareUnknownRecords);
+			if (key === "terms" || key === "values" || key === "parameters") return values.sort(comparePositionedRecords);
+			return values;
+		}
+		if (!isRecord(current)) return current;
+		const output = {};
+		for (const [childKey, child] of Object.entries(current)) output[childKey] = visit(child, childKey);
+		return output;
+	};
+	return visit(value, void 0);
+}
+function isObjectArrayKey(key, version) {
+	if (version === 1) return key === "tables" || key === "columns" || key === "constraints" || key === "indexes";
+	return key === "tables" || key === "views" || key === "sequences" || key === "enums" || key === "domains" || key === "collations" || key === "triggers" || key === "routines" || key === "partitions" || key === "policies" || key === "extensions" || key === "deferredObjects" || key === "opaqueObjects" || key === "comments" || key === "ownership" || key === "columns" || key === "constraints" || key === "indexes";
+}
+function compareUnknownRecords(left, right) {
+	const leftRecord = isRecord(left) ? left : void 0;
+	const rightRecord = isRecord(right) ? right : void 0;
+	const leftId = leftRecord && typeof leftRecord.id === "string" ? leftRecord.id : "";
+	const rightId = rightRecord && typeof rightRecord.id === "string" ? rightRecord.id : "";
+	if (leftId !== rightId) return leftId < rightId ? -1 : 1;
+	return safeString(left).localeCompare(safeString(right));
+}
+function comparePositionedRecords(left, right) {
+	const leftRecord = isRecord(left) ? left : void 0;
+	const rightRecord = isRecord(right) ? right : void 0;
+	return (leftRecord && typeof leftRecord.position === "number" ? leftRecord.position : leftRecord && typeof leftRecord.ordinalPosition === "number" ? leftRecord.ordinalPosition : Number.MAX_SAFE_INTEGER) - (rightRecord && typeof rightRecord.position === "number" ? rightRecord.position : rightRecord && typeof rightRecord.ordinalPosition === "number" ? rightRecord.ordinalPosition : Number.MAX_SAFE_INTEGER) || compareUnknownRecords(left, right);
+}
+function safeString(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function canonicalEquivalent(left, right) {
+	try {
+		return canonicalJson(toSnapshotJsonValue(left)) === canonicalJson(toSnapshotJsonValue(right));
+	} catch {
+		return safeString(left) === safeString(right);
+	}
+}
+function normalizeRenameTarget(value, path, diagnostics) {
+	if (typeof value === "string") {
+		if (value.length === 0) {
+			diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename target cannot be empty", path));
+			return;
+		}
+		return freeze({ id: value });
+	}
+	if (!isRecord(value)) {
+		diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename target must be a string or object", path));
+		return;
+	}
+	for (const key of Object.keys(value)) if (key !== "id" && key !== "physicalName" && key !== "path") diagnostics.push(diffDiagnostic("invalid-rename-hint", `Unknown rename target field "${key}"`, [...path, key]));
+	const id = value.id;
+	const physicalName = value.physicalName;
+	const targetPath = value.path;
+	if (id !== void 0 && (typeof id !== "string" || id.length === 0)) diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename target id must be a non-empty string", [...path, "id"]));
+	if (physicalName !== void 0 && (typeof physicalName !== "string" || physicalName.length === 0)) diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename target physicalName must be a non-empty string", [...path, "physicalName"]));
+	if (targetPath !== void 0 && !isPath(targetPath)) diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename target path must be an array", [...path, "path"]));
+	if (id === void 0 && physicalName === void 0 && targetPath === void 0) {
+		diagnostics.push(diffDiagnostic("invalid-rename-hint", "Rename target needs an id, physicalName, or path", path));
+		return;
+	}
+	if (id !== void 0 && (typeof id !== "string" || id.length === 0) || physicalName !== void 0 && (typeof physicalName !== "string" || physicalName.length === 0) || targetPath !== void 0 && !isPath(targetPath)) return void 0;
+	return freeze({
+		...typeof id === "string" ? { id } : {},
+		...typeof physicalName === "string" ? { physicalName } : {},
+		...isPath(targetPath) ? { path: freeze([...targetPath]) } : {}
+	});
+}
+function targetKey(target) {
+	return `${target.id ?? ""}\u0000${target.physicalName ?? ""}\u0000${target.path?.join(".") ?? ""}`;
+}
+function isObjectKind(value) {
+	return typeof value === "string" && objectKinds.has(value);
+}
+function isPath(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string" || Number.isSafeInteger(item));
+}
+function samePath(left, right) {
+	return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function compareObject(left, right) {
+	return left.object.kind.localeCompare(right.object.kind) || (left.object.namespace ?? "").localeCompare(right.object.namespace ?? "") || (left.object.parent?.id ?? "").localeCompare(right.object.parent?.id ?? "") || left.object.id.localeCompare(right.object.id) || safeString(left.object.path).localeCompare(safeString(right.object.path));
+}
+function compareOperation(left, right) {
+	return (operationOrder.get(left.type) ?? 99) - (operationOrder.get(right.type) ?? 99) || left.kind.localeCompare(right.kind) || (left.namespace ?? "").localeCompare(right.namespace ?? "") || (left.logicalId ?? "").localeCompare(right.logicalId ?? "") || safeString(left.before?.path ?? left.after?.path).localeCompare(safeString(right.before?.path ?? right.after?.path));
+}
+function compareSuggestion(left, right) {
+	return left.kind.localeCompare(right.kind) || (left.namespace ?? "").localeCompare(right.namespace ?? "") || left.before.id.localeCompare(right.before.id) || left.after.id.localeCompare(right.after.id);
+}
+function compareHint(left, right) {
+	return left.kind.localeCompare(right.kind) || (left.namespace ?? "").localeCompare(right.namespace ?? "") || targetKey(normalizeTargetForCompare(left.from)).localeCompare(targetKey(normalizeTargetForCompare(right.from))) || targetKey(normalizeTargetForCompare(left.to)).localeCompare(targetKey(normalizeTargetForCompare(right.to)));
+}
+function normalizeTargetForCompare(target) {
+	return typeof target === "string" ? { id: target } : target;
+}
+function clampThreshold(value) {
+	return value === void 0 || !Number.isFinite(value) ? .75 : Math.min(1, Math.max(0, value));
+}
+function sortDiagnostics(diagnostics) {
+	return freeze([...diagnostics].sort((left, right) => left.code.localeCompare(right.code) || safeString(left.path).localeCompare(safeString(right.path)) || left.message.localeCompare(right.message)));
+}
+function freezeDiff(value) {
+	return deepFreeze(value);
+}
+function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) for (const item of value) deepFreeze(item, seen);
+	else for (const child of Object.values(value)) deepFreeze(child, seen);
+	return Object.freeze(value);
+}
+function freeze(value) {
+	return deepFreeze(value);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSnapshotRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { compareSnapshots, decodeRenameHints, decodeSnapshotForDiff, decodeSnapshotRenameHints, diffSnapshots, encodeRenameHints, encodeSnapshotRenameHints, validateRenameHints, validateSnapshotRenameHints };