qubu 0.0.0 → 0.3.4

package/dist/complete-D5Djh-zo.mjs

@@ -0,0 +1,1788 @@
+import { n as canonicalJson } from "./canonical-BbnqavJm.mjs";
+//#region src/snapshot/complete-types.ts
+/** The stable envelope tag shared by Snapshot v1 and the complete model. */
+const completeSchemaSnapshotFormat = "qubu-schema";
+/** The strict format version for the complete catalog/object model. */
+const completeSchemaSnapshotVersion = 2;
+/** Descriptive alias for consumers that select a numbered snapshot version. */
+const schemaSnapshotV2Version = 2;
+/** Explicit format-version aliases for generated tooling and fixtures. */
+const schemaSnapshotCompleteVersion = 2;
+const schemaSnapshotVersion2 = 2;
+//#endregion
+//#region src/snapshot/complete.ts
+/** Error raised by throwing APIs after collecting strict v2 diagnostics. */
+var CompleteSnapshotValidationError = class extends TypeError {
+	name = "CompleteSnapshotValidationError";
+	diagnostics;
+	issues;
+	constructor(diagnostics) {
+		const frozen = Object.freeze(diagnostics.map((issue) => Object.freeze({
+			...issue,
+			path: Object.freeze([...issue.path]),
+			relatedPaths: issue.relatedPaths ? Object.freeze(issue.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
+		})));
+		super(frozen.map((issue) => issue.message).join("\n"));
+		this.diagnostics = frozen;
+		this.issues = frozen;
+	}
+};
+/** Decode and strictly validate a complete Snapshot v2 JSON value. */
+function decodeCompleteSchemaSnapshot(input) {
+	let value = input;
+	if (typeof input === "string") try {
+		value = JSON.parse(input);
+	} catch (error) {
+		return {
+			ok: false,
+			diagnostics: Object.freeze([issue("invalid-snapshot", `Snapshot JSON could not be parsed: ${error instanceof Error ? error.message : String(error)}`, [])])
+		};
+	}
+	if (!isRecord(value)) return {
+		ok: false,
+		diagnostics: Object.freeze([issue("invalid-snapshot", "Snapshot root must be an object", [])])
+	};
+	const diagnostics = [];
+	const snapshot = validateCompleteSnapshot(value, diagnostics);
+	if (diagnostics.length > 0 || snapshot === void 0) return {
+		ok: false,
+		diagnostics: Object.freeze(diagnostics)
+	};
+	return {
+		ok: true,
+		value: deepFreeze(snapshot)
+	};
+}
+/** Validate a complete snapshot and throw one structured error on failure. */
+function assertCompleteSchemaSnapshot(input) {
+	const result = decodeCompleteSchemaSnapshot(input);
+	if (!result.ok) throw new CompleteSnapshotValidationError(result.diagnostics);
+	return result.value;
+}
+/** Return a fixed-order, deeply immutable complete snapshot. */
+function canonicalizeCompleteSchemaSnapshot(input) {
+	return assertCompleteSchemaSnapshot(input);
+}
+/** Encode a complete snapshot with deterministic property and array order. */
+function encodeCompleteSchemaSnapshot(snapshot) {
+	const canonical = assertCompleteSchemaSnapshot(snapshot);
+	return canonicalJson(canonical);
+}
+/** Compute the deterministic content digest for a complete Snapshot v2. */
+function completeSchemaSnapshotDigest(snapshot) {
+	const source = encodeCompleteSchemaSnapshot(snapshot);
+	let hash = 14695981039346656037n;
+	const prime = 1099511628211n;
+	const mask = 18446744073709551615n;
+	for (let index = 0; index < source.length; index += 1) {
+		const codePoint = source.codePointAt(index) ?? 0;
+		if (codePoint > 65535) index += 1;
+		for (const byte of new TextEncoder().encode(String.fromCodePoint(codePoint))) {
+			hash ^= BigInt(byte);
+			hash = hash * prime & mask;
+		}
+	}
+	return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
+}
+/** Numbered aliases for tooling that keeps v1 and v2 side by side. */
+const decodeSchemaSnapshotV2 = decodeCompleteSchemaSnapshot;
+const assertSchemaSnapshotV2 = assertCompleteSchemaSnapshot;
+const encodeSchemaSnapshotV2 = encodeCompleteSchemaSnapshot;
+const canonicalizeSchemaSnapshotV2 = canonicalizeCompleteSchemaSnapshot;
+const schemaSnapshotV2Digest = completeSchemaSnapshotDigest;
+const decodeCompleteSnapshot = decodeCompleteSchemaSnapshot;
+const assertCompleteSnapshot = assertCompleteSchemaSnapshot;
+const encodeCompleteSnapshot = encodeCompleteSchemaSnapshot;
+const digestCompleteSchemaSnapshot = completeSchemaSnapshotDigest;
+function validateCompleteSnapshot(value, diagnostics) {
+	requireKeys(value, [
+		"format",
+		"version",
+		"dialect",
+		"namingPolicy",
+		"namespace",
+		"capabilities",
+		"tables",
+		"views",
+		"sequences",
+		"enums",
+		"domains",
+		"collations",
+		"triggers",
+		"routines",
+		"partitions",
+		"policies",
+		"extensions",
+		"deferredObjects",
+		"opaqueObjects",
+		"comments",
+		"ownership"
+	], [], diagnostics);
+	if (value.format !== "qubu-schema") diagnostics.push(issue("invalid-snapshot", `Snapshot format must be "${completeSchemaSnapshotFormat}"`, ["format"]));
+	if (value.version !== 2) diagnostics.push(issue(typeof value.version === "number" && value.version > 2 ? "future-version" : "invalid-snapshot", `Unsupported complete schema snapshot version: ${String(value.version)}`, ["version"]));
+	const dialect = validateDialect(value.dialect, ["dialect"], diagnostics);
+	const namingPolicy = validateNamingPolicy(value.namingPolicy, ["namingPolicy"], diagnostics);
+	const namespace = validateNamespace(value.namespace, ["namespace"], diagnostics, dialect?.name);
+	const capabilities = validateCapabilities(value.capabilities, ["capabilities"], diagnostics);
+	const tables = validateObjects(value.tables, ["tables"], diagnostics, validateTable);
+	const views = validateObjects(value.views, ["views"], diagnostics, validateView);
+	const sequences = validateObjects(value.sequences, ["sequences"], diagnostics, validateSequence);
+	const enums = validateObjects(value.enums, ["enums"], diagnostics, validateEnum);
+	const domains = validateObjects(value.domains, ["domains"], diagnostics, validateDomain);
+	const collations = validateObjects(value.collations, ["collations"], diagnostics, validateCollation);
+	const triggers = validateObjects(value.triggers, ["triggers"], diagnostics, validateTrigger);
+	const routines = validateObjects(value.routines, ["routines"], diagnostics, validateRoutine);
+	const partitions = validateObjects(value.partitions, ["partitions"], diagnostics, validatePartition);
+	const policies = validateObjects(value.policies, ["policies"], diagnostics, validatePolicy);
+	const extensions = validateObjects(value.extensions, ["extensions"], diagnostics, validateExtensionObject);
+	const deferredObjects = validateObjects(value.deferredObjects, ["deferredObjects"], diagnostics, validateDeferredObject);
+	const opaqueObjects = validateObjects(value.opaqueObjects, ["opaqueObjects"], diagnostics, validateOpaqueObject);
+	const comments = validateObjects(value.comments, ["comments"], diagnostics, validateComment);
+	const ownership = validateObjects(value.ownership, ["ownership"], diagnostics, validateOwnership);
+	if (dialect === void 0 || namingPolicy === void 0 || namespace === void 0 || capabilities === void 0 || tables === void 0 || views === void 0 || sequences === void 0 || enums === void 0 || domains === void 0 || collations === void 0 || triggers === void 0 || routines === void 0 || partitions === void 0 || policies === void 0 || extensions === void 0 || deferredObjects === void 0 || opaqueObjects === void 0 || comments === void 0 || ownership === void 0) return void 0;
+	const snapshot = {
+		format: completeSchemaSnapshotFormat,
+		version: 2,
+		dialect,
+		namingPolicy,
+		namespace,
+		capabilities,
+		tables,
+		views,
+		sequences,
+		enums,
+		domains,
+		collations,
+		triggers,
+		routines,
+		partitions,
+		policies,
+		extensions,
+		deferredObjects,
+		opaqueObjects,
+		comments,
+		ownership
+	};
+	validateCompleteDialectMetadata(snapshot, diagnostics);
+	validateCompleteCrossReferences(snapshot, diagnostics);
+	return diagnostics.length === 0 ? snapshot : void 0;
+}
+function validateDialect(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Dialect must be an object", path));
+		return;
+	}
+	requireKeys(value, ["name", "version"], path, diagnostics);
+	const name = stringValue(value.name, [...path, "name"], diagnostics, true);
+	const version = integerValue(value.version, [...path, "version"], diagnostics);
+	if (version !== void 0 && version < 1) diagnostics.push(issue("invalid-snapshot", "Dialect version must be positive", [...path, "version"]));
+	if (version !== void 0 && version > 1) diagnostics.push(issue("future-version", `Unsupported dialect version: ${version}`, [...path, "version"]));
+	if (name === void 0 || version === void 0) return void 0;
+	return {
+		name,
+		version
+	};
+}
+function validateNamingPolicy(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Naming policy must be an object", path));
+		return;
+	}
+	requireKeys(value, ["name", "version"], path, diagnostics);
+	const name = stringValue(value.name, [...path, "name"], diagnostics, true);
+	const version = integerValue(value.version, [...path, "version"], diagnostics);
+	if (version !== 1) diagnostics.push(issue(typeof value.version === "number" && value.version > 1 ? "future-version" : "invalid-snapshot", `Unsupported naming-policy version: ${String(value.version)}`, [...path, "version"]));
+	return name === void 0 || version === void 0 ? void 0 : {
+		name,
+		version
+	};
+}
+function validateNamespace(value, path, diagnostics, dialect) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Snapshot namespace must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"kind",
+		"name",
+		"provenance",
+		"physicalReference",
+		"dialect"
+	], path, diagnostics, [
+		"provenance",
+		"physicalReference",
+		"dialect"
+	]);
+	const kind = value.kind;
+	if (kind !== "postgres-schema" && kind !== "sqlite-database" && kind !== "mysql-database") diagnostics.push(issue("invalid-snapshot", "Snapshot namespace kind is invalid", [...path, "kind"]));
+	const name = stringValue(value.name, [...path, "name"], diagnostics, true);
+	const metadata = validateObjectMetadata(value, path, dialect, diagnostics);
+	return name === void 0 || typeof kind !== "string" ? void 0 : {
+		kind,
+		name,
+		...metadata
+	};
+}
+function validateCapabilities(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Snapshot capabilities must be an object", path));
+		return;
+	}
+	const required = [
+		"generatedColumns",
+		"identityMetadata",
+		"checkConstraints",
+		"checkConstraintEnforcement",
+		"expressionDecompilation",
+		"indexExpressions",
+		"indexPredicates",
+		"indexIncludedColumns",
+		"namespaces",
+		"visibility"
+	];
+	requireKeys(value, required, path, diagnostics);
+	const result = {};
+	for (const key of Object.keys(value).sort()) {
+		const child = value[key];
+		if (typeof child !== "boolean" && typeof child !== "string") diagnostics.push(issue("invalid-value", "Capability values must be boolean or string", [...path, key]));
+		else result[key] = child;
+	}
+	const enforcement = value.checkConstraintEnforcement;
+	if (enforcement !== "enforced" && enforcement !== "metadata-only" && enforcement !== "unknown") diagnostics.push(issue("invalid-snapshot", "Check-constraint enforcement is invalid", [...path, "checkConstraintEnforcement"]));
+	const visibility = value.visibility;
+	if (visibility !== "complete" && visibility !== "limited" && visibility !== "unknown") diagnostics.push(issue("invalid-snapshot", "Capability visibility is invalid", [...path, "visibility"]));
+	for (const key of required) if (typeof value[key] !== "boolean" && key !== "checkConstraintEnforcement" && key !== "visibility") diagnostics.push(issue("invalid-snapshot", "Capability must be boolean", [...path, key]));
+	if (diagnostics.some((diagnostic) => diagnostic.path.length === path.length + 1 && diagnostic.path.slice(0, path.length).every((part, i) => part === path[i]))) return void 0;
+	return result;
+}
+function validateObjects(value, path, diagnostics, validate) {
+	if (!Array.isArray(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Value must be an array", path));
+		return;
+	}
+	validateSortedIds(value, path, diagnostics);
+	const result = [];
+	for (const [index, item] of value.entries()) {
+		const valid = validate(item, [...path, index], diagnostics);
+		if (valid !== void 0) result.push(valid);
+	}
+	return result;
+}
+function validateObjectMetadata(value, path, dialect, diagnostics, allowed = []) {
+	const provenance = value.provenance === void 0 ? void 0 : validateProvenance(value.provenance, [...path, "provenance"], dialect, diagnostics);
+	const extension = value.dialect === void 0 ? void 0 : validateExtension(value.dialect, [...path, "dialect"], dialect, diagnostics);
+	const physicalReference = value.physicalReference === void 0 ? void 0 : validatePhysicalReference(value.physicalReference, [...path, "physicalReference"], diagnostics);
+	return {
+		...provenance === void 0 ? {} : { provenance },
+		...physicalReference === void 0 ? {} : { physicalReference },
+		...extension === void 0 ? {} : { dialect: extension }
+	};
+}
+function validateBase(value, path, kind, dialect, diagnostics, allowed = []) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", `${kind} must be an object`, path));
+		return;
+	}
+	requireKeys(value, [
+		"kind",
+		"id",
+		"physicalName",
+		"provenance",
+		"physicalReference",
+		"dialect",
+		...allowed
+	], path, diagnostics, [
+		"provenance",
+		"physicalReference",
+		"dialect",
+		...allowed
+	]);
+	if (value.kind !== kind && !(kind === "view" && value.kind === "materialized-view")) diagnostics.push(issue("invalid-snapshot", `${kind} kind is invalid`, [...path, "kind"]));
+	const id = stringValue(value.id, [...path, "id"], diagnostics, true);
+	const physicalName = stringValue(value.physicalName, [...path, "physicalName"], diagnostics, true);
+	const metadata = validateObjectMetadata(value, path, dialect, diagnostics, allowed);
+	return id === void 0 || physicalName === void 0 ? void 0 : {
+		id,
+		physicalName,
+		metadata
+	};
+}
+function validateTable(value, path, diagnostics) {
+	const base = validateBase(value, path, "table", void 0, diagnostics, [
+		"columns",
+		"constraints",
+		"indexes"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const columns = validateObjects(value.columns, [...path, "columns"], diagnostics, validateColumn);
+	const constraints = validateObjects(value.constraints, [...path, "constraints"], diagnostics, validateConstraint);
+	const indexes = validateObjects(value.indexes, [...path, "indexes"], diagnostics, validateIndex);
+	if (columns === void 0 || constraints === void 0 || indexes === void 0) return void 0;
+	return {
+		kind: "table",
+		id: base.id,
+		physicalName: base.physicalName,
+		columns,
+		constraints,
+		indexes,
+		...base.metadata
+	};
+}
+function validateColumn(value, path, diagnostics) {
+	const base = validateBase(value, path, "column", void 0, diagnostics, [
+		"ordinalPosition",
+		"nullable",
+		"hasDefault",
+		"generated",
+		"storage",
+		"default",
+		"generatedColumn",
+		"identity",
+		"onUpdate"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const ordinalPosition = integerValue(value.ordinalPosition, [...path, "ordinalPosition"], diagnostics);
+	const nullable = booleanValue(value.nullable, [...path, "nullable"], diagnostics);
+	const hasDefault = booleanValue(value.hasDefault, [...path, "hasDefault"], diagnostics);
+	const generated = booleanValue(value.generated, [...path, "generated"], diagnostics);
+	const storage = value.storage === void 0 ? void 0 : validateStorage(value.storage, [...path, "storage"], diagnostics);
+	const defaultValue = value.default === void 0 ? void 0 : validateDefault(value.default, [...path, "default"], diagnostics);
+	const generatedColumn = value.generatedColumn === void 0 ? void 0 : validateGenerated(value.generatedColumn, [...path, "generatedColumn"], diagnostics);
+	const identity = value.identity === void 0 ? void 0 : validateIdentity(value.identity, [...path, "identity"], diagnostics);
+	const onUpdate = value.onUpdate === void 0 ? void 0 : validateExpression(value.onUpdate, [...path, "onUpdate"], diagnostics);
+	if (ordinalPosition === void 0 || nullable === void 0 || hasDefault === void 0 || generated === void 0) return void 0;
+	return {
+		kind: "column",
+		id: base.id,
+		physicalName: base.physicalName,
+		ordinalPosition,
+		nullable,
+		hasDefault,
+		generated,
+		...storage === void 0 ? {} : { storage },
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		...generatedColumn === void 0 ? {} : { generatedColumn },
+		...identity === void 0 ? {} : { identity },
+		...onUpdate === void 0 ? {} : { onUpdate },
+		...base.metadata
+	};
+}
+function validateConstraint(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Constraint must be an object", path));
+		return;
+	}
+	const kind = value.kind;
+	const base = validateBase(value, path, String(kind), void 0, diagnostics, kind === "foreign-key" ? [
+		"columns",
+		"target",
+		"onUpdate",
+		"onDelete",
+		"match",
+		"deferrable",
+		"initially",
+		"validated"
+	] : kind === "check" ? [
+		"expression",
+		"deferrable",
+		"initially",
+		"validated"
+	] : [
+		"columns",
+		"nulls",
+		"backingIndex",
+		"deferrable",
+		"initially",
+		"validated"
+	]);
+	if (base === void 0) return void 0;
+	if (kind === "check") {
+		const expression = validateExpression(value.expression, [...path, "expression"], diagnostics);
+		const timing = validateTiming(value, path, diagnostics);
+		const validated = optionalBoolean(value.validated, [...path, "validated"], diagnostics);
+		if (expression === void 0) return void 0;
+		return {
+			kind: "check",
+			id: base.id,
+			physicalName: base.physicalName,
+			expression,
+			...timing,
+			...validated === void 0 ? {} : { validated },
+			...base.metadata
+		};
+	}
+	if (kind === "foreign-key") {
+		const columns = validateIds(value.columns, [...path, "columns"], diagnostics);
+		const target = validateForeignKeyTarget(value.target, [...path, "target"], diagnostics);
+		const onUpdate = validateAction(value.onUpdate, [...path, "onUpdate"], diagnostics);
+		const onDelete = validateAction(value.onDelete, [...path, "onDelete"], diagnostics);
+		const match = validateMatch(value.match, [...path, "match"], diagnostics);
+		const timing = validateTiming(value, path, diagnostics);
+		const validated = optionalBoolean(value.validated, [...path, "validated"], diagnostics);
+		if (columns === void 0 || target === void 0) return void 0;
+		return {
+			kind: "foreign-key",
+			id: base.id,
+			physicalName: base.physicalName,
+			columns,
+			target,
+			...onUpdate === void 0 ? {} : { onUpdate },
+			...onDelete === void 0 ? {} : { onDelete },
+			...match === void 0 ? {} : { match },
+			...timing,
+			...validated === void 0 ? {} : { validated },
+			...base.metadata
+		};
+	}
+	if (kind !== "primary-key" && kind !== "unique" && kind !== "unique-constraint") {
+		diagnostics.push(issue("invalid-snapshot", "Constraint kind is invalid", [...path, "kind"]));
+		return;
+	}
+	const columns = validateIds(value.columns, [...path, "columns"], diagnostics);
+	const nulls = value.nulls === void 0 ? void 0 : validateNulls(value.nulls, [...path, "nulls"], diagnostics);
+	const backingIndex = value.backingIndex === void 0 ? void 0 : validateObjectReference(value.backingIndex, [...path, "backingIndex"], diagnostics);
+	const timing = validateTiming(value, path, diagnostics);
+	const validated = optionalBoolean(value.validated, [...path, "validated"], diagnostics);
+	if (columns === void 0) return void 0;
+	if (kind === "unique-constraint" && nulls === void 0) {
+		diagnostics.push(issue("invalid-snapshot", "Unique constraints require nulls semantics", [...path, "nulls"]));
+		return;
+	}
+	return {
+		kind,
+		id: base.id,
+		physicalName: base.physicalName,
+		columns,
+		...nulls === void 0 ? {} : { nulls },
+		...backingIndex === void 0 ? {} : { backingIndex },
+		...timing,
+		...validated === void 0 ? {} : { validated },
+		...base.metadata
+	};
+}
+function validateIndex(value, path, diagnostics) {
+	const base = validateBase(value, path, "index", void 0, diagnostics, [
+		"terms",
+		"unique",
+		"candidateKey",
+		"predicate",
+		"includedColumns",
+		"backingConstraint",
+		"method"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const terms = validateArray(value.terms, [...path, "terms"], diagnostics, validateIndexTerm);
+	if (terms !== void 0) validateSortedPositions(terms, [...path, "terms"], diagnostics);
+	const unique = booleanValue(value.unique, [...path, "unique"], diagnostics);
+	const candidateKey = booleanValue(value.candidateKey, [...path, "candidateKey"], diagnostics);
+	const predicate = value.predicate === void 0 ? void 0 : validateExpression(value.predicate, [...path, "predicate"], diagnostics);
+	const includedColumns = value.includedColumns === void 0 ? void 0 : validateIds(value.includedColumns, [...path, "includedColumns"], diagnostics, false);
+	const backingConstraint = value.backingConstraint === void 0 ? void 0 : validateObjectReference(value.backingConstraint, [...path, "backingConstraint"], diagnostics);
+	const method = value.method === void 0 ? void 0 : stringValue(value.method, [...path, "method"], diagnostics, true);
+	if (terms === void 0 || unique === void 0 || candidateKey === void 0) return void 0;
+	return {
+		kind: "index",
+		id: base.id,
+		physicalName: base.physicalName,
+		terms,
+		unique,
+		candidateKey,
+		...predicate === void 0 ? {} : { predicate },
+		...includedColumns === void 0 ? {} : { includedColumns },
+		...backingConstraint === void 0 ? {} : { backingConstraint },
+		...method === void 0 ? {} : { method },
+		...base.metadata
+	};
+}
+function validateIndexTerm(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Index term must be an object", path));
+		return;
+	}
+	const kind = value.kind;
+	requireKeys(value, [
+		"kind",
+		"position",
+		"direction",
+		"nulls",
+		"operatorClass",
+		...kind === "column" ? ["column", "prefixLength"] : ["expression"]
+	], path, diagnostics, [
+		"direction",
+		"nulls",
+		"operatorClass",
+		"prefixLength"
+	]);
+	const position = integerValue(value.position, [...path, "position"], diagnostics);
+	const direction = validateDirection(value.direction, [...path, "direction"], diagnostics);
+	const nulls = validateIndexNulls(value.nulls, [...path, "nulls"], diagnostics);
+	const operatorClass = value.operatorClass === void 0 ? void 0 : stringValue(value.operatorClass, [...path, "operatorClass"], diagnostics, true);
+	if (kind === "column") {
+		const column = stringValue(value.column, [...path, "column"], diagnostics, true);
+		const prefixLength = value.prefixLength === void 0 ? void 0 : validateValueFact(value.prefixLength, [...path, "prefixLength"], diagnostics);
+		if (column === void 0 || position === void 0) return void 0;
+		return {
+			kind: "column",
+			column,
+			position,
+			...direction === void 0 ? {} : { direction },
+			...nulls === void 0 ? {} : { nulls },
+			...prefixLength === void 0 ? {} : { prefixLength },
+			...operatorClass === void 0 ? {} : { operatorClass }
+		};
+	}
+	if (kind === "expression") {
+		const expression = validateExpression(value.expression, [...path, "expression"], diagnostics);
+		if (expression === void 0 || position === void 0) return void 0;
+		return {
+			kind: "expression",
+			expression,
+			position,
+			...direction === void 0 ? {} : { direction },
+			...nulls === void 0 ? {} : { nulls },
+			...operatorClass === void 0 ? {} : { operatorClass }
+		};
+	}
+	diagnostics.push(issue("invalid-snapshot", "Index term kind is invalid", [...path, "kind"]));
+}
+function validateView(value, path, diagnostics) {
+	const base = validateBase(value, path, "view", void 0, diagnostics, [
+		"columns",
+		"definition",
+		"dependencies",
+		"checkOption",
+		"securityBarrier",
+		"securityInvoker"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const columns = validateObjects(value.columns, [...path, "columns"], diagnostics, validateColumn);
+	const definition = validateExpression(value.definition, [...path, "definition"], diagnostics);
+	const dependencies = value.dependencies === void 0 ? void 0 : validateReferences(value.dependencies, [...path, "dependencies"], diagnostics);
+	const checkOption = validateCheckOption(value.checkOption, [...path, "checkOption"], diagnostics);
+	const securityBarrier = optionalBoolean(value.securityBarrier, [...path, "securityBarrier"], diagnostics);
+	const securityInvoker = optionalBoolean(value.securityInvoker, [...path, "securityInvoker"], diagnostics);
+	if (columns === void 0 || definition === void 0) return void 0;
+	return {
+		kind: value.kind,
+		id: base.id,
+		physicalName: base.physicalName,
+		columns,
+		definition,
+		...dependencies === void 0 ? {} : { dependencies },
+		...checkOption === void 0 ? {} : { checkOption },
+		...securityBarrier === void 0 ? {} : { securityBarrier },
+		...securityInvoker === void 0 ? {} : { securityInvoker },
+		...base.metadata
+	};
+}
+function validateSequence(value, path, diagnostics) {
+	const base = validateBase(value, path, "sequence", void 0, diagnostics, [
+		"storage",
+		"start",
+		"increment",
+		"minimum",
+		"maximum",
+		"cache",
+		"cycle",
+		"ownedBy",
+		"identity"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const storage = value.storage === void 0 ? void 0 : validateStorage(value.storage, [...path, "storage"], diagnostics);
+	const start = value.start === void 0 ? void 0 : validateValueFact(value.start, [...path, "start"], diagnostics);
+	const increment = value.increment === void 0 ? void 0 : validateValueFact(value.increment, [...path, "increment"], diagnostics);
+	const minimum = value.minimum === void 0 ? void 0 : validateValueFact(value.minimum, [...path, "minimum"], diagnostics);
+	const maximum = value.maximum === void 0 ? void 0 : validateValueFact(value.maximum, [...path, "maximum"], diagnostics);
+	const cache = value.cache === void 0 ? void 0 : validateValueFact(value.cache, [...path, "cache"], diagnostics);
+	const cycle = optionalBoolean(value.cycle, [...path, "cycle"], diagnostics);
+	const ownedBy = value.ownedBy === void 0 ? void 0 : validateObjectReference(value.ownedBy, [...path, "ownedBy"], diagnostics);
+	const identity = value.identity === void 0 ? void 0 : validateIdentity(value.identity, [...path, "identity"], diagnostics);
+	return {
+		kind: "sequence",
+		id: base.id,
+		physicalName: base.physicalName,
+		...storage === void 0 ? {} : { storage },
+		...start === void 0 ? {} : { start },
+		...increment === void 0 ? {} : { increment },
+		...minimum === void 0 ? {} : { minimum },
+		...maximum === void 0 ? {} : { maximum },
+		...cache === void 0 ? {} : { cache },
+		...cycle === void 0 ? {} : { cycle },
+		...ownedBy === void 0 ? {} : { ownedBy },
+		...identity === void 0 ? {} : { identity },
+		...base.metadata
+	};
+}
+function validateEnum(value, path, diagnostics) {
+	const base = validateBase(value, path, "enum", void 0, diagnostics, ["values"]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const values = validateArray(value.values, [...path, "values"], diagnostics, validateEnumValue);
+	if (values === void 0) return void 0;
+	let previous = -1;
+	for (const [index, item] of values.entries()) {
+		if (item.ordinalPosition <= previous) diagnostics.push(issue("non-canonical", "Enum labels must be sorted by ordinal position", [
+			...path,
+			"values",
+			index,
+			"ordinalPosition"
+		]));
+		previous = item.ordinalPosition;
+	}
+	return {
+		kind: "enum",
+		id: base.id,
+		physicalName: base.physicalName,
+		values,
+		...base.metadata
+	};
+}
+function validateEnumValue(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Enum value must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"value",
+		"ordinalPosition",
+		"provenance"
+	], path, diagnostics, ["provenance"]);
+	const label = stringValue(value.value, [...path, "value"], diagnostics);
+	const ordinalPosition = integerValue(value.ordinalPosition, [...path, "ordinalPosition"], diagnostics);
+	const provenance = value.provenance === void 0 ? void 0 : validateProvenance(value.provenance, [...path, "provenance"], void 0, diagnostics);
+	return label === void 0 || ordinalPosition === void 0 ? void 0 : {
+		value: label,
+		ordinalPosition,
+		...provenance === void 0 ? {} : { provenance }
+	};
+}
+function validateDomain(value, path, diagnostics) {
+	const base = validateBase(value, path, "domain", void 0, diagnostics, [
+		"storage",
+		"nullable",
+		"default",
+		"constraints"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const storage = validateStorage(value.storage, [...path, "storage"], diagnostics);
+	const nullable = optionalBoolean(value.nullable, [...path, "nullable"], diagnostics);
+	const defaultValue = value.default === void 0 ? void 0 : validateValueFact(value.default, [...path, "default"], diagnostics);
+	const constraints = value.constraints === void 0 ? void 0 : validateArray(value.constraints, [...path, "constraints"], diagnostics, validateCheckConstraint);
+	if (storage === void 0) return void 0;
+	return {
+		kind: "domain",
+		id: base.id,
+		physicalName: base.physicalName,
+		storage,
+		...nullable === void 0 ? {} : { nullable },
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		...constraints === void 0 ? {} : { constraints },
+		...base.metadata
+	};
+}
+function validateCheckConstraint(value, path, diagnostics) {
+	const constraint = validateConstraint(value, path, diagnostics);
+	if (constraint?.kind !== "check") {
+		diagnostics.push(issue("invalid-snapshot", "Domain constraints must be check constraints", path));
+		return;
+	}
+	return constraint;
+}
+function validateCollation(value, path, diagnostics) {
+	const base = validateBase(value, path, "collation", void 0, diagnostics, [
+		"provider",
+		"locale",
+		"deterministic",
+		"version"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const provider = value.provider === void 0 ? void 0 : stringValue(value.provider, [...path, "provider"], diagnostics, true);
+	const locale = value.locale === void 0 ? void 0 : stringValue(value.locale, [...path, "locale"], diagnostics);
+	const deterministic = optionalBoolean(value.deterministic, [...path, "deterministic"], diagnostics);
+	const version = value.version === void 0 ? void 0 : stringValue(value.version, [...path, "version"], diagnostics);
+	return {
+		kind: "collation",
+		id: base.id,
+		physicalName: base.physicalName,
+		...provider === void 0 ? {} : { provider },
+		...locale === void 0 ? {} : { locale },
+		...deterministic === void 0 ? {} : { deterministic },
+		...version === void 0 ? {} : { version },
+		...base.metadata
+	};
+}
+function validateTrigger(value, path, diagnostics) {
+	const base = validateBase(value, path, "trigger", void 0, diagnostics, [
+		"table",
+		"timing",
+		"events",
+		"orientation",
+		"condition",
+		"body",
+		"enabled"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const table = validateObjectReference(value.table, [...path, "table"], diagnostics);
+	const timing = validateTimingKind(value.timing, [...path, "timing"], diagnostics);
+	const events = validateEvents(value.events, [...path, "events"], diagnostics);
+	const orientation = validateOrientation(value.orientation, [...path, "orientation"], diagnostics);
+	const condition = value.condition === void 0 ? void 0 : validateExpression(value.condition, [...path, "condition"], diagnostics);
+	const body = validateExpression(value.body, [...path, "body"], diagnostics);
+	const enabled = optionalBoolean(value.enabled, [...path, "enabled"], diagnostics);
+	if (table === void 0 || timing === void 0 || events === void 0 || body === void 0) return void 0;
+	return {
+		kind: "trigger",
+		id: base.id,
+		physicalName: base.physicalName,
+		table,
+		timing,
+		events,
+		...orientation === void 0 ? {} : { orientation },
+		...condition === void 0 ? {} : { condition },
+		body,
+		...enabled === void 0 ? {} : { enabled },
+		...base.metadata
+	};
+}
+function validateRoutine(value, path, diagnostics) {
+	const base = validateBase(value, path, "routine", void 0, diagnostics, [
+		"routineKind",
+		"parameters",
+		"returnType",
+		"language",
+		"body",
+		"volatility",
+		"parallel",
+		"security",
+		"dependencies"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const routineKind = validateRoutineKind(value.routineKind, [...path, "routineKind"], diagnostics);
+	const parameters = validateArray(value.parameters, [...path, "parameters"], diagnostics, validateRoutineParameter);
+	if (parameters !== void 0) validateSortedPositions(parameters, [...path, "parameters"], diagnostics);
+	const returnType = value.returnType === void 0 ? void 0 : validateStorage(value.returnType, [...path, "returnType"], diagnostics);
+	const language = value.language === void 0 ? void 0 : stringValue(value.language, [...path, "language"], diagnostics, true);
+	const body = value.body === void 0 ? void 0 : validateExpression(value.body, [...path, "body"], diagnostics);
+	const volatility = validateChoice(value.volatility, [
+		"immutable",
+		"stable",
+		"volatile",
+		"unknown"
+	], [...path, "volatility"], diagnostics);
+	const parallel = validateChoice(value.parallel, [
+		"safe",
+		"restricted",
+		"unsafe",
+		"unknown"
+	], [...path, "parallel"], diagnostics);
+	const security = validateChoice(value.security, [
+		"invoker",
+		"definer",
+		"unknown"
+	], [...path, "security"], diagnostics);
+	const dependencies = value.dependencies === void 0 ? void 0 : validateReferences(value.dependencies, [...path, "dependencies"], diagnostics);
+	if (routineKind === void 0 || parameters === void 0) return void 0;
+	return {
+		kind: "routine",
+		id: base.id,
+		physicalName: base.physicalName,
+		routineKind,
+		parameters,
+		...returnType === void 0 ? {} : { returnType },
+		...language === void 0 ? {} : { language },
+		...body === void 0 ? {} : { body },
+		...volatility === void 0 ? {} : { volatility },
+		...parallel === void 0 ? {} : { parallel },
+		...security === void 0 ? {} : { security },
+		...dependencies === void 0 ? {} : { dependencies },
+		...base.metadata
+	};
+}
+function validateRoutineParameter(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Routine parameter must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"name",
+		"mode",
+		"storage",
+		"default",
+		"ordinalPosition"
+	], path, diagnostics, [
+		"name",
+		"mode",
+		"default"
+	]);
+	const name = value.name === void 0 ? void 0 : stringValue(value.name, [...path, "name"], diagnostics);
+	const mode = validateChoice(value.mode, [
+		"in",
+		"out",
+		"inout",
+		"variadic",
+		"table"
+	], [...path, "mode"], diagnostics);
+	const storage = validateStorage(value.storage, [...path, "storage"], diagnostics);
+	const defaultValue = value.default === void 0 ? void 0 : validateValueFact(value.default, [...path, "default"], diagnostics);
+	const ordinalPosition = integerValue(value.ordinalPosition, [...path, "ordinalPosition"], diagnostics);
+	return storage === void 0 || ordinalPosition === void 0 ? void 0 : {
+		...name === void 0 ? {} : { name },
+		...mode === void 0 ? {} : { mode },
+		storage,
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		ordinalPosition
+	};
+}
+function validatePartition(value, path, diagnostics) {
+	const base = validateBase(value, path, "partition", void 0, diagnostics, [
+		"parent",
+		"strategy",
+		"keyColumns",
+		"bound",
+		"default"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const parent = validateObjectReference(value.parent, [...path, "parent"], diagnostics);
+	const strategy = validateChoice(value.strategy, [
+		"range",
+		"list",
+		"hash",
+		"reference",
+		"unknown"
+	], [...path, "strategy"], diagnostics);
+	const keyColumns = value.keyColumns === void 0 ? void 0 : validateIds(value.keyColumns, [...path, "keyColumns"], diagnostics, false);
+	const bound = value.bound === void 0 ? void 0 : validateExpression(value.bound, [...path, "bound"], diagnostics);
+	const defaultValue = optionalBoolean(value.default, [...path, "default"], diagnostics);
+	if (parent === void 0 || strategy === void 0) return void 0;
+	return {
+		kind: "partition",
+		id: base.id,
+		physicalName: base.physicalName,
+		parent,
+		strategy,
+		...keyColumns === void 0 ? {} : { keyColumns },
+		...bound === void 0 ? {} : { bound },
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		...base.metadata
+	};
+}
+function validatePolicy(value, path, diagnostics) {
+	const base = validateBase(value, path, "policy", void 0, diagnostics, [
+		"table",
+		"command",
+		"roles",
+		"permissive",
+		"using",
+		"check"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const table = validateObjectReference(value.table, [...path, "table"], diagnostics);
+	const command = validateChoice(value.command, [
+		"all",
+		"select",
+		"insert",
+		"update",
+		"delete",
+		"unknown"
+	], [...path, "command"], diagnostics);
+	const roles = value.roles === void 0 ? void 0 : validateStrings(value.roles, [...path, "roles"], diagnostics, false);
+	const permissive = optionalBoolean(value.permissive, [...path, "permissive"], diagnostics);
+	const using = value.using === void 0 ? void 0 : validateExpression(value.using, [...path, "using"], diagnostics);
+	const check = value.check === void 0 ? void 0 : validateExpression(value.check, [...path, "check"], diagnostics);
+	if (table === void 0 || command === void 0) return void 0;
+	return {
+		kind: "policy",
+		id: base.id,
+		physicalName: base.physicalName,
+		table,
+		command,
+		...roles === void 0 ? {} : { roles },
+		...permissive === void 0 ? {} : { permissive },
+		...using === void 0 ? {} : { using },
+		...check === void 0 ? {} : { check },
+		...base.metadata
+	};
+}
+function validateExtensionObject(value, path, diagnostics) {
+	const base = validateBase(value, path, "extension", void 0, diagnostics, [
+		"extensionName",
+		"extensionVersion",
+		"schema",
+		"data",
+		"configuration"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const extensionName = stringValue(value.extensionName, [...path, "extensionName"], diagnostics, true);
+	const extensionVersion = value.extensionVersion === void 0 ? void 0 : stringValue(value.extensionVersion, [...path, "extensionVersion"], diagnostics);
+	const schema = value.schema === void 0 ? void 0 : stringValue(value.schema, [...path, "schema"], diagnostics, true);
+	const data = validateJsonValue(value.data, [...path, "data"], diagnostics);
+	const configuration = value.configuration === void 0 ? void 0 : validateJsonValue(value.configuration, [...path, "configuration"], diagnostics);
+	if (extensionName === void 0 || data === void 0) return void 0;
+	return {
+		kind: "extension",
+		id: base.id,
+		physicalName: base.physicalName,
+		extensionName,
+		...extensionVersion === void 0 ? {} : { extensionVersion },
+		...schema === void 0 ? {} : { schema },
+		data,
+		...configuration === void 0 ? {} : { configuration },
+		...base.metadata
+	};
+}
+function validateDeferredObject(value, path, diagnostics) {
+	const base = validateBase(value, path, "deferred-object", void 0, diagnostics, [
+		"objectKind",
+		"reason",
+		"data"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const objectKind = stringValue(value.objectKind, [...path, "objectKind"], diagnostics, true);
+	const reason = value.reason === void 0 ? void 0 : stringValue(value.reason, [...path, "reason"], diagnostics);
+	const data = value.data === void 0 ? void 0 : validateJsonValue(value.data, [...path, "data"], diagnostics);
+	if (objectKind === void 0) return void 0;
+	return {
+		kind: "deferred-object",
+		id: base.id,
+		objectKind,
+		physicalName: base.physicalName,
+		...reason === void 0 ? {} : { reason },
+		...data === void 0 ? {} : { data },
+		...base.metadata
+	};
+}
+function validateOpaqueObject(value, path, diagnostics) {
+	const base = validateBase(value, path, "opaque-object", void 0, diagnostics, [
+		"objectKind",
+		"data",
+		"sql"
+	]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const objectKind = stringValue(value.objectKind, [...path, "objectKind"], diagnostics, true);
+	const data = validateJsonValue(value.data, [...path, "data"], diagnostics);
+	const sql = value.sql === void 0 ? void 0 : validateExpression(value.sql, [...path, "sql"], diagnostics);
+	if (objectKind === void 0 || data === void 0) return void 0;
+	return {
+		kind: "opaque-object",
+		id: base.id,
+		objectKind,
+		physicalName: base.physicalName,
+		data,
+		...sql === void 0 ? {} : { sql },
+		...base.metadata
+	};
+}
+function validateComment(value, path, diagnostics) {
+	const base = validateBase(value, path, "comment", void 0, diagnostics, ["object", "text"]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const object = validateObjectReference(value.object, [...path, "object"], diagnostics);
+	const text = stringValue(value.text, [...path, "text"], diagnostics);
+	if (object === void 0 || text === void 0) return void 0;
+	return {
+		kind: "comment",
+		id: base.id,
+		physicalName: base.physicalName,
+		object,
+		text,
+		...base.metadata
+	};
+}
+function validateOwnership(value, path, diagnostics) {
+	const base = validateBase(value, path, "ownership", void 0, diagnostics, ["object", "owner"]);
+	if (!isRecord(value) || base === void 0) return void 0;
+	const object = validateObjectReference(value.object, [...path, "object"], diagnostics);
+	const owner = stringValue(value.owner, [...path, "owner"], diagnostics, true);
+	if (object === void 0 || owner === void 0) return void 0;
+	return {
+		kind: "ownership",
+		id: base.id,
+		physicalName: base.physicalName,
+		object,
+		owner,
+		...base.metadata
+	};
+}
+function validateStorage(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Storage must be an object", path));
+		return;
+	}
+	if (value.kind === "portable") {
+		requireKeys(value, ["kind", "type"], path, diagnostics);
+		const type = stringValue(value.type, [...path, "type"], diagnostics, true);
+		return type === void 0 ? void 0 : {
+			kind: "portable",
+			type
+		};
+	}
+	if (value.kind === "native") {
+		requireKeys(value, [
+			"kind",
+			"dialect",
+			"type",
+			"affinity"
+		], path, diagnostics, ["affinity"]);
+		const dialect = stringValue(value.dialect, [...path, "dialect"], diagnostics, true);
+		const type = stringValue(value.type, [...path, "type"], diagnostics, true);
+		const affinity = value.affinity === void 0 ? void 0 : validateChoice(value.affinity, [
+			"blob",
+			"integer",
+			"numeric",
+			"real",
+			"text"
+		], [...path, "affinity"], diagnostics);
+		if (dialect === void 0 || type === void 0) return void 0;
+		return {
+			kind: "native",
+			dialect,
+			type,
+			...affinity === void 0 ? {} : { affinity }
+		};
+	}
+	diagnostics.push(issue("invalid-snapshot", "Storage kind is invalid", [...path, "kind"]));
+}
+function validateDefault(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Default must be an object", path));
+		return;
+	}
+	if (value.kind === "external") {
+		requireKeys(value, ["kind"], path, diagnostics);
+		return { kind: "external" };
+	}
+	if (value.kind === "literal") {
+		requireKeys(value, ["kind", "value"], path, diagnostics);
+		const literal = validateLiteral(value.value, [...path, "value"], diagnostics);
+		return literal === void 0 ? void 0 : {
+			kind: "literal",
+			value: literal
+		};
+	}
+	if (value.kind === "expression") {
+		requireKeys(value, ["kind", "expression"], path, diagnostics);
+		const expression = validateExpression(value.expression, [...path, "expression"], diagnostics);
+		return expression === void 0 ? void 0 : {
+			kind: "expression",
+			expression
+		};
+	}
+	diagnostics.push(issue("invalid-snapshot", "Default kind is invalid", [...path, "kind"]));
+}
+function validateGenerated(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Generated-column metadata must be an object", path));
+		return;
+	}
+	if (value.kind === "external") {
+		requireKeys(value, ["kind"], path, diagnostics);
+		return { kind: "external" };
+	}
+	if (value.kind === "expression") {
+		requireKeys(value, [
+			"kind",
+			"expression",
+			"mode"
+		], path, diagnostics);
+		const expression = validateExpression(value.expression, [...path, "expression"], diagnostics);
+		const mode = validateChoice(value.mode, ["stored", "virtual"], [...path, "mode"], diagnostics);
+		return expression === void 0 || mode === void 0 ? void 0 : {
+			kind: "expression",
+			expression,
+			mode
+		};
+	}
+	diagnostics.push(issue("invalid-snapshot", "Generated-column kind is invalid", [...path, "kind"]));
+}
+function validateIdentity(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Identity must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"kind",
+		"generation",
+		"options",
+		"provenance",
+		"physicalReference",
+		"dialect"
+	], path, diagnostics, [
+		"provenance",
+		"physicalReference",
+		"dialect"
+	]);
+	if (value.kind !== "identity") diagnostics.push(issue("invalid-snapshot", "Identity kind must be identity", [...path, "kind"]));
+	const generation = validateChoice(value.generation, ["always", "by-default"], [...path, "generation"], diagnostics);
+	const options = validateValueFactRecord(value.options, [...path, "options"], diagnostics);
+	const metadata = validateObjectMetadata(value, path, void 0, diagnostics);
+	if (generation === void 0 || options === void 0 || value.kind !== "identity") return void 0;
+	return {
+		kind: "identity",
+		generation,
+		options,
+		...metadata
+	};
+}
+function validateExpression(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Expression must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"kind",
+		"expressionKind",
+		"sql",
+		"dialect"
+	], path, diagnostics, ["dialect"]);
+	const expressionKind = stringValue(value.expressionKind, [...path, "expressionKind"], diagnostics, true);
+	const sql = stringValue(value.sql, [...path, "sql"], diagnostics);
+	const dialect = value.dialect === void 0 ? void 0 : stringValue(value.dialect, [...path, "dialect"], diagnostics, true);
+	if (value.kind !== "expression") diagnostics.push(issue("invalid-snapshot", "Expression kind must be expression", [...path, "kind"]));
+	if (sql !== void 0 && sql !== sql.replace(/\r\n?/g, "\n")) diagnostics.push(issue("non-canonical", "Expression SQL must use LF line endings", [...path, "sql"]));
+	if (expressionKind === "unsafe" && dialect === void 0) diagnostics.push(issue("invalid-snapshot", "Unsafe expressions must carry a dialect tag", [...path, "dialect"]));
+	if (expressionKind !== void 0 && expressionKind !== "unsafe" && dialect !== void 0) diagnostics.push(issue("invalid-snapshot", "Only unsafe expressions may carry a dialect tag", [...path, "dialect"]));
+	if (expressionKind === void 0 || sql === void 0 || value.kind !== "expression") return void 0;
+	return {
+		kind: "expression",
+		expressionKind,
+		sql,
+		...dialect === void 0 ? {} : { dialect }
+	};
+}
+function validateLiteral(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Literal must be an object", path));
+		return;
+	}
+	if (value.kind === "null") {
+		requireKeys(value, ["kind"], path, diagnostics);
+		return { kind: "null" };
+	}
+	if (value.kind === "boolean" || value.kind === "string") {
+		requireKeys(value, ["kind", "value"], path, diagnostics);
+		const expected = value.kind === "boolean" ? "boolean" : "string";
+		if (typeof value.value !== expected) diagnostics.push(issue("invalid-snapshot", `${expected} literal value is invalid`, [...path, "value"]));
+		return typeof value.value === expected ? {
+			kind: value.kind,
+			value: value.value
+		} : void 0;
+	}
+	if (value.kind === "number" || value.kind === "bigint") {
+		requireKeys(value, ["kind", "value"], path, diagnostics);
+		const raw = value.value;
+		const valid = typeof raw === "string" && isCanonicalNumber(raw, value.kind === "bigint");
+		if (!valid) diagnostics.push(issue("invalid-snapshot", `${value.kind} literal value is not canonical`, [...path, "value"]));
+		return valid ? {
+			kind: value.kind,
+			value: raw
+		} : void 0;
+	}
+	diagnostics.push(issue("invalid-snapshot", "Literal kind is invalid", [...path, "kind"]));
+}
+function validateValueFact(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Value fact must be an object", path));
+		return;
+	}
+	if (value.kind === "literal") {
+		requireKeys(value, ["kind", "value"], path, diagnostics);
+		const literal = validateLiteral(value.value, [...path, "value"], diagnostics);
+		return literal === void 0 ? void 0 : {
+			kind: "literal",
+			value: literal
+		};
+	}
+	if (value.kind === "expression") {
+		requireKeys(value, ["kind", "expression"], path, diagnostics);
+		const expression = validateExpression(value.expression, [...path, "expression"], diagnostics);
+		return expression === void 0 ? void 0 : {
+			kind: "expression",
+			expression
+		};
+	}
+	diagnostics.push(issue("invalid-snapshot", "Value fact kind is invalid", [...path, "kind"]));
+}
+function validateValueFactRecord(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Value-fact options must be an object", path));
+		return;
+	}
+	const result = {};
+	for (const key of Object.keys(value).sort()) {
+		const fact = validateValueFact(value[key], [...path, key], diagnostics);
+		if (fact !== void 0) result[key] = fact;
+	}
+	return result;
+}
+function validateProvenance(value, path, dialect, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Provenance must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"kind",
+		"dialect",
+		"path"
+	], path, diagnostics, ["path"]);
+	const kind = validateChoice(value.kind, [
+		"catalog",
+		"decompiler",
+		"create-sql"
+	], [...path, "kind"], diagnostics);
+	const sourceDialect = stringValue(value.dialect, [...path, "dialect"], diagnostics, true);
+	const sourcePath = value.path === void 0 ? void 0 : validatePath(value.path, [...path, "path"], diagnostics);
+	if (dialect !== void 0 && sourceDialect !== void 0 && sourceDialect !== dialect) diagnostics.push(issue("dialect-mismatch", `Provenance belongs to "${sourceDialect}" but snapshot dialect is "${dialect}"`, [...path, "dialect"]));
+	if (kind === void 0 || sourceDialect === void 0) return void 0;
+	return {
+		kind,
+		dialect: sourceDialect,
+		...sourcePath === void 0 ? {} : { path: sourcePath }
+	};
+}
+function validatePhysicalReference(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Physical reference must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"kind",
+		"namespace",
+		"table",
+		"name"
+	], path, diagnostics, ["namespace", "table"]);
+	const kind = stringValue(value.kind, [...path, "kind"], diagnostics, true);
+	const namespace = value.namespace === void 0 ? void 0 : stringValue(value.namespace, [...path, "namespace"], diagnostics, true);
+	const table = value.table === void 0 ? void 0 : stringValue(value.table, [...path, "table"], diagnostics, true);
+	const name = stringValue(value.name, [...path, "name"], diagnostics, true);
+	if (kind !== void 0 && !completeObjectKinds.has(kind) && kind !== "namespace") diagnostics.push(issue("invalid-snapshot", `Unknown physical reference kind: ${kind}`, [...path, "kind"]));
+	return kind === void 0 || name === void 0 ? void 0 : {
+		kind,
+		...namespace === void 0 ? {} : { namespace },
+		...table === void 0 ? {} : { table },
+		name
+	};
+}
+function validateExtension(value, path, dialect, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Dialect extension must be an object", path));
+		return;
+	}
+	requireKeys(value, [
+		"dialect",
+		"version",
+		"data"
+	], path, diagnostics);
+	const extensionDialect = stringValue(value.dialect, [...path, "dialect"], diagnostics, true);
+	const version = integerValue(value.version, [...path, "version"], diagnostics);
+	const data = validateJsonValue(value.data, [...path, "data"], diagnostics);
+	if (version !== void 0 && version < 1) diagnostics.push(issue("invalid-snapshot", "Dialect extension version must be positive", [...path, "version"]));
+	if (version !== void 0 && version > 1) diagnostics.push(issue("future-version", `Unsupported dialect extension version: ${version}`, [...path, "version"]));
+	if (dialect !== void 0 && extensionDialect !== void 0 && extensionDialect !== dialect) diagnostics.push(issue("dialect-mismatch", `Dialect extension belongs to "${extensionDialect}" but snapshot dialect is "${dialect}"`, [...path, "dialect"]));
+	if (extensionDialect === void 0 || version === void 0 || data === void 0) return void 0;
+	return {
+		dialect: extensionDialect,
+		version,
+		data
+	};
+}
+function validateJsonValue(value, path, diagnostics, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) diagnostics.push(issue("invalid-value", "Non-finite JSON numbers must use a tagged value", path));
+		return Number.isFinite(value) ? value : void 0;
+	}
+	if (typeof value !== "object") {
+		diagnostics.push(issue("invalid-value", "Snapshot data contains an unsupported value", path));
+		return;
+	}
+	if (seen.has(value)) {
+		diagnostics.push(issue("invalid-value", "Snapshot data cannot be cyclic", path));
+		return;
+	}
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const result = [];
+			for (const [index, item] of value.entries()) {
+				const child = validateJsonValue(item, [...path, index], diagnostics, seen);
+				if (child !== void 0) result.push(child);
+			}
+			return result;
+		}
+		if (!isRecord(value)) {
+			diagnostics.push(issue("invalid-value", "Snapshot data must use plain objects", path));
+			return;
+		}
+		if (Object.keys(value).length === 1 && "$bigint" in value) {
+			if (typeof value.$bigint !== "string" || !isCanonicalNumber(value.$bigint, true)) diagnostics.push(issue("invalid-value", "Tagged bigint is not canonical", [...path, "$bigint"]));
+			return typeof value.$bigint === "string" && isCanonicalNumber(value.$bigint, true) ? { $bigint: value.$bigint } : void 0;
+		}
+		if (Object.keys(value).length === 1 && "$number" in value) {
+			if (value.$number !== "NaN" && value.$number !== "Infinity" && value.$number !== "-Infinity") diagnostics.push(issue("invalid-value", "Tagged number is invalid", [...path, "$number"]));
+			return value.$number === "NaN" || value.$number === "Infinity" || value.$number === "-Infinity" ? { $number: value.$number } : void 0;
+		}
+		const result = {};
+		for (const key of Object.keys(value).sort()) {
+			const child = validateJsonValue(value[key], [...path, key], diagnostics, seen);
+			if (child !== void 0) result[key] = child;
+		}
+		return result;
+	} finally {
+		seen.delete(value);
+	}
+}
+function validateObjectReference(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Object reference must be an object", path));
+		return;
+	}
+	requireKeys(value, ["kind", "id"], path, diagnostics);
+	const kind = stringValue(value.kind, [...path, "kind"], diagnostics, true);
+	const id = stringValue(value.id, [...path, "id"], diagnostics, true);
+	if (kind === "namespace") diagnostics.push(issue("invalid-snapshot", "Object references cannot target a namespace", [...path, "kind"]));
+	if (kind !== void 0 && !completeObjectKinds.has(kind)) diagnostics.push(issue("invalid-snapshot", `Unknown object reference kind: ${kind}`, [...path, "kind"]));
+	return kind === void 0 || id === void 0 || !completeObjectKinds.has(kind) || kind === "namespace" ? void 0 : {
+		kind,
+		id
+	};
+}
+function validateReferences(value, path, diagnostics) {
+	return validateArray(value, path, diagnostics, validateObjectReference);
+}
+function validateForeignKeyTarget(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Foreign-key target must be an object", path));
+		return;
+	}
+	requireKeys(value, ["table", "columns"], path, diagnostics);
+	const table = validateObjectReference(value.table, [...path, "table"], diagnostics);
+	const columns = validateIds(value.columns, [...path, "columns"], diagnostics);
+	return table === void 0 || columns === void 0 ? void 0 : {
+		table,
+		columns
+	};
+}
+function validateIds(value, path, diagnostics, nonEmpty = true) {
+	const result = validateStrings(value, path, diagnostics, nonEmpty);
+	if (result === void 0) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, id] of result.entries()) {
+		if (seen.has(id)) diagnostics.push(issue("non-canonical", "References cannot contain duplicate IDs", [...path, index]));
+		seen.add(id);
+	}
+	return result;
+}
+function validateStrings(value, path, diagnostics, nonEmpty) {
+	if (!Array.isArray(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Value must be an array", path));
+		return;
+	}
+	const result = [];
+	for (const [index, item] of value.entries()) {
+		const string = stringValue(item, [...path, index], diagnostics, nonEmpty);
+		if (string !== void 0) result.push(string);
+	}
+	if (nonEmpty && result.length === 0) diagnostics.push(issue("invalid-snapshot", "Array cannot be empty", path));
+	return result;
+}
+function validateArray(value, path, diagnostics, validate) {
+	if (!Array.isArray(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Value must be an array", path));
+		return;
+	}
+	const result = [];
+	for (const [index, item] of value.entries()) {
+		const child = validate(item, [...path, index], diagnostics);
+		if (child !== void 0) result.push(child);
+	}
+	return result;
+}
+function validateTiming(value, path, diagnostics) {
+	const deferrable = optionalBoolean(value.deferrable, [...path, "deferrable"], diagnostics);
+	const initially = validateChoice(value.initially, ["immediate", "deferred"], [...path, "initially"], diagnostics);
+	return {
+		...deferrable === void 0 ? {} : { deferrable },
+		...initially === void 0 ? {} : { initially }
+	};
+}
+function validateAction(value, path, diagnostics) {
+	return validateChoice(value, [
+		"no-action",
+		"restrict",
+		"cascade",
+		"set-null",
+		"set-default"
+	], path, diagnostics);
+}
+function validateMatch(value, path, diagnostics) {
+	return validateChoice(value, [
+		"simple",
+		"full",
+		"partial"
+	], path, diagnostics);
+}
+function validateNulls(value, path, diagnostics) {
+	return validateChoice(value, ["distinct", "not-distinct"], path, diagnostics);
+}
+function validateDirection(value, path, diagnostics) {
+	return validateChoice(value, ["ASC", "DESC"], path, diagnostics);
+}
+function validateIndexNulls(value, path, diagnostics) {
+	return validateChoice(value, ["FIRST", "LAST"], path, diagnostics);
+}
+function validateCheckOption(value, path, diagnostics) {
+	return validateChoice(value, [
+		"none",
+		"local",
+		"cascaded"
+	], path, diagnostics);
+}
+function validateTimingKind(value, path, diagnostics) {
+	return validateChoice(value, [
+		"before",
+		"after",
+		"instead-of",
+		"unknown"
+	], path, diagnostics);
+}
+function validateOrientation(value, path, diagnostics) {
+	return validateChoice(value, ["row", "statement"], path, diagnostics);
+}
+function validateRoutineKind(value, path, diagnostics) {
+	return validateChoice(value, [
+		"function",
+		"procedure",
+		"aggregate",
+		"window",
+		"unknown"
+	], path, diagnostics);
+}
+function validateEvents(value, path, diagnostics) {
+	const events = validateStrings(value, path, diagnostics, true);
+	if (events === void 0) return void 0;
+	const allowed = /* @__PURE__ */ new Set([
+		"insert",
+		"update",
+		"delete",
+		"truncate"
+	]);
+	const result = [];
+	for (const [index, event] of events.entries()) if (!allowed.has(event)) diagnostics.push(issue("invalid-snapshot", "Trigger event is invalid", [...path, index]));
+	else result.push(event);
+	if ([...result].sort().some((event, index) => event !== result[index])) diagnostics.push(issue("non-canonical", "Trigger events must be sorted", path));
+	return result;
+}
+function validatePath(value, path, diagnostics) {
+	if (!Array.isArray(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Provenance path must be an array", path));
+		return;
+	}
+	const result = [];
+	for (const [index, part] of value.entries()) if (typeof part !== "string" && typeof part !== "number" || typeof part === "number" && !Number.isSafeInteger(part)) diagnostics.push(issue("invalid-snapshot", "Provenance path parts must be strings or safe integers", [...path, index]));
+	else result.push(part);
+	return result;
+}
+function validateChoice(value, choices, path, diagnostics) {
+	if (value === void 0) return void 0;
+	if (choices.includes(value)) return value;
+	diagnostics.push(issue("invalid-snapshot", `Value must be one of ${choices.join(", ")}`, path));
+}
+function stringValue(value, path, diagnostics, nonEmpty = false) {
+	if (typeof value !== "string" || nonEmpty && value.length === 0) {
+		diagnostics.push(issue("invalid-snapshot", nonEmpty ? "Value must be a non-empty string" : "Value must be a string", path));
+		return;
+	}
+	return value;
+}
+function integerValue(value, path, diagnostics) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+		diagnostics.push(issue("invalid-snapshot", "Value must be a safe integer", path));
+		return;
+	}
+	return value;
+}
+function booleanValue(value, path, diagnostics) {
+	if (typeof value !== "boolean") {
+		diagnostics.push(issue("invalid-snapshot", "Value must be boolean", path));
+		return;
+	}
+	return value;
+}
+function optionalBoolean(value, path, diagnostics) {
+	return value === void 0 ? void 0 : booleanValue(value, path, diagnostics);
+}
+function isCanonicalNumber(value, integer) {
+	return integer ? /^(?:0|-[1-9]\d*|[1-9]\d*)$/u.test(value) : /^(?:0|-?(?:[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|0(?:\.\d+)?(?:[eE][+-]?\d+)?)$/u.test(value);
+}
+const completeObjectKinds = /* @__PURE__ */ new Set([
+	"table",
+	"column",
+	"constraint",
+	"index",
+	"view",
+	"materialized-view",
+	"sequence",
+	"enum",
+	"domain",
+	"collation",
+	"trigger",
+	"routine",
+	"partition",
+	"policy",
+	"extension",
+	"comment",
+	"ownership",
+	"deferred-object",
+	"opaque-object"
+]);
+function validateCompleteDialectMetadata(snapshot, diagnostics) {
+	const dialect = snapshot.dialect.name;
+	const objects = [
+		...snapshot.tables,
+		...snapshot.views,
+		...snapshot.sequences,
+		...snapshot.enums,
+		...snapshot.domains,
+		...snapshot.collations,
+		...snapshot.triggers,
+		...snapshot.routines,
+		...snapshot.partitions,
+		...snapshot.policies,
+		...snapshot.extensions,
+		...snapshot.deferredObjects,
+		...snapshot.opaqueObjects,
+		...snapshot.comments,
+		...snapshot.ownership
+	];
+	for (const object of objects) {
+		if (object.dialect?.dialect !== void 0 && object.dialect.dialect !== dialect) diagnostics.push(issue("dialect-mismatch", `Dialect extension belongs to "${object.dialect.dialect}" but snapshot dialect is "${dialect}"`, [
+			object.kind,
+			object.id,
+			"dialect",
+			"dialect"
+		]));
+		if (object.provenance?.dialect !== void 0 && object.provenance.dialect !== dialect) diagnostics.push(issue("dialect-mismatch", `Provenance belongs to "${object.provenance.dialect}" but snapshot dialect is "${dialect}"`, [
+			object.kind,
+			object.id,
+			"provenance",
+			"dialect"
+		]));
+	}
+	walkCompleteMetadata(snapshot, [], dialect, diagnostics);
+}
+function walkCompleteMetadata(value, path, dialect, diagnostics, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) {
+			for (const [index, child] of value.entries()) walkCompleteMetadata(child, [...path, index], dialect, diagnostics, seen);
+			return;
+		}
+		if (!isRecord(value)) return;
+		if (value.kind === "expression" && typeof value.dialect === "string" && value.dialect !== dialect) diagnostics.push(issue("dialect-mismatch", `Expression belongs to "${value.dialect}" but snapshot dialect is "${dialect}"`, [...path, "dialect"]));
+		if (value.kind === "native" && typeof value.dialect === "string" && value.dialect !== dialect) diagnostics.push(issue("dialect-mismatch", `Native storage belongs to "${value.dialect}" but snapshot dialect is "${dialect}"`, [...path, "dialect"]));
+		for (const [key, child] of Object.entries(value)) if (key !== "data") walkCompleteMetadata(child, [...path, key], dialect, diagnostics, seen);
+	} finally {
+		seen.delete(value);
+	}
+}
+function validateCompleteCrossReferences(snapshot, diagnostics) {
+	const objects = /* @__PURE__ */ new Map();
+	const add = (object) => {
+		const kind = object.kind;
+		objects.set(referenceKey(kind, object.id), object);
+		if (kind === "primary-key" || kind === "unique" || kind === "unique-constraint" || kind === "foreign-key" || kind === "check") objects.set(referenceKey("constraint", object.id), object);
+	};
+	for (const table of snapshot.tables) {
+		add(table);
+		for (const column of table.columns) add(column);
+		for (const constraint of table.constraints) add(constraint);
+		for (const index of table.indexes) add(index);
+	}
+	for (const group of [
+		snapshot.views,
+		snapshot.sequences,
+		snapshot.enums,
+		snapshot.domains,
+		snapshot.collations,
+		snapshot.triggers,
+		snapshot.routines,
+		snapshot.partitions,
+		snapshot.policies,
+		snapshot.extensions,
+		snapshot.deferredObjects,
+		snapshot.opaqueObjects,
+		snapshot.comments,
+		snapshot.ownership
+	]) for (const object of group) add(object);
+	for (const view of snapshot.views) for (const column of view.columns) add(column);
+	const requireReference = (reference, path, expected) => {
+		if (expected !== void 0 && reference.kind !== expected) diagnostics.push(issue("invalid-cross-reference", `Reference must target a ${expected}`, path));
+		if (!objects.has(referenceKey(reference.kind, reference.id))) diagnostics.push(issue("invalid-cross-reference", `Referenced ${reference.kind} "${reference.id}" does not exist`, path));
+	};
+	for (const [tableIndex, table] of snapshot.tables.entries()) {
+		const columns = new Set(table.columns.map((column) => column.id));
+		for (const [constraintIndex, constraint] of table.constraints.entries()) {
+			if (constraint.kind !== "check") {
+				for (const [columnIndex, column] of constraint.columns.entries()) if (!columns.has(column)) diagnostics.push(issue("invalid-cross-reference", `Constraint column "${column}" is not declared on table "${table.id}"`, [
+					"tables",
+					tableIndex,
+					"constraints",
+					constraintIndex,
+					"columns",
+					columnIndex
+				]));
+			}
+			if (constraint.kind === "foreign-key") {
+				requireReference(constraint.target.table, [
+					"tables",
+					tableIndex,
+					"constraints",
+					constraintIndex,
+					"target",
+					"table"
+				], "table");
+				const target = objects.get(referenceKey(constraint.target.table.kind, constraint.target.table.id));
+				if (target?.kind === "table") {
+					const targetColumns = new Set(target.columns.map((column) => column.id));
+					for (const [columnIndex, column] of constraint.target.columns.entries()) if (!targetColumns.has(column)) diagnostics.push(issue("invalid-cross-reference", `Foreign-key target column "${column}" is not declared on table "${target.id}"`, [
+						"tables",
+						tableIndex,
+						"constraints",
+						constraintIndex,
+						"target",
+						"columns",
+						columnIndex
+					]));
+				}
+			}
+			if (constraint.kind !== "foreign-key" && "backingIndex" in constraint && constraint.backingIndex !== void 0) requireReference(constraint.backingIndex, [
+				"tables",
+				tableIndex,
+				"constraints",
+				constraintIndex,
+				"backingIndex"
+			], "index");
+		}
+		for (const [indexIndex, index] of table.indexes.entries()) {
+			for (const [termIndex, term] of index.terms.entries()) if (term.kind === "column" && !columns.has(term.column)) diagnostics.push(issue("invalid-cross-reference", `Index column "${term.column}" is not declared on table "${table.id}"`, [
+				"tables",
+				tableIndex,
+				"indexes",
+				indexIndex,
+				"terms",
+				termIndex,
+				"column"
+			]));
+			for (const [columnIndex, column] of (index.includedColumns ?? []).entries()) if (!columns.has(column)) diagnostics.push(issue("invalid-cross-reference", `Included index column "${column}" is not declared on table "${table.id}"`, [
+				"tables",
+				tableIndex,
+				"indexes",
+				indexIndex,
+				"includedColumns",
+				columnIndex
+			]));
+			if (index.backingConstraint !== void 0) requireReference(index.backingConstraint, [
+				"tables",
+				tableIndex,
+				"indexes",
+				indexIndex,
+				"backingConstraint"
+			], "constraint");
+		}
+	}
+	for (const [index, sequence] of snapshot.sequences.entries()) if (sequence.ownedBy !== void 0) requireReference(sequence.ownedBy, [
+		"sequences",
+		index,
+		"ownedBy"
+	]);
+	for (const [index, view] of snapshot.views.entries()) for (const [dependency, reference] of (view.dependencies ?? []).entries()) requireReference(reference, [
+		"views",
+		index,
+		"dependencies",
+		dependency
+	]);
+	for (const [index, trigger] of snapshot.triggers.entries()) requireReference(trigger.table, [
+		"triggers",
+		index,
+		"table"
+	]);
+	for (const [index, routine] of snapshot.routines.entries()) for (const [dependency, reference] of (routine.dependencies ?? []).entries()) requireReference(reference, [
+		"routines",
+		index,
+		"dependencies",
+		dependency
+	]);
+	for (const [index, partition] of snapshot.partitions.entries()) requireReference(partition.parent, [
+		"partitions",
+		index,
+		"parent"
+	], "table");
+	for (const [index, policy] of snapshot.policies.entries()) requireReference(policy.table, [
+		"policies",
+		index,
+		"table"
+	], "table");
+	for (const [index, comment] of snapshot.comments.entries()) requireReference(comment.object, [
+		"comments",
+		index,
+		"object"
+	]);
+	for (const [index, ownership] of snapshot.ownership.entries()) requireReference(ownership.object, [
+		"ownership",
+		index,
+		"object"
+	]);
+}
+function referenceKey(kind, id) {
+	return `${kind}\u0000${id}`;
+}
+function validateSortedIds(value, path, diagnostics) {
+	if (!Array.isArray(value)) return;
+	let previous;
+	for (const [index, item] of value.entries()) {
+		if (!isRecord(item) || typeof item.id !== "string") continue;
+		if (previous !== void 0 && item.id <= previous) diagnostics.push(issue("non-canonical", "Entities must be sorted by stable logical ID", [
+			...path,
+			index,
+			"id"
+		]));
+		previous = item.id;
+	}
+}
+function validateSortedPositions(value, path, diagnostics) {
+	let previous;
+	for (const [index, item] of value.entries()) {
+		const position = item.position ?? item.ordinalPosition;
+		if (position !== void 0 && previous !== void 0 && position <= previous) diagnostics.push(issue("non-canonical", "Positioned entries must be sorted by strictly increasing position", [
+			...path,
+			index,
+			item.position === void 0 ? "ordinalPosition" : "position"
+		]));
+		if (position !== void 0) previous = position;
+	}
+}
+function requireKeys(value, required, path, diagnostics, optional = []) {
+	const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+	for (const key of required) if (!optional.includes(key) && !(key in value)) diagnostics.push(issue("invalid-snapshot", `Missing required field "${key}"`, [...path, key]));
+	for (const key of Object.keys(value)) if (!allowed.has(key)) diagnostics.push(issue("unknown-field", `Unknown snapshot field "${key}"`, [...path, key]));
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function issue(code, message, path) {
+	return {
+		code,
+		message,
+		path: Object.freeze([...path])
+	};
+}
+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
+export { completeSchemaSnapshotVersion as _, canonicalizeCompleteSchemaSnapshot as a, schemaSnapshotVersion2 as b, decodeCompleteSchemaSnapshot as c, digestCompleteSchemaSnapshot as d, encodeCompleteSchemaSnapshot as f, completeSchemaSnapshotFormat as g, schemaSnapshotV2Digest as h, assertSchemaSnapshotV2 as i, decodeCompleteSnapshot as l, encodeSchemaSnapshotV2 as m, assertCompleteSchemaSnapshot as n, canonicalizeSchemaSnapshotV2 as o, encodeCompleteSnapshot as p, assertCompleteSnapshot as r, completeSchemaSnapshotDigest as s, CompleteSnapshotValidationError as t, decodeSchemaSnapshotV2 as u, schemaSnapshotCompleteVersion as v, schemaSnapshotV2Version as y };