qubu 0.6.0 → 0.6.2

package/dist/snapshot-mIb-Zzb5.mjs

@@ -0,0 +1,1489 @@
+import { a as toSnapshotJsonValue, d as assertCompleteSchemaSnapshot } from "./canonical-B5_ouh-c.mjs";
+import "./snapshot.mjs";
+import { storageAffinity } from "./snapshot/sqlite.mjs";
+import { n as createIntrospectionDiagnostic } from "./diagnostics-I9vVtXkc.mjs";
+//#region src/snapshot/candidate-key.ts
+/** Return the column IDs for an index whose shape can prove a candidate key. */
+function candidateKeyIndexColumns(index) {
+	if (!index.unique || index.predicate !== void 0 || index.terms.length === 0) return;
+	const columns = [];
+	for (const term of index.terms) {
+		if (term.kind !== "column" || term.prefixLength !== void 0 || term.operatorClass !== void 0) return;
+		columns.push(term.column);
+	}
+	return columns;
+}
+/** Return whether an index's facts prove a non-null, non-lossy candidate key. */
+function hasCandidateKeyShape(index, columns) {
+	const indexColumns = candidateKeyIndexColumns(index);
+	return indexColumns !== void 0 && indexColumns.every((column) => {
+		const nullable = columns.get(column);
+		return (typeof nullable === "boolean" ? nullable : nullable?.nullable) === false;
+	});
+}
+/** Return whether the snapshot explicitly marks a shape-proven index as a candidate key. */
+function isCandidateKeyIndex(index, columns) {
+	return index.candidateKey && hasCandidateKeyShape(index, columns);
+}
+//#endregion
+//#region src/introspection/catalog.ts
+/**
+* Materialize every optional object-family collection and deeply freeze the normalized catalog.
+* Catalog text and extension data remain values; this helper never evaluates SQL or assigns
+* persisted logical identities.
+*/
+function createCompleteIntrospectionCatalog(catalog) {
+	return deepFreeze({
+		dialect: catalog.dialect,
+		server: catalog.server,
+		capabilities: catalog.capabilities ?? catalog.server.capabilities,
+		namespace: catalog.namespace,
+		tables: sortTables(catalog.tables),
+		views: sortObjects(catalog.views ?? []),
+		sequences: sortObjects(catalog.sequences ?? []),
+		enums: sortObjects(catalog.enums ?? []),
+		domains: sortObjects(catalog.domains ?? []),
+		collations: sortObjects(catalog.collations ?? []),
+		triggers: sortObjects(catalog.triggers ?? []),
+		routines: sortObjects(catalog.routines ?? []),
+		partitions: sortObjects(catalog.partitions ?? []),
+		policies: sortObjects(catalog.policies ?? []),
+		extensionObjects: sortObjects(catalog.extensionObjects ?? []),
+		deferredObjects: [...catalog.deferredObjects].sort(compareDeferred),
+		opaqueObjects: sortObjects(catalog.opaqueObjects ?? []),
+		comments: [...catalog.comments ?? []].sort(compareId$1),
+		ownership: [...catalog.ownership ?? []].sort(compareId$1),
+		diagnostics: [...catalog.diagnostics]
+	});
+}
+/** Alias for callers that already use the normalized-catalog terminology. */
+const freezeIntrospectionCatalog = createCompleteIntrospectionCatalog;
+/** Convert a complete catalog back to the optional reader-facing contract. */
+function toIntrospectionCatalog(catalog) {
+	return deepFreeze({
+		...catalog,
+		capabilities: catalog.capabilities
+	});
+}
+function sortTables(tables) {
+	return [...tables].map((table) => deepFreeze({
+		...table,
+		columns: [...table.columns].sort(compareColumn),
+		constraints: [...table.constraints].sort(compareId$1),
+		indexes: [...table.indexes].sort(compareId$1)
+	})).sort(compareId$1);
+}
+function sortObjects(objects) {
+	return [...objects].sort(compareId$1);
+}
+function compareId$1(left, right) {
+	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+function compareDeferred(left, right) {
+	const leftId = left.id ?? left.physicalName;
+	const rightId = right.id ?? right.physicalName;
+	return leftId < rightId ? -1 : leftId > rightId ? 1 : 0;
+}
+function compareColumn(left, right) {
+	return left.ordinalPosition - right.ordinalPosition || compareId$1(left, right);
+}
+/**
+* Freeze nested catalog values without imposing JSON semantics on bigint or opaque driver values.
+* The normalized contract is expected to contain plain records, arrays, and scalar values;
+* unsupported prototypes are retained but still frozen so the operation remains non-destructive.
+*/
+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);
+}
+//#endregion
+//#region src/introspection/identity.ts
+/** The naming policy used by the first introspection snapshot mapper. */
+const introspectedPhysicalIdentityPolicy = Object.freeze({
+	name: "introspected-physical",
+	version: 1,
+	fallback: "escaped",
+	precedence: Object.freeze([
+		"explicit-hint",
+		"previous-snapshot",
+		"physical-name",
+		"deterministic-fallback"
+	])
+});
+//#endregion
+//#region src/introspection/complete-snapshot.ts
+/**
+* Map a normalized catalog to validated Snapshot v1 data.
+*
+* Strict mode reports mapping errors as failure. Explicit lossy mode may omit only recoverable
+* unsafe facts and marks a successful result as lossy. Complete objects are never fabricated as
+* tables, and catalog references remain evidence rather than logical IDs.
+*/
+function mapCatalogToCompleteSnapshot(input, options) {
+	const catalog = createCompleteIntrospectionCatalog(applyIdentityOptions(input, options));
+	const normalizedDiagnostics = normalizeCatalogDiagnostics(catalog.diagnostics, options?.mode ?? "strict");
+	const context = {
+		mode: options?.mode ?? "strict",
+		diagnostics: normalizedDiagnostics.diagnostics,
+		lossy: normalizedDiagnostics.lossy,
+		references: createCatalogReferenceLookup(catalog)
+	};
+	const tableByPhysicalName = new Map(catalog.tables.map((table) => [table.physicalName, table]));
+	const tables = catalog.tables.map((table) => mapTable(table, catalog.dialect, tableByPhysicalName, context));
+	const views = catalog.views.map((view, index) => mapView(view, catalog.dialect, context, ["views", index]));
+	const sequences = catalog.sequences.map((sequence, index) => mapSequence(sequence, catalog.dialect, context, ["sequences", index])).filter((sequence) => sequence !== void 0);
+	const enums = catalog.enums.map((item) => mapEnum(item, catalog.dialect));
+	const domains = catalog.domains.map((domain) => mapDomain(domain, catalog.dialect));
+	const collations = catalog.collations.map((collation) => ({
+		kind: "collation",
+		id: collation.id,
+		physicalName: collation.physicalName,
+		...collation.provider === void 0 ? {} : { provider: collation.provider },
+		...collation.locale === void 0 ? {} : { locale: collation.locale },
+		...collation.deterministic === void 0 ? {} : { deterministic: collation.deterministic },
+		...collation.version === void 0 ? {} : { version: collation.version },
+		...mapMetadata(collation.provenance, collation.dialect, catalog.dialect, collation.reference)
+	}));
+	const triggers = catalog.triggers.map((trigger, index) => mapTrigger(trigger, catalog.dialect, context, ["triggers", index]));
+	const routines = catalog.routines.map((routine, index) => mapRoutine(routine, catalog.dialect, context, ["routines", index]));
+	const partitions = catalog.partitions.map((partition, index) => mapPartition(partition, catalog.dialect, context, ["partitions", index]));
+	const policies = catalog.policies.map((policy, index) => mapPolicy(policy, catalog.dialect, context, ["policies", index]));
+	const extensions = catalog.extensionObjects.map((extension) => mapExtensionObject(extension, catalog.dialect));
+	const deferredObjects = catalog.deferredObjects.map((object) => mapDeferredObject(object, catalog.dialect));
+	const opaqueObjects = catalog.opaqueObjects.map((object) => mapOpaqueObject(object, catalog.dialect));
+	for (const object of catalogObjectsWithUnknownFields(catalog)) for (const field of object.unknownFields ?? []) opaqueObjects.push(mapUnknownField(object, field, catalog.dialect));
+	const comments = (catalog.comments ?? []).map((comment, index) => mapComment(comment, catalog.dialect, context, ["comments", index])).filter((comment) => comment !== void 0);
+	const ownership = (catalog.ownership ?? []).map((item, index) => mapOwnership(item, catalog.dialect, context, ["ownership", index])).filter((item) => item !== void 0);
+	for (const object of catalogObjectList(catalog)) {
+		if (object.comment && !comments.some((item) => item.id === object.comment?.id)) {
+			const comment = mapComment(object.comment, catalog.dialect, context, ["comments"], object.ownerScope);
+			if (comment !== void 0) comments.push(comment);
+		}
+		if (object.ownership && !ownership.some((item) => item.id === object.ownership?.id)) {
+			const ownershipRecord = mapOwnership(object.ownership, catalog.dialect, context, ["ownership"], object.ownerScope);
+			if (ownershipRecord !== void 0) ownership.push(ownershipRecord);
+		}
+	}
+	const snapshot = {
+		format: "qubu-schema",
+		version: 1,
+		dialect: {
+			name: catalog.dialect,
+			version: 1
+		},
+		namingPolicy: {
+			name: (options?.identityPolicy ?? introspectedPhysicalIdentityPolicy).name,
+			version: (options?.identityPolicy ?? introspectedPhysicalIdentityPolicy).version
+		},
+		namespace: {
+			kind: catalog.namespace.kind,
+			name: catalog.namespace.name,
+			...mapMetadata(catalog.namespace.provenance, catalog.namespace.dialect, catalog.dialect, catalog.namespace.reference)
+		},
+		capabilities: catalog.capabilities,
+		tables: tables.sort(compareId),
+		views: views.sort(compareId),
+		sequences: sequences.sort(compareId),
+		enums: enums.sort(compareId),
+		domains: domains.sort(compareId),
+		collations: collations.sort(compareId),
+		triggers: triggers.filter((trigger) => trigger !== void 0).sort(compareId),
+		routines: routines.filter((routine) => routine !== void 0).sort(compareId),
+		partitions: partitions.filter((partition) => partition !== void 0).sort(compareId),
+		policies: policies.filter((policy) => policy !== void 0).sort(compareId),
+		extensions: extensions.sort(compareId),
+		deferredObjects: deferredObjects.sort(compareId),
+		opaqueObjects: opaqueObjects.sort(compareId),
+		comments: comments.sort(compareId),
+		ownership: ownership.sort(compareId)
+	};
+	let validatedSnapshot;
+	try {
+		validatedSnapshot = assertCompleteSchemaSnapshot(snapshot);
+	} catch (error) {
+		context.diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "invalid-catalog-row",
+			message: error instanceof Error ? `Catalog facts could not form Snapshot v1: ${error.message}` : "Catalog facts could not form Snapshot v1",
+			path: [],
+			remediation: "Inspect the catalog diagnostics and complete object mappings."
+		}));
+		return Object.freeze({
+			ok: false,
+			catalog,
+			diagnostics: Object.freeze(context.diagnostics),
+			lossy: false
+		});
+	}
+	if (context.diagnostics.some((diagnostic) => diagnostic.severity === "error")) return Object.freeze({
+		ok: false,
+		catalog,
+		diagnostics: Object.freeze(context.diagnostics),
+		lossy: false
+	});
+	const diagnostics = Object.freeze(context.diagnostics);
+	if (context.lossy) return Object.freeze({
+		ok: true,
+		catalog,
+		snapshot: validatedSnapshot,
+		diagnostics,
+		lossy: true
+	});
+	return Object.freeze({
+		ok: true,
+		catalog,
+		snapshot: validatedSnapshot,
+		diagnostics,
+		lossy: false
+	});
+}
+/** Numbered alias for callers that prefer the explicit Snapshot v1 mapper name. */
+const mapCatalogToSnapshotV1 = mapCatalogToCompleteSnapshot;
+function applyIdentityOptions(input, options) {
+	if (options?.identityHints === void 0 && options?.previousSnapshot === void 0 && options?.identityPolicy === void 0) return input;
+	const policy = options?.identityPolicy ?? introspectedPhysicalIdentityPolicy;
+	const identityDiagnostics = [];
+	const previous = selectPreviousSnapshot(input, options?.previousSnapshot, options?.namespace ?? input.namespace.name, identityDiagnostics);
+	const entries = collectIdentityEntries(input);
+	const previousIndex = previous === void 0 ? void 0 : collectPreviousIdentities(previous);
+	return rewriteCatalog(input, createIdentityResolver(entries, options?.identityHints ?? [], previousIndex, policy, identityDiagnostics), identityDiagnostics);
+}
+function normalizeCatalogDiagnostics(diagnostics, mode) {
+	const normalized = [];
+	let lossy = false;
+	for (const diagnostic of diagnostics) {
+		if (diagnostic.code === "lossy-mapping") lossy = true;
+		if (mode === "lossy" && isRecoverableMappingDiagnostic(diagnostic)) {
+			lossy = true;
+			normalized.push(createIntrospectionDiagnostic({
+				...diagnostic,
+				severity: "warning",
+				code: "lossy-mapping",
+				message: `Lossy mapping omitted an unsafe catalog fact: ${diagnostic.message}`
+			}));
+		} else normalized.push(diagnostic);
+	}
+	return {
+		diagnostics: normalized,
+		lossy
+	};
+}
+function isRecoverableMappingDiagnostic(diagnostic) {
+	if (diagnostic.severity !== "error") return false;
+	if (diagnostic.code === "unresolved-reference" || diagnostic.code === "expression-parse-failed" || diagnostic.code === "unsupported-feature" || diagnostic.code === "ambiguous-identity") return true;
+	return diagnostic.code === "dialect-mismatch" && diagnostic.path[0] === "previousSnapshot";
+}
+function reportMappingIssue(context, input, recoverable = true) {
+	if (context.mode === "lossy" && recoverable) {
+		context.lossy = true;
+		context.diagnostics.push(createIntrospectionDiagnostic({
+			...input,
+			severity: "warning",
+			code: "lossy-mapping",
+			message: `Lossy mapping omitted an unsafe catalog fact: ${input.message}`
+		}));
+		return true;
+	}
+	context.diagnostics.push(createIntrospectionDiagnostic({
+		...input,
+		severity: "error"
+	}));
+	return false;
+}
+function createCatalogReferenceLookup(catalog) {
+	const keys = /* @__PURE__ */ new Set();
+	const scopedKeys = /* @__PURE__ */ new Set();
+	const inferredOwners = /* @__PURE__ */ new Map();
+	const add = (kind, id) => keys.add(referenceKey(kind, id));
+	const addScoped = (kind, id, ownerKind, ownerId) => {
+		add(kind, id);
+		scopedKeys.add(referenceKey(`${kind}:${ownerKind}:${ownerId}`, id));
+		const key = referenceKey(normalizeReferenceKind(kind), id);
+		const owner = {
+			kind: ownerKind,
+			id: ownerId
+		};
+		const existing = inferredOwners.get(key);
+		inferredOwners.set(key, existing === void 0 ? owner : existing === null || existing.kind !== owner.kind || existing.id !== owner.id ? null : existing);
+	};
+	add("namespace", catalog.namespace.name);
+	for (const table of catalog.tables) {
+		add("table", table.id);
+		for (const column of table.columns) addScoped("column", column.id, "table", table.id);
+		for (const constraint of table.constraints) {
+			addScoped("constraint", constraint.id, "table", table.id);
+			addScoped(constraint.kind, constraint.id, "table", table.id);
+		}
+		for (const index of table.indexes) addScoped("index", index.id, "table", table.id);
+	}
+	for (const view of catalog.views) {
+		add(view.kind, view.id);
+		for (const column of view.columns) addScoped("column", column.id, view.kind, view.id);
+	}
+	for (const sequence of catalog.sequences) add("sequence", sequence.id);
+	for (const item of catalog.enums) add("enum", item.id);
+	for (const domain of catalog.domains) {
+		add("domain", domain.id);
+		for (const constraint of domain.constraints ?? []) {
+			addScoped("constraint", constraint.id, "domain", domain.id);
+			addScoped("check", constraint.id, "domain", domain.id);
+		}
+	}
+	for (const collation of catalog.collations) add("collation", collation.id);
+	for (const trigger of catalog.triggers) add("trigger", trigger.id);
+	for (const routine of catalog.routines) add("routine", routine.id);
+	for (const partition of catalog.partitions) add("partition", partition.id);
+	for (const policy of catalog.policies) add("policy", policy.id);
+	for (const extension of catalog.extensionObjects) add("extension", extension.id);
+	for (const object of catalog.deferredObjects) add("deferred-object", object.id ?? `deferred:${object.objectKind}:${object.physicalName}`);
+	for (const object of catalog.opaqueObjects) add("opaque-object", object.id);
+	for (const comment of catalog.comments) add("comment", comment.id);
+	for (const ownership of catalog.ownership) add("ownership", ownership.id);
+	return {
+		has(reference) {
+			if (!keys.has(referenceKey(reference.kind, reference.id))) return false;
+			const owner = reference.owner ?? (isEntityReference(reference) && reference.tableId !== void 0 ? {
+				kind: "table",
+				id: reference.tableId
+			} : void 0);
+			if (owner === void 0) return true;
+			return scopedKeys.has(referenceKey(`${normalizeReferenceKind(reference.kind)}:${owner.kind}:${owner.id}`, reference.id));
+		},
+		owner(reference) {
+			const owner = inferredOwners.get(referenceKey(normalizeReferenceKind(reference.kind), reference.id));
+			return owner === null ? void 0 : owner;
+		}
+	};
+}
+function isEntityReference(reference) {
+	return "tableId" in reference;
+}
+function referenceKey(kind, id) {
+	return `${kind}\u0000${id}`;
+}
+function selectPreviousSnapshot(input, previous, selectedNamespace, diagnostics) {
+	if (previous === void 0) return;
+	const dialectMatches = previous.dialect.name === input.dialect;
+	const namespaceMatches = previous.namespace.kind === input.namespace.kind && previous.namespace.name === selectedNamespace && input.namespace.name === selectedNamespace;
+	if (!dialectMatches || !namespaceMatches) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "dialect-mismatch",
+			message: !dialectMatches ? `Previous snapshot dialect ${previous.dialect.name} does not match ${input.dialect}` : `Previous snapshot namespace ${previous.namespace.name} does not match ${selectedNamespace}`,
+			path: ["previousSnapshot", !dialectMatches ? "dialect" : "namespace"],
+			remediation: "Use a previous snapshot from the same dialect and selected namespace."
+		}));
+		return;
+	}
+	return previous;
+}
+function collectIdentityEntries(input) {
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (object, kind, currentId, physicalName, scopePhysicalName, scopeId, physicalIdentityName = physicalName) => {
+		if (seen.has(object)) return;
+		seen.add(object);
+		entries.push({
+			object,
+			kind,
+			currentId,
+			physicalName,
+			physicalIdentityName,
+			...scopePhysicalName === void 0 ? {} : { scopePhysicalName },
+			...scopeId === void 0 ? {} : { scopeId }
+		});
+	};
+	for (const table of input.tables) {
+		add(table, "table", table.id, table.physicalName);
+		for (const column of table.columns) add(column, "column", column.id, column.physicalName, table.physicalName, table.id);
+		for (const constraint of table.constraints) add(constraint, "constraint", constraint.id, constraint.physicalName ?? constraint.id, table.physicalName, table.id);
+		for (const index of table.indexes) add(index, "index", index.id, index.physicalName ?? index.id, table.physicalName, table.id);
+	}
+	for (const view of input.views ?? []) {
+		add(view, view.kind, view.id, view.physicalName);
+		for (const column of view.columns) add(column, "column", column.id, column.physicalName, view.physicalName, view.id);
+	}
+	for (const sequence of input.sequences ?? []) addObject(sequence, sequence.kind);
+	for (const item of input.enums ?? []) addObject(item, item.kind);
+	for (const domain of input.domains ?? []) {
+		add(domain, "domain", domain.id, domain.physicalName);
+		for (const constraint of domain.constraints ?? []) add(constraint, "constraint", constraint.id, constraint.physicalName ?? constraint.id, domain.physicalName, domain.id);
+	}
+	for (const collation of input.collations ?? []) addObject(collation, collation.kind);
+	for (const trigger of input.triggers ?? []) addObject(trigger, trigger.kind);
+	for (const routine of input.routines ?? []) addObject(routine, routine.kind);
+	for (const partition of input.partitions ?? []) addObject(partition, partition.kind);
+	for (const policy of input.policies ?? []) addObject(policy, policy.kind);
+	for (const extension of input.extensionObjects ?? []) addObject(extension, extension.kind);
+	for (const object of input.opaqueObjects ?? []) addObject(object, object.kind);
+	for (const comment of input.comments ?? []) addMetadataObject(comment, "comment");
+	for (const ownership of input.ownership ?? []) addMetadataObject(ownership, "ownership");
+	const metadataObjects = [
+		input.namespace,
+		...input.tables,
+		...input.views ?? [],
+		...input.sequences ?? [],
+		...input.enums ?? [],
+		...input.domains ?? [],
+		...input.collations ?? [],
+		...input.triggers ?? [],
+		...input.routines ?? [],
+		...input.partitions ?? [],
+		...input.policies ?? [],
+		...input.extensionObjects ?? [],
+		...input.opaqueObjects ?? [],
+		...input.deferredObjects,
+		...input.tables.flatMap((table) => [
+			...table.columns,
+			...table.constraints,
+			...table.indexes
+		]),
+		...(input.views ?? []).flatMap((view) => view.columns),
+		...(input.domains ?? []).flatMap((domain) => domain.constraints ?? [])
+	];
+	for (const object of metadataObjects) {
+		if (object.comment) addMetadataObject(object.comment, "comment");
+		if (object.ownership) addMetadataObject(object.ownership, "ownership");
+	}
+	return entries;
+	function addObject(object, kind) {
+		add(object, kind, object.id, object.physicalName);
+	}
+	function addMetadataObject(object, kind) {
+		add(object, kind, object.id, object.reference?.name ?? object.id, void 0, void 0, object.id);
+	}
+}
+function collectPreviousIdentities(snapshot) {
+	const result = [];
+	const add = (kind, id, physicalName, scopePhysicalName) => result.push({
+		kind,
+		id,
+		physicalName,
+		...scopePhysicalName === void 0 ? {} : { scopePhysicalName }
+	});
+	for (const table of snapshot.tables) {
+		add("table", table.id, table.physicalName);
+		for (const column of table.columns) add("column", column.id, column.physicalName, table.physicalName);
+		for (const constraint of table.constraints) add("constraint", constraint.id, constraint.physicalName, table.physicalName);
+		for (const index of table.indexes) add("index", index.id, index.physicalName, table.physicalName);
+	}
+	for (const view of snapshot.views) {
+		add(view.kind, view.id, view.physicalName);
+		for (const column of view.columns) add("column", column.id, column.physicalName, view.physicalName);
+	}
+	for (const sequence of snapshot.sequences) add("sequence", sequence.id, sequence.physicalName);
+	for (const item of snapshot.enums) add("enum", item.id, item.physicalName);
+	for (const domain of snapshot.domains) {
+		add("domain", domain.id, domain.physicalName);
+		for (const constraint of domain.constraints ?? []) add("constraint", constraint.id, constraint.physicalName, domain.physicalName);
+	}
+	for (const item of snapshot.collations) add("collation", item.id, item.physicalName);
+	for (const item of snapshot.triggers) add("trigger", item.id, item.physicalName);
+	for (const item of snapshot.routines) add("routine", item.id, item.physicalName);
+	for (const item of snapshot.partitions) add("partition", item.id, item.physicalName);
+	for (const item of snapshot.policies) add("policy", item.id, item.physicalName);
+	for (const item of snapshot.extensions) add("extension", item.id, item.physicalName);
+	for (const item of snapshot.opaqueObjects) add("opaque-object", item.id, item.physicalName);
+	for (const item of snapshot.comments) add("comment", item.id, item.physicalName);
+	for (const item of snapshot.ownership) add("ownership", item.id, item.physicalName);
+	return result;
+}
+function createIdentityResolver(entries, hints, previous, policy, diagnostics) {
+	const byObject = /* @__PURE__ */ new Map();
+	const byGlobal = /* @__PURE__ */ new Map();
+	const byScope = /* @__PURE__ */ new Map();
+	const previousBySelector = /* @__PURE__ */ new Map();
+	for (const item of previous ?? []) {
+		const key = identitySelectorKey(item.kind, item.physicalName, item.scopePhysicalName);
+		const existing = previousBySelector.get(key);
+		previousBySelector.set(key, existing === void 0 ? item : null);
+	}
+	for (const entry of entries) {
+		const identity = resolveIdentityEntry(entry, hints, previousBySelector, policy, diagnostics);
+		byObject.set(entry.object, identity);
+		registerIdentity(byGlobal, referenceKey(entry.kind, entry.currentId), {
+			object: entry.object,
+			identity
+		});
+		if (entry.scopeId !== void 0) registerIdentity(byScope, referenceKey(`${entry.kind}:${entry.scopeId}`, entry.currentId), {
+			object: entry.object,
+			identity
+		});
+	}
+	return {
+		forObject(object) {
+			return byObject.get(object);
+		},
+		resolveReference(kind, id, scopeId) {
+			const normalizedKind = normalizeIdentityKind(kind);
+			if (scopeId !== void 0 && normalizedKind !== void 0) {
+				const scoped = byScope.get(referenceKey(`${normalizedKind}:${scopeId}`, id));
+				if (scoped !== void 0 && scoped !== null) return scoped.identity;
+				if (scoped === null) return;
+			}
+			const global = byGlobal.get(referenceKey(normalizedKind ?? kind, id));
+			return global === void 0 || global === null ? void 0 : global.identity;
+		}
+	};
+}
+function registerIdentity(map, key, value) {
+	const existing = map.get(key);
+	map.set(key, existing === void 0 ? value : null);
+}
+function resolveIdentityEntry(entry, hints, previous, policy, diagnostics) {
+	for (const source of policy.precedence) if (source === "explicit-hint") {
+		const matching = hints.filter((hint) => hint.kind === entry.kind && hint.physicalName === entry.physicalName && hint.tablePhysicalName === entry.scopePhysicalName);
+		const logicalIds = [...new Set(matching.map((hint) => hint.logicalId))];
+		if (logicalIds.length > 1) diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "ambiguous-identity",
+			message: `Multiple identity hints match ${entry.kind} ${entry.physicalName}`,
+			path: [entry.kind, entry.physicalName],
+			remediation: "Provide one identity hint for each physical selector."
+		}));
+		else if (logicalIds[0] !== void 0) return {
+			logicalId: logicalIds[0],
+			source
+		};
+	} else if (source === "previous-snapshot") {
+		const match = previous.get(identitySelectorKey(entry.kind, entry.physicalName, entry.scopePhysicalName));
+		if (match !== void 0 && match !== null) return {
+			logicalId: match.id,
+			source
+		};
+		if (match === null) diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "ambiguous-identity",
+			message: `Previous snapshot contains multiple ${entry.kind} objects named ${entry.physicalName}`,
+			path: [
+				"previousSnapshot",
+				entry.kind,
+				entry.physicalName
+			],
+			remediation: "Use an explicit identity hint for the ambiguous object."
+		}));
+	} else if (source === "physical-name" && isSafeIdentityName(entry.physicalIdentityName)) return {
+		logicalId: entry.physicalIdentityName,
+		source
+	};
+	else if (source === "deterministic-fallback") return {
+		logicalId: fallbackIdentity(entry, policy),
+		source
+	};
+	return {
+		logicalId: fallbackIdentity(entry, policy),
+		source: "deterministic-fallback"
+	};
+}
+function identitySelectorKey(kind, physicalName, scopePhysicalName) {
+	return `${kind}\u0000${scopePhysicalName ?? ""}\u0000${physicalName}`;
+}
+function normalizeIdentityKind(kind) {
+	if (kind === "primary-key" || kind === "unique" || kind === "foreign-key" || kind === "check") return "constraint";
+	if (kind === "namespace" || kind === "deferred-object") return;
+	return kind;
+}
+function fallbackIdentity(entry, policy) {
+	const seed = [
+		entry.kind,
+		entry.scopePhysicalName ?? "",
+		entry.physicalName,
+		entry.physicalIdentityName,
+		entry.currentId
+	].join(":");
+	if (policy.fallback === "hashed") return `introspected_${fnv1a32(seed)}`;
+	return escapeIdentity(entry.physicalIdentityName || entry.currentId || entry.physicalName || seed);
+}
+function isSafeIdentityName(value) {
+	if (value.length === 0 || value !== value.trim()) return false;
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		if (character === "." || character === "\\" || character === "/" || character === "\"" || character === "'" || codePoint <= 31 || codePoint === 127) return false;
+	}
+	return true;
+}
+function escapeIdentity(value) {
+	let result = "";
+	for (const character of value) if (isSafeIdentityName(character)) result += character;
+	else result += `_x${character.codePointAt(0)?.toString(16) ?? "0"}_`;
+	return result || "introspected_object";
+}
+function fnv1a32(value) {
+	let hash = 2166136261;
+	for (const byte of new TextEncoder().encode(value)) {
+		hash ^= byte;
+		hash = Math.imul(hash, 16777619) >>> 0;
+	}
+	return hash.toString(16).padStart(8, "0");
+}
+function rewriteCatalog(input, resolver, diagnostics) {
+	return {
+		...input,
+		namespace: rewriteNamespace(input.namespace, resolver),
+		tables: input.tables.map((table) => rewriteTable(table, resolver)),
+		...input.views === void 0 ? {} : { views: input.views.map((view) => rewriteView(view, resolver)) },
+		...input.sequences === void 0 ? {} : { sequences: input.sequences.map((sequence) => rewriteSequence(sequence, resolver)) },
+		...input.enums === void 0 ? {} : { enums: input.enums.map((item) => rewriteEnum(item, resolver)) },
+		...input.domains === void 0 ? {} : { domains: input.domains.map((domain) => rewriteDomain(domain, resolver)) },
+		...input.collations === void 0 ? {} : { collations: input.collations.map((item) => rewriteCollation(item, resolver)) },
+		...input.triggers === void 0 ? {} : { triggers: input.triggers.map((item) => rewriteTrigger(item, resolver)) },
+		...input.routines === void 0 ? {} : { routines: input.routines.map((item) => rewriteRoutine(item, resolver)) },
+		...input.partitions === void 0 ? {} : { partitions: input.partitions.map((item) => rewritePartition(item, resolver)) },
+		...input.policies === void 0 ? {} : { policies: input.policies.map((item) => rewritePolicy(item, resolver)) },
+		...input.extensionObjects === void 0 ? {} : { extensionObjects: input.extensionObjects.map((item) => rewriteExtension(item, resolver)) },
+		deferredObjects: input.deferredObjects.map((item) => rewriteDeferred(item, resolver)),
+		...input.opaqueObjects === void 0 ? {} : { opaqueObjects: input.opaqueObjects.map((item) => rewriteOpaque(item, resolver)) },
+		...input.comments === void 0 ? {} : { comments: input.comments.map((item) => rewriteComment(item, resolver)) },
+		...input.ownership === void 0 ? {} : { ownership: input.ownership.map((item) => rewriteOwnership(item, resolver)) },
+		diagnostics: [...input.diagnostics, ...diagnostics]
+	};
+}
+function rewriteNamespace(namespace, resolver) {
+	return { ...rewriteMetadata(namespace, resolver) };
+}
+function rewriteTable(table, resolver) {
+	const owner = {
+		kind: "table",
+		id: table.id
+	};
+	return {
+		...rewriteMetadata(table, resolver),
+		...rewriteIdentityFields(table, resolver),
+		columns: table.columns.map((column) => ({
+			...rewriteMetadata(column, resolver, owner),
+			...rewriteIdentityFields(column, resolver)
+		})),
+		constraints: table.constraints.map((constraint) => rewriteConstraint(constraint, resolver, owner)),
+		indexes: table.indexes.map((index) => rewriteIndex(index, resolver, owner))
+	};
+}
+function rewriteConstraint(constraint, resolver, owner) {
+	const backingIndex = (constraint.kind === "primary-key" || constraint.kind === "unique") && constraint.backingIndex !== void 0 ? rewriteCatalogReference(constraint.backingIndex, resolver, owner) : void 0;
+	return {
+		...rewriteMetadata(constraint, resolver, owner),
+		...rewriteIdentityFields(constraint, resolver),
+		...backingIndex === void 0 ? {} : { backingIndex }
+	};
+}
+function rewriteIndex(index, resolver, owner) {
+	return {
+		...rewriteMetadata(index, resolver, owner),
+		...rewriteIdentityFields(index, resolver),
+		...index.backingConstraint === void 0 ? {} : { backingConstraint: rewriteCatalogReference(index.backingConstraint, resolver, owner) }
+	};
+}
+function rewriteView(view, resolver) {
+	const owner = {
+		kind: view.kind,
+		id: view.id
+	};
+	return {
+		...rewriteMetadata(view, resolver),
+		...rewriteIdentityFields(view, resolver),
+		columns: view.columns.map((column) => ({
+			...rewriteMetadata(column, resolver, owner),
+			...rewriteIdentityFields(column, resolver)
+		})),
+		...view.dependencies === void 0 ? {} : { dependencies: view.dependencies.map((reference) => rewriteCatalogReference(reference, resolver)) }
+	};
+}
+function rewriteSequence(sequence, resolver) {
+	return {
+		...rewriteMetadata(sequence, resolver),
+		...rewriteIdentityFields(sequence, resolver),
+		...sequence.ownedBy === void 0 ? {} : { ownedBy: rewriteCatalogReference(sequence.ownedBy, resolver) }
+	};
+}
+function rewriteEnum(item, resolver) {
+	return {
+		...rewriteMetadata(item, resolver),
+		...rewriteIdentityFields(item, resolver)
+	};
+}
+function rewriteDomain(domain, resolver) {
+	const owner = {
+		kind: "domain",
+		id: domain.id
+	};
+	return {
+		...rewriteMetadata(domain, resolver),
+		...rewriteIdentityFields(domain, resolver),
+		...domain.constraints === void 0 ? {} : { constraints: domain.constraints.map((constraint) => ({
+			...rewriteMetadata(constraint, resolver, owner),
+			...rewriteIdentityFields(constraint, resolver)
+		})) }
+	};
+}
+function rewriteCollation(item, resolver) {
+	return {
+		...rewriteMetadata(item, resolver),
+		...rewriteIdentityFields(item, resolver)
+	};
+}
+function rewriteTrigger(trigger, resolver) {
+	return {
+		...rewriteMetadata(trigger, resolver),
+		...rewriteIdentityFields(trigger, resolver),
+		table: rewriteCatalogReference(trigger.table, resolver)
+	};
+}
+function rewriteRoutine(routine, resolver) {
+	return {
+		...rewriteMetadata(routine, resolver),
+		...rewriteIdentityFields(routine, resolver),
+		...routine.dependencies === void 0 ? {} : { dependencies: routine.dependencies.map((reference) => rewriteCatalogReference(reference, resolver)) }
+	};
+}
+function rewritePartition(partition, resolver) {
+	return {
+		...rewriteMetadata(partition, resolver),
+		...rewriteIdentityFields(partition, resolver),
+		parent: rewriteCatalogReference(partition.parent, resolver)
+	};
+}
+function rewritePolicy(policy, resolver) {
+	return {
+		...rewriteMetadata(policy, resolver),
+		...rewriteIdentityFields(policy, resolver),
+		table: rewriteCatalogReference(policy.table, resolver)
+	};
+}
+function rewriteExtension(extension, resolver) {
+	return {
+		...rewriteMetadata(extension, resolver),
+		...rewriteIdentityFields(extension, resolver)
+	};
+}
+function rewriteOpaque(object, resolver) {
+	return {
+		...rewriteMetadata(object, resolver),
+		...rewriteIdentityFields(object, resolver)
+	};
+}
+function rewriteDeferred(object, resolver) {
+	return rewriteMetadata(object, resolver);
+}
+function rewriteMetadata(object, resolver, fallbackOwner) {
+	return {
+		...object,
+		...object.comment === void 0 ? {} : { comment: rewriteComment(object.comment, resolver, fallbackOwner) },
+		...object.ownership === void 0 ? {} : { ownership: rewriteOwnership(object.ownership, resolver, fallbackOwner) }
+	};
+}
+function rewriteIdentityFields(object, resolver) {
+	const identity = resolver.forObject(object);
+	return identity === void 0 ? {
+		id: object.id,
+		identitySource: object.identitySource
+	} : {
+		id: identity.logicalId,
+		identitySource: identity.source
+	};
+}
+function rewriteCatalogReference(reference, resolver, fallbackOwner) {
+	const tableId = isEntityReference(reference) ? reference.tableId : void 0;
+	const referenceOwner = reference.owner ?? (tableId === void 0 ? fallbackOwner : {
+		kind: "table",
+		id: tableId
+	});
+	const identity = resolver.resolveReference(reference.kind, reference.id, referenceOwner?.id);
+	const tableIdentity = referenceOwner?.kind === "table" ? resolver.resolveReference("table", referenceOwner.id) : void 0;
+	const rewrittenOwner = referenceOwner === void 0 ? void 0 : rewriteCatalogOwner(referenceOwner, resolver);
+	return {
+		...reference,
+		id: identity?.logicalId ?? reference.id,
+		...reference.owner !== void 0 || fallbackOwner !== void 0 && tableId === void 0 ? { owner: rewrittenOwner } : {},
+		...tableId === void 0 ? {} : { tableId: tableIdentity?.logicalId ?? tableId }
+	};
+}
+function rewriteCatalogOwner(owner, resolver) {
+	const identity = resolver.resolveReference(owner.kind, owner.id);
+	return {
+		...owner,
+		id: identity?.logicalId ?? owner.id
+	};
+}
+function rewriteComment(comment, resolver, fallbackOwner) {
+	const identity = resolver.forObject(comment);
+	return {
+		...comment,
+		...identity === void 0 ? {} : { id: identity.logicalId },
+		object: rewriteCatalogReference(comment.object, resolver, fallbackOwner)
+	};
+}
+function rewriteOwnership(ownership, resolver, fallbackOwner) {
+	const identity = resolver.forObject(ownership);
+	return {
+		...ownership,
+		...identity === void 0 ? {} : { id: identity.logicalId },
+		object: rewriteCatalogReference(ownership.object, resolver, fallbackOwner)
+	};
+}
+function mapTable(table, dialect, tables, context) {
+	const owner = {
+		kind: "table",
+		id: table.id
+	};
+	const columns = table.columns.map((column) => mapColumn(column, dialect)).sort(compareId);
+	const columnIds = new Map(table.columns.map((column) => [column.physicalName, column.id]));
+	const columnNullability = new Map(table.columns.map((column) => [column.physicalName, column.nullable]));
+	const snapshotColumnNullability = new Map(table.columns.map((column) => [column.id, column.nullable]));
+	const constraints = table.constraints.map((constraint) => mapConstraint(constraint, dialect, columnIds, columnNullability, tables, context, [
+		"tables",
+		table.id,
+		"constraints",
+		constraint.id
+	], owner)).filter((value) => value !== void 0).sort(compareId);
+	const indexes = table.indexes.map((index) => mapIndex(index, dialect, columnIds, snapshotColumnNullability, context, [
+		"tables",
+		table.id,
+		"indexes",
+		index.id
+	], owner)).filter((index) => index !== void 0).sort(compareId);
+	return {
+		kind: "table",
+		id: table.id,
+		physicalName: table.physicalName,
+		columns,
+		constraints,
+		indexes,
+		...mapMetadata(table.provenance, table.dialect, dialect, table.reference)
+	};
+}
+function mapColumn(column, dialect) {
+	const defaultValue = column.default ? mapValueFact(column.default) : void 0;
+	const generatedColumn = column.generated ? column.generated.mode === "unknown" ? { kind: "external" } : {
+		kind: "expression",
+		expression: mapExpression(column.generated.expression),
+		mode: column.generated.mode
+	} : void 0;
+	const identity = column.identity ? mapIdentity(column.identity, dialect) : void 0;
+	return {
+		kind: "column",
+		id: column.id,
+		physicalName: column.physicalName,
+		ordinalPosition: column.ordinalPosition,
+		nullable: column.nullable,
+		hasDefault: defaultValue !== void 0,
+		generated: generatedColumn !== void 0 || identity !== void 0,
+		storage: mapStorage(column.storage, dialect),
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		...generatedColumn === void 0 ? {} : { generatedColumn },
+		...identity === void 0 ? {} : { identity },
+		...column.onUpdate === void 0 ? {} : { onUpdate: mapExpression(column.onUpdate) },
+		...mapMetadata(column.provenance, column.dialect, dialect, column.reference)
+	};
+}
+function mapConstraint(constraint, dialect, columns, columnNullability, tables, context, path, owner) {
+	const physicalName = constraint.physicalName ?? constraint.id;
+	const common = {
+		id: constraint.id,
+		physicalName,
+		...mapMetadata(constraint.provenance, constraint.dialect, dialect, constraint.reference)
+	};
+	const mappedColumns = constraint.kind === "check" ? void 0 : mapColumnNames(constraint.columns, columns, context, [...path, "columns"]);
+	if (mappedColumns === void 0 && context.mode === "lossy") return;
+	const backingIndex = constraint.kind === "primary-key" || constraint.kind === "unique" ? constraint.backingIndex === void 0 ? void 0 : mapReference(constraint.backingIndex, context, [...path, "backingIndex"], "index", owner) : void 0;
+	if (constraint.kind === "check") return {
+		kind: "check",
+		...common,
+		expression: mapExpression(constraint.expression),
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+	if (constraint.kind === "primary-key") return {
+		kind: "primary-key",
+		...common,
+		columns: mappedColumns ?? [],
+		...backingIndex === void 0 ? {} : { backingIndex },
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+	if (constraint.kind === "unique") {
+		if (!constraint.columns.some((column) => columnNullability.get(column) === true) && constraint.nulls === "distinct") return {
+			kind: "unique",
+			...common,
+			columns: mappedColumns ?? [],
+			...backingIndex === void 0 ? {} : { backingIndex },
+			...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+			...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+			...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+		};
+		return {
+			kind: "unique-constraint",
+			...common,
+			columns: mappedColumns ?? [],
+			nulls: constraint.nulls,
+			...backingIndex === void 0 ? {} : { backingIndex },
+			...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+			...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+			...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+		};
+	}
+	const targetTable = tables.get(constraint.target.table);
+	const targetId = targetTable?.id;
+	if (targetId === void 0) {
+		if (reportMappingIssue(context, {
+			code: "unresolved-reference",
+			message: `Foreign-key target table ${constraint.target.table} was not found`,
+			path: [
+				...path,
+				"target",
+				"table"
+			]
+		})) return;
+	}
+	const targetColumnIds = targetTable ? new Map(targetTable.columns.map((column) => [column.physicalName, column.id])) : /* @__PURE__ */ new Map();
+	const targetColumns = mapColumnNames(constraint.target.columns, targetColumnIds, context, [
+		...path,
+		"target",
+		"columns"
+	]);
+	if (targetColumns === void 0 && context.mode === "lossy") return;
+	return {
+		kind: "foreign-key",
+		...common,
+		columns: mappedColumns ?? [],
+		target: {
+			table: {
+				kind: "table",
+				id: targetId ?? constraint.target.table
+			},
+			columns: targetColumns ?? []
+		},
+		...constraint.onUpdate === void 0 ? {} : { onUpdate: constraint.onUpdate },
+		...constraint.onDelete === void 0 ? {} : { onDelete: constraint.onDelete },
+		...constraint.match === void 0 ? {} : { match: constraint.match },
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+}
+function mapColumnNames(names, columns, context, path) {
+	let missing = false;
+	const result = names.map((name, index) => {
+		const id = columns.get(name);
+		if (id !== void 0) return id;
+		missing = true;
+		reportMappingIssue(context, {
+			code: "unresolved-reference",
+			message: `Column ${name} was not found`,
+			path: [...path, index]
+		});
+		return name;
+	});
+	return missing && context.mode === "lossy" ? void 0 : result;
+}
+function mapOptionalColumnNames(names, columns, context, path) {
+	if (names === void 0) return;
+	return mapColumnNames(names, columns, context, path);
+}
+function mapIndex(index, dialect, columns, snapshotColumnNullability, context, path, owner) {
+	const terms = index.terms.map((term, position) => mapIndexTerm(term, columns, context, [
+		...path,
+		"terms",
+		position
+	]));
+	if (terms.some((term) => term === void 0) && context.mode === "lossy") return;
+	const includedColumns = mapOptionalColumnNames(index.includedColumns, columns, context, [...path, "includedColumns"]);
+	const backingConstraint = index.backingConstraint === void 0 ? void 0 : mapReference(index.backingConstraint, context, [...path, "backingConstraint"], "constraint", owner);
+	const mapped = {
+		kind: "index",
+		id: index.id,
+		physicalName: index.physicalName ?? index.id,
+		terms: terms.filter((term) => term !== void 0).sort((left, right) => left.position - right.position),
+		unique: index.unique,
+		candidateKey: false,
+		...index.predicate === void 0 ? {} : { predicate: mapExpression(index.predicate) },
+		...includedColumns === void 0 ? {} : { includedColumns },
+		...backingConstraint === void 0 ? {} : { backingConstraint },
+		...index.method === void 0 ? {} : { method: index.method },
+		...mapMetadata(void 0, index.dialect, dialect, index.reference)
+	};
+	return {
+		...mapped,
+		candidateKey: hasCandidateKeyShape(mapped, snapshotColumnNullability)
+	};
+}
+function mapIndexTerm(term, columns, context, path) {
+	if (term.kind === "column") {
+		const column = columns.get(term.column);
+		if (column === void 0) {
+			if (reportMappingIssue(context, {
+				code: "unresolved-reference",
+				message: `Index column ${term.column} was not found`,
+				path
+			})) return;
+		}
+		return {
+			kind: "column",
+			column: column ?? term.column,
+			position: term.position,
+			...term.direction === void 0 ? {} : { direction: term.direction },
+			...term.nulls === void 0 ? {} : { nulls: term.nulls },
+			...term.prefixLength === void 0 ? {} : { prefixLength: mapValueFact(term.prefixLength) },
+			...term.operatorClass === void 0 ? {} : { operatorClass: term.operatorClass }
+		};
+	}
+	return {
+		kind: "expression",
+		expression: mapExpression(term.expression),
+		position: term.position,
+		...term.direction === void 0 ? {} : { direction: term.direction },
+		...term.nulls === void 0 ? {} : { nulls: term.nulls },
+		...term.operatorClass === void 0 ? {} : { operatorClass: term.operatorClass }
+	};
+}
+function mapView(view, dialect, context, path) {
+	const dependencies = view.dependencies?.flatMap((reference, index) => {
+		const mapped = mapReference(reference, context, [
+			...path,
+			"dependencies",
+			index
+		]);
+		return mapped === void 0 ? [] : [mapped];
+	});
+	return {
+		kind: view.kind,
+		id: view.id,
+		physicalName: view.physicalName,
+		columns: view.columns.map((column) => mapColumn(column, dialect)).sort(compareId),
+		definition: mapExpression(view.definition),
+		...dependencies === void 0 ? {} : { dependencies },
+		...view.checkOption === void 0 ? {} : { checkOption: view.checkOption },
+		...view.securityBarrier === void 0 ? {} : { securityBarrier: view.securityBarrier },
+		...view.securityInvoker === void 0 ? {} : { securityInvoker: view.securityInvoker },
+		...mapMetadata(view.provenance, view.dialect, dialect, view.reference)
+	};
+}
+function mapSequence(sequence, dialect, context, path) {
+	const ownedBy = sequence.ownedBy === void 0 ? void 0 : mapReference(sequence.ownedBy, context, [...path, "ownedBy"]);
+	return {
+		kind: "sequence",
+		id: sequence.id,
+		physicalName: sequence.physicalName,
+		...sequence.storage === void 0 ? {} : { storage: mapStorage(sequence.storage, dialect) },
+		...sequence.start === void 0 ? {} : { start: mapValueFact(sequence.start) },
+		...sequence.increment === void 0 ? {} : { increment: mapValueFact(sequence.increment) },
+		...sequence.minimum === void 0 ? {} : { minimum: mapValueFact(sequence.minimum) },
+		...sequence.maximum === void 0 ? {} : { maximum: mapValueFact(sequence.maximum) },
+		...sequence.cache === void 0 ? {} : { cache: mapValueFact(sequence.cache) },
+		...sequence.cycle === void 0 ? {} : { cycle: sequence.cycle },
+		...ownedBy === void 0 ? {} : { ownedBy },
+		...sequence.identity === void 0 ? {} : { identity: mapIdentity(sequence.identity, dialect) },
+		...mapMetadata(sequence.provenance, sequence.dialect, dialect, sequence.reference)
+	};
+}
+function mapEnum(item, dialect) {
+	return {
+		kind: "enum",
+		id: item.id,
+		physicalName: item.physicalName,
+		values: [...item.values].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((value) => ({
+			value: value.value,
+			ordinalPosition: value.ordinalPosition,
+			...value.provenance === void 0 ? {} : { provenance: mapProvenance(value.provenance) }
+		})),
+		...mapMetadata(item.provenance, item.dialect, dialect, item.reference)
+	};
+}
+function mapDomain(domain, dialect) {
+	return {
+		kind: "domain",
+		id: domain.id,
+		physicalName: domain.physicalName,
+		storage: mapStorage(domain.storage, dialect),
+		...domain.nullable === void 0 ? {} : { nullable: domain.nullable },
+		...domain.default === void 0 ? {} : { default: mapValueFact(domain.default) },
+		...domain.constraints === void 0 ? {} : { constraints: domain.constraints.map((constraint) => mapCheckConstraint(constraint, dialect)).sort(compareId) },
+		...mapMetadata(domain.provenance, domain.dialect, dialect, domain.reference)
+	};
+}
+function mapCheckConstraint(constraint, dialect) {
+	return {
+		kind: "check",
+		id: constraint.id,
+		physicalName: constraint.physicalName ?? constraint.id,
+		expression: mapExpression(constraint.expression),
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated },
+		...mapMetadata(constraint.provenance, constraint.dialect, dialect, constraint.reference)
+	};
+}
+function mapTrigger(trigger, dialect, context, path) {
+	const table = mapReference(trigger.table, context, [...path, "table"], "table");
+	if (table === void 0 && context.mode === "lossy") return;
+	return {
+		kind: "trigger",
+		id: trigger.id,
+		physicalName: trigger.physicalName,
+		table: table ?? {
+			kind: "table",
+			id: trigger.table.id
+		},
+		timing: trigger.timing,
+		events: [...trigger.events].sort(),
+		...trigger.orientation === void 0 ? {} : { orientation: trigger.orientation },
+		...trigger.condition === void 0 ? {} : { condition: mapExpression(trigger.condition) },
+		body: mapExpression(trigger.body),
+		...trigger.enabled === void 0 ? {} : { enabled: trigger.enabled },
+		...mapMetadata(trigger.provenance, trigger.dialect, dialect, trigger.reference)
+	};
+}
+function mapRoutine(routine, dialect, context, path) {
+	const dependencies = routine.dependencies?.flatMap((reference, index) => {
+		const mapped = mapReference(reference, context, [
+			...path,
+			"dependencies",
+			index
+		]);
+		return mapped === void 0 ? [] : [mapped];
+	});
+	return {
+		kind: "routine",
+		id: routine.id,
+		physicalName: routine.physicalName,
+		routineKind: routine.routineKind,
+		parameters: [...routine.parameters].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((parameter) => mapRoutineParameter(parameter, dialect)),
+		...routine.returnType === void 0 ? {} : { returnType: mapStorage(routine.returnType, dialect) },
+		...routine.language === void 0 ? {} : { language: routine.language },
+		...routine.body === void 0 ? {} : { body: mapExpression(routine.body) },
+		...routine.volatility === void 0 ? {} : { volatility: routine.volatility },
+		...routine.parallel === void 0 ? {} : { parallel: routine.parallel },
+		...routine.security === void 0 ? {} : { security: routine.security },
+		...dependencies === void 0 ? {} : { dependencies },
+		...mapMetadata(routine.provenance, routine.dialect, dialect, routine.reference)
+	};
+}
+function mapRoutineParameter(parameter, dialect) {
+	return {
+		...parameter.name === void 0 ? {} : { name: parameter.name },
+		...parameter.mode === void 0 ? {} : { mode: parameter.mode },
+		storage: mapStorage(parameter.storage, dialect),
+		...parameter.default === void 0 ? {} : { default: mapValueFact(parameter.default) },
+		ordinalPosition: parameter.ordinalPosition,
+		...parameter.provenance === void 0 ? {} : { provenance: mapProvenance(parameter.provenance) }
+	};
+}
+function mapPartition(partition, dialect, context, path) {
+	const parent = mapReference(partition.parent, context, [...path, "parent"], "table");
+	if (parent === void 0 && context.mode === "lossy") return;
+	return {
+		kind: "partition",
+		id: partition.id,
+		physicalName: partition.physicalName,
+		parent: parent ?? {
+			kind: "table",
+			id: partition.parent.id
+		},
+		strategy: partition.strategy,
+		...partition.keyColumns === void 0 ? {} : { keyColumns: [...partition.keyColumns] },
+		...partition.bound === void 0 ? {} : { bound: mapExpression(partition.bound) },
+		...partition.default === void 0 ? {} : { default: partition.default },
+		...mapMetadata(partition.provenance, partition.dialect, dialect, partition.reference)
+	};
+}
+function mapPolicy(policy, dialect, context, path) {
+	const table = mapReference(policy.table, context, [...path, "table"], "table");
+	if (table === void 0 && context.mode === "lossy") return;
+	return {
+		kind: "policy",
+		id: policy.id,
+		physicalName: policy.physicalName,
+		table: table ?? {
+			kind: "table",
+			id: policy.table.id
+		},
+		command: policy.command,
+		...policy.roles === void 0 ? {} : { roles: [...policy.roles].sort() },
+		...policy.permissive === void 0 ? {} : { permissive: policy.permissive },
+		...policy.using === void 0 ? {} : { using: mapExpression(policy.using) },
+		...policy.check === void 0 ? {} : { check: mapExpression(policy.check) },
+		...mapMetadata(policy.provenance, policy.dialect, dialect, policy.reference)
+	};
+}
+function mapExtensionObject(extension, dialect) {
+	return {
+		kind: "extension",
+		id: extension.id,
+		physicalName: extension.physicalName,
+		extensionName: extension.extensionName,
+		...extension.extensionVersion === void 0 ? {} : { extensionVersion: extension.extensionVersion },
+		...extension.schema === void 0 ? {} : { schema: extension.schema },
+		data: toSnapshotJsonValue(extension.data),
+		...extension.configuration === void 0 ? {} : { configuration: toSnapshotJsonValue(extension.configuration) },
+		...mapMetadata(extension.provenance, extension.dialect, dialect, extension.reference)
+	};
+}
+function mapDeferredObject(object, dialect) {
+	const data = object.unknownFields ? Object.fromEntries(object.unknownFields.map((field) => [field.name, toSnapshotJsonValue(isCatalogSqlExpression(field.value) ? field.value.text : field.value)])) : void 0;
+	return {
+		kind: "deferred-object",
+		id: object.id ?? `deferred:${object.objectKind}:${object.physicalName}`,
+		objectKind: object.objectKind,
+		physicalName: object.physicalName,
+		...data === void 0 ? {} : { data: toSnapshotJsonValue(data) },
+		...mapMetadata(object.provenance, object.dialect, dialect, object.reference)
+	};
+}
+function mapOpaqueObject(object, dialect) {
+	return {
+		kind: "opaque-object",
+		id: object.id,
+		objectKind: object.objectKind,
+		physicalName: object.physicalName,
+		data: toSnapshotJsonValue(object.data),
+		...object.sql === void 0 ? {} : { sql: mapExpression(object.sql) },
+		...mapMetadata(object.provenance, object.dialect, dialect, object.reference)
+	};
+}
+function mapComment(comment, dialect, context, path, fallbackOwner) {
+	const object = mapReference(comment.object, context, [...path, "object"], void 0, fallbackOwner);
+	if (object === void 0 && context.mode === "lossy") return;
+	return {
+		kind: "comment",
+		id: comment.id,
+		physicalName: comment.reference?.name ?? comment.id,
+		object: object ?? comment.object,
+		text: comment.text,
+		...mapMetadata(comment.provenance, comment.dialect, dialect, comment.reference)
+	};
+}
+function mapOwnership(ownership, dialect, context, path, fallbackOwner) {
+	const object = mapReference(ownership.object, context, [...path, "object"], void 0, fallbackOwner);
+	if (object === void 0 && context.mode === "lossy") return;
+	return {
+		kind: "ownership",
+		id: ownership.id,
+		physicalName: ownership.reference?.name ?? ownership.id,
+		object: object ?? ownership.object,
+		owner: ownership.owner,
+		...mapMetadata(ownership.provenance, ownership.dialect, dialect, ownership.reference)
+	};
+}
+function mapStorage(storage, dialect) {
+	return {
+		kind: "native",
+		dialect,
+		type: storage.nativeType,
+		...dialect === "sqlite" ? { affinity: storageAffinity(storage.nativeType) } : {}
+	};
+}
+function mapValueFact(value) {
+	if (value.kind === "literal") return {
+		kind: "literal",
+		value: mapLiteral(value)
+	};
+	return {
+		kind: "expression",
+		expression: mapExpression(value.expression)
+	};
+}
+function mapLiteral(value) {
+	if (value.value === null) return { kind: "null" };
+	if (typeof value.value === "boolean") return {
+		kind: "boolean",
+		value: value.value
+	};
+	if (typeof value.value === "bigint") return {
+		kind: "bigint",
+		value: value.value.toString()
+	};
+	if (typeof value.value === "number") return {
+		kind: "number",
+		value: String(value.value)
+	};
+	return {
+		kind: "string",
+		value: value.value
+	};
+}
+function mapIdentity(identity, dialect) {
+	return {
+		kind: "identity",
+		generation: identity.generation,
+		options: Object.fromEntries(Object.entries(identity.options).map(([key, value]) => [key, mapValueFact(value)])),
+		...mapMetadata(void 0, identity.dialect, dialect)
+	};
+}
+function mapExpression(value) {
+	return {
+		kind: "expression",
+		expressionKind: "unsafe",
+		sql: value.text.replace(/\r\n?/g, "\n").trim(),
+		dialect: value.dialect
+	};
+}
+function mapMetadata(provenance, extension, dialect, reference) {
+	const mappedProvenance = provenance ? mapProvenance(provenance) : void 0;
+	const mappedExtension = extension ? {
+		dialect: extension.dialect,
+		version: extension.version,
+		data: toSnapshotJsonValue(extension.data)
+	} : void 0;
+	const physicalReference = reference ? {
+		kind: reference.kind,
+		...reference.namespace === void 0 ? {} : { namespace: reference.namespace },
+		...reference.table === void 0 ? {} : { table: reference.table },
+		name: reference.name
+	} : void 0;
+	return {
+		...mappedProvenance === void 0 ? {} : { provenance: mappedProvenance },
+		...physicalReference === void 0 ? {} : { physicalReference },
+		...mappedExtension === void 0 ? {} : { dialect: mappedExtension }
+	};
+}
+function mapProvenance(value) {
+	return {
+		kind: value.kind,
+		dialect: value.dialect,
+		...value.path === void 0 ? {} : { path: [...value.path] }
+	};
+}
+function mapReference(reference, context, path, expectedKind, fallbackOwner) {
+	const kind = normalizeReferenceKind(reference.kind);
+	const tableId = isEntityReference(reference) ? reference.tableId : void 0;
+	const explicitOwner = reference.owner ?? (tableId === void 0 ? fallbackOwner : {
+		kind: "table",
+		id: tableId
+	});
+	const lookupReference = {
+		...reference,
+		kind,
+		...explicitOwner === void 0 ? {} : { owner: explicitOwner }
+	};
+	const owner = explicitOwner ?? context.references.owner(lookupReference);
+	const scopedLookupReference = {
+		...lookupReference,
+		...owner === void 0 ? {} : { owner }
+	};
+	const validKind = expectedKind === void 0 || kind === expectedKind;
+	const ownerRequired = kind === "column" || kind === "constraint" || kind === "index";
+	const validReference = context.references.has(scopedLookupReference);
+	if (!validKind || !validReference || ownerRequired && owner === void 0) {
+		if (reportMappingIssue(context, {
+			code: "unresolved-reference",
+			message: !validKind ? `Reference kind ${reference.kind} is not valid here` : ownerRequired && owner === void 0 ? `Reference ${reference.kind}:${reference.id} has no unique owner scope` : `Reference ${reference.kind}:${reference.id} was not found`,
+			path
+		})) return;
+	}
+	return {
+		kind,
+		id: reference.id,
+		...owner === void 0 ? {} : { owner }
+	};
+}
+function normalizeReferenceKind(kind) {
+	return kind === "primary-key" || kind === "unique" || kind === "foreign-key" || kind === "check" ? "constraint" : kind;
+}
+function catalogObjectList(catalog) {
+	const topLevel = [
+		catalog.namespace,
+		...catalog.tables,
+		...catalog.views,
+		...catalog.sequences,
+		...catalog.enums,
+		...catalog.domains,
+		...catalog.collations,
+		...catalog.triggers,
+		...catalog.routines,
+		...catalog.partitions,
+		...catalog.policies,
+		...catalog.extensionObjects,
+		...catalog.deferredObjects,
+		...catalog.opaqueObjects,
+		...catalog.comments,
+		...catalog.ownership
+	];
+	const nested = [
+		...catalog.tables.flatMap((table) => {
+			const owner = {
+				kind: "table",
+				id: table.id
+			};
+			return [
+				...table.columns.map((object) => ({
+					...object,
+					ownerScope: owner
+				})),
+				...table.constraints.map((object) => ({
+					...object,
+					ownerScope: owner
+				})),
+				...table.indexes.map((object) => ({
+					...object,
+					ownerScope: owner
+				}))
+			];
+		}),
+		...catalog.views.flatMap((view) => {
+			const owner = {
+				kind: view.kind,
+				id: view.id
+			};
+			return view.columns.map((object) => ({
+				...object,
+				ownerScope: owner
+			}));
+		}),
+		...catalog.domains.flatMap((domain) => {
+			const owner = {
+				kind: "domain",
+				id: domain.id
+			};
+			return (domain.constraints ?? []).map((object) => ({
+				...object,
+				ownerScope: owner
+			}));
+		})
+	];
+	return [...topLevel, ...nested];
+}
+function catalogObjectsWithUnknownFields(catalog) {
+	return catalogObjectList(catalog);
+}
+function mapUnknownField(object, field, dialect) {
+	const sql = isCatalogSqlExpression(field.value) ? mapExpression(field.value) : void 0;
+	const value = isCatalogSqlExpression(field.value) ? field.value.text : field.value;
+	return {
+		kind: "opaque-object",
+		id: `unknown:${object.kind}:${object.id ?? object.physicalName ?? "object"}:${field.name}`,
+		objectKind: "unknown-field",
+		physicalName: object.physicalName ?? object.id ?? field.name,
+		data: toSnapshotJsonValue({
+			ownerKind: object.kind,
+			ownerId: object.id ?? object.physicalName ?? field.name,
+			field: field.name,
+			value
+		}),
+		...sql === void 0 ? {} : { sql },
+		...mapMetadata(field.provenance, void 0, dialect)
+	};
+}
+function compareId(left, right) {
+	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+function isCatalogSqlExpression(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && value.kind === "sql" && typeof value.text === "string";
+}
+//#endregion
+//#region src/introspection/snapshot.ts
+/**
+* Map a normalized catalog to the canonical Snapshot v1 object model.
+*
+* Snapshot identity and namespace facts come from the normalized catalog, with explicit identity
+* continuity options applied during the mapping step. Strict mode fails on mapping errors; lossy
+* mode may omit recoverable facts and marks successful output accordingly.
+*/
+function mapCatalogToSnapshot(catalog, options) {
+	return mapCatalogToCompleteSnapshot(catalog, options);
+}
+//#endregion
+export { createCompleteIntrospectionCatalog as a, candidateKeyIndexColumns as c, introspectedPhysicalIdentityPolicy as i, hasCandidateKeyShape as l, mapCatalogToCompleteSnapshot as n, freezeIntrospectionCatalog as o, mapCatalogToSnapshotV1 as r, toIntrospectionCatalog as s, mapCatalogToSnapshot as t, isCandidateKeyIndex as u };