@atscript/db 0.1.136 → 0.1.137

package/dist/{db-view-BAzhEUxB.cjs → column-diff-CgxgFKzx.cjs}

@@ -119,18 +119,24 @@ function findAncestorInSet(path, set) {
 	}
 }
 /**
+* Whether a `@db.column` / `@db.column.renamed` on `path` applies: always on
+* relational storage; on document storage (`nestedObjects`) for top-level
+* fields only — nested keys are stored as-is. Column maps are built with it.
+*/
+function columnOverrideApplies(path, nestedObjects) {
+	return !nestedObjects || !path.includes(".");
+}
+/**
 * Logical field path → its physical path in document storage (nested
-* objects kept inline). `@db.column` renames (`columnMap`) apply to the
-* annotated key, and a document renames the TOP-LEVEL key only — nested keys
-* are stored as-is — so a dotted path under a renamed top-level object
-* renames its first segment: `profile.bio` under `@db.column 'prof'` →
-* `prof.bio`.
+* objects kept inline). A document renames the TOP-LEVEL key only — nested
+* keys are stored as-is, so a `@db.column` on a nested leaf renames nothing
+* (`address.zip` stays `address.zip`; see {@link columnOverrideApplies}) —
+* and a dotted path under a renamed top-level object renames its first
+* segment: `profile.bio` under `@db.column 'prof'` → `prof.bio`.
 */
 function documentPath(columnMap, path) {
-	const direct = columnMap.get(path);
-	if (direct !== void 0) return direct;
 	const dot = path.indexOf(".");
-	if (dot === -1) return path;
+	if (dot === -1) return columnMap.get(path) ?? path;
 	const top = columnMap.get(path.slice(0, dot));
 	return top === void 0 ? path : top + path.slice(dot);
 }
@@ -196,6 +202,7 @@ var TableMetadata = class {
 	ignoredFields = /* @__PURE__ */ new Set();
 	uniqueProps = /* @__PURE__ */ new Set();
 	defaults = /* @__PURE__ */ new Map();
+	/** Logical path → `@db.column` override (top-level keys only on document storage). */
 	columnMap = /* @__PURE__ */ new Map();
 	dimensions = [];
 	measures = [];
@@ -261,17 +268,19 @@ var TableMetadata = class {
 	get isBuilt() {
 		return this._built;
 	}
-	/**
-	* Logical field path → its physical path in document storage (nested
-	* objects kept inline). `@db.column` renames apply to the annotated key,
-	* and a document renames the TOP-LEVEL key only — nested keys are stored
-	* as-is — so a dotted path under a renamed top-level object renames its
-	* first segment: `profile.bio` under `@db.column 'prof'` → `prof.bio`.
-	*/
+	/** {@link documentPath} over this table's `columnMap`. */
 	documentPath(path) {
 		return documentPath(this.columnMap, path);
 	}
 	/**
+	* Physical name of a logical path: the document path on nested-object
+	* adapters, else the relational column (`pathToPhysical`, then the
+	* `@db.column` override).
+	*/
+	physicalPath(logical) {
+		return this.nestedObjects ? this.documentPath(logical) : this.pathToPhysical.get(logical) ?? this.columnMap.get(logical) ?? logical;
+	}
+	/**
 	* Runs the full metadata compilation pipeline. Called once by
 	* `AtscriptDbReadable._ensureBuilt()` on first metadata access.
 	*
@@ -359,10 +368,11 @@ var TableMetadata = class {
 			this.primaryKeys.push(fieldName);
 			this.originalMetaIdFields.push(fieldName);
 		}
+		const renamable = columnOverrideApplies(fieldName, this.nestedObjects);
 		const column = metadata.get("db.column");
-		if (column) this.columnMap.set(fieldName, column);
+		if (column && renamable) this.columnMap.set(fieldName, column);
 		const columnFrom = metadata.get("db.column.renamed");
-		if (columnFrom) this._columnFromMap.set(fieldName, columnFrom);
+		if (columnFrom && renamable) this._columnFromMap.set(fieldName, columnFrom);
 		const resolvedDefault = resolveDefaultFromMetadata(metadata);
 		if (resolvedDefault) this.defaults.set(fieldName, resolvedDefault);
 		if (metadata.has("db.ignore")) this.ignoredFields.add(fieldName);
@@ -620,7 +630,7 @@ var TableMetadata = class {
 			else if (isJson) storage = "json";
 			else if (isFlattened) storage = "flattened";
 			else storage = "column";
-			const physicalName = skipFlattening ? this.columnMap.get(path) ?? path : this.pathToPhysical.get(path) ?? this.columnMap.get(path) ?? path;
+			const physicalName = this.physicalPath(path);
 			const fromLocal = this._columnFromMap.get(path);
 			let renamedFrom;
 			if (fromLocal) renamedFrom = isFlattened ? flattenedPrefix(path) + fromLocal : fromLocal;
@@ -724,7 +734,7 @@ var TableMetadata = class {
 				field.optional = ftype.optional === true;
 				field.designType = ftype.type.tags?.has("objectId") ? "objectId" : resolveDesignType(ftype);
 			}
-			field.name = this.pathToPhysical.get(field.name) ?? this.columnMap.get(field.name) ?? field.name;
+			field.name = this.physicalPath(field.name);
 		}
 	}
 	/**
@@ -1023,11 +1033,24 @@ var FieldMappingStrategy = class {
 		else if (key === "$not") result[key] = this.translateFilter(value, meta);
 		else if (key.startsWith("$")) result[key] = value;
 		else {
-			const formatKey = meta.columnMap.get(key) ?? key;
-			result[meta.documentPath(key)] = this.formatFilterValue(formatKey, value, meta);
+			const physical = this.physicalPath(key, meta);
+			result[physical] = this.formatFilterValue(physical, value, meta);
 		}
 		return result;
 	}
+	/** `$inc` / `$mul` field-op keys to physical names ({@link physicalPath}). */
+	translateOpsKeys(ops, meta) {
+		if (!this.renamesPaths(meta)) return ops;
+		const physical = (rec) => {
+			const out = {};
+			for (const key in rec) out[this.physicalPath(key, meta)] = rec[key];
+			return out;
+		};
+		return {
+			inc: ops.inc && physical(ops.inc),
+			mul: ops.mul && physical(ops.mul)
+		};
+	}
 	/**
 	* Reverse-maps `@db.column` renames on a row read from storage.
 	* Renames physical keys back to logical names in-place.
@@ -1187,10 +1210,11 @@ var DocumentFieldMapper = class extends FieldMappingStrategy {
 		}
 		return this.formatWriteValues(data, meta);
 	}
+	/** Patch keys (top-level or decomposed dotted) to document paths. */
 	translatePatchKeys(update, meta) {
-		if (meta.columnMap.size > 0) {
+		if (this.renamesPaths(meta)) {
 			const result = {};
-			for (const key of Object.keys(update)) result[meta.columnMap.get(key) ?? key] = update[key];
+			for (const key of Object.keys(update)) result[this.physicalPath(key, meta)] = update[key];
 			return this.formatWriteValues(result, meta);
 		}
 		return this.formatWriteValues(update, meta);
@@ -2239,7 +2263,7 @@ var AtscriptDbReadable = class {
 	get syncMethod() {
 		return this._syncMethod;
 	}
-	/** Logical → physical column name mapping from `@db.column`. */
+	/** Logical → physical column name mapping from `@db.column` (top-level only on document storage). */
 	get columnMap() {
 		this._ensureBuilt();
 		return this._meta.columnMap;
@@ -2934,6 +2958,15 @@ var BaseDbAdapter = class {
 		if (logger) this.logger = logger;
 	}
 	/**
+	* Called by {@link DbSpace} right after its factory builds this adapter —
+	* the administrative one included — before {@link registerReadable}. No-op
+	* by default: override it to share state across a space's adapters when the
+	* adapter has no driver to share it through (the memory adapter keeps one
+	* store per space).
+	* @since 0.1.137
+	*/
+	registerSpace(_space) {}
+	/**
 	* Enables or disables verbose (debug-level) logging for this adapter.
 	* When disabled, no log strings are constructed — zero overhead.
 	*/
@@ -3118,6 +3151,17 @@ var BaseDbAdapter = class {
 		return require_aggregate_fns.BASE_AGGREGATE_FNS;
 	}
 	/**
+	* Revision of how this adapter renders a managed view (its SQL / pipeline)
+	* from an unchanged view definition. Stored in each managed view's sync
+	* snapshot when defined, so bumping it recreates every managed view of the
+	* adapter once on the next sync — return a new value whenever a rendering
+	* fix changes what an existing view returns. `undefined` (the default)
+	* leaves the snapshot, and its hash, as before. External views ignore it.
+	*
+	* @since 0.1.137
+	*/
+	viewRenderRevision() {}
+	/**
 	* Whether this adapter enforces foreign key constraints natively.
 	* When `true`, the generic layer skips application-level cascade/setNull
 	* on delete — the DB engine handles it (e.g. SQLite `ON DELETE CASCADE`).
@@ -3406,6 +3450,26 @@ var BaseDbAdapter = class {
 	*/
 	supportsColumnModify;
 	/**
+	* Drops a table by name (without needing a registered readable).
+	* Used by schema sync to remove tables no longer in the schema. A missing
+	* table is not an error (`DROP TABLE IF EXISTS`). The default throws —
+	* schema sync then reports the removed table as an `error` entry and keeps
+	* it tracked. Since 0.1.137; before, the method was optional and a drop the
+	* adapter lacked was skipped silently while sync reported it done.
+	*/
+	async dropTableByName(tableName) {
+		throw new Error(`Cannot drop table "${tableName}": dropTableByName is not supported by this adapter`);
+	}
+	/**
+	* Drops a view by name (without needing a registered readable).
+	* Used by schema sync to remove views no longer in the schema, and to drop
+	* a managed view before recreating it. A missing view is not an error. The
+	* default throws, with the same history as {@link dropTableByName}.
+	*/
+	async dropViewByName(viewName) {
+		throw new Error(`Cannot drop view "${viewName}": dropViewByName is not supported by this adapter`);
+	}
+	/**
 	* Drops several tables that reference each other (a foreign-key cycle) as
 	* one operation. Schema sync only calls this for cycles whose members are
 	* ALL being removed. Default: {@link dropTableByName} in the given order —
@@ -3415,7 +3479,7 @@ var BaseDbAdapter = class {
 	* @since 0.1.128
 	*/
 	async dropTablesByName(tableNames) {
-		for (const name of tableNames) await this.dropTableByName?.(name);
+		for (const name of tableNames) await this.dropTableByName(name);
 	}
 	/**
 	* Whether the table has at least one row. Schema sync uses it in the
@@ -3527,7 +3591,7 @@ var ApplicationIntegrity = class extends IntegrityStrategy {
 		const physicalToLogical = /* @__PURE__ */ new Map();
 		const physicalFields = [];
 		for (const logical of neededLogical) {
-			const physical = meta.pathToPhysical.get(logical) ?? meta.columnMap.get(logical) ?? logical;
+			const physical = meta.physicalPath(logical);
 			physicalFields.push(physical);
 			physicalToLogical.set(physical, logical);
 		}
@@ -3995,19 +4059,6 @@ var RemoveGuardContext = class {
 		return this._pending;
 	}
 };
-/** Translates a single ops record from logical to physical column names. */
-function _translateOpsRecord(rec, meta) {
-	const out = {};
-	for (const key in rec) out[meta.leafByLogical.get(key)?.physicalName ?? key] = rec[key];
-	return out;
-}
-/** Translates ops keys from logical field names to physical column names. */
-function _translateOpsKeys(ops, meta) {
-	return {
-		inc: ops.inc ? _translateOpsRecord(ops.inc, meta) : void 0,
-		mul: ops.mul ? _translateOpsRecord(ops.mul, meta) : void 0
-	};
-}
 /** Upper bound of keys per `touchMany` UPDATE statement (parameter-count safety). */
 const TOUCH_MANY_CHUNK = 500;
 /** `touchMany` input rejection — always `INVALID_QUERY`, path names the key. */
@@ -4268,13 +4319,13 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 				let result;
 				if (this.adapter.supportsNativePatch()) {
 					const ops = require_ops.separateFieldOps(data);
-					const translatedOps = ops ? _translateOpsKeys(ops, this._meta) : void 0;
+					const translatedOps = ops ? this._fieldMapper.translateOpsKeys(ops, this._meta) : void 0;
 					const translatedData = this._fieldMapper.translatePatchKeys(data, this._meta);
 					result = await this.adapter.nativePatch(translatedFilter, translatedData, translatedOps, expectedVersion);
 				} else {
 					const update = decomposePatch(data, this);
 					const ops = require_ops.separateFieldOps(update);
-					const translatedOps = ops ? _translateOpsKeys(ops, this._meta) : void 0;
+					const translatedOps = ops ? this._fieldMapper.translateOpsKeys(ops, this._meta) : void 0;
 					const translatedUpdate = this._fieldMapper.translatePatchKeys(update, this._meta);
 					if (getArrayOpsFields(translatedUpdate).size > 0) {
 						const resolved = resolveArrayOps(translatedUpdate, await this.adapter.findOne({
@@ -4413,7 +4464,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		await this._encryptItems([dataCopy], "patch");
 		const update = decomposePatch(dataCopy, this);
 		const ops = require_ops.separateFieldOps(update);
-		const translatedOps = ops ? _translateOpsKeys(ops, this._meta) : void 0;
+		const translatedOps = ops ? this._fieldMapper.translateOpsKeys(ops, this._meta) : void 0;
 		const translatedUpdate = this._fieldMapper.translatePatchKeys(update, this._meta);
 		const translatedFilter = this._fieldMapper.translateFilter(filter, this._meta);
 		if (translatedOps === void 0 && require_validator.isEmptyObject(translatedUpdate)) return {
@@ -4695,6 +4746,7 @@ function sourceIndex(type) {
 	idx = {
 		flatMap: /* @__PURE__ */ new Map(),
 		columnMap: /* @__PURE__ */ new Map(),
+		documentColumnMap: /* @__PURE__ */ new Map(),
 		unstored: /* @__PURE__ */ new Set(),
 		jsonRoots: /* @__PURE__ */ new Set(),
 		encrypted: /* @__PURE__ */ new Set(),
@@ -4718,7 +4770,10 @@ function sourceIndex(type) {
 		for (const [path, fieldType, metadata] of collected) {
 			if (!path || findAncestorInSet(path, navFields) !== void 0) continue;
 			const column = metadata.get("db.column");
-			if (column) idx.columnMap.set(path, column);
+			if (column) {
+				idx.columnMap.set(path, column);
+				if (columnOverrideApplies(path, true)) idx.documentColumnMap.set(path, column);
+			}
 			if (metadata.has("db.ignore") || navFields.has(path)) idx.unstored.add(path);
 			if (metadata.has("db.encrypted")) storage.push([path, false]);
 			else if (metadata.has("db.json") || resolveDesignType(fieldType) === "array") storage.push([path, true]);
@@ -4765,7 +4820,7 @@ function resolveViewSource(sourceType, logicalPath, nestedObjects) {
 	if (unstored !== void 0) throw new Error(`"${logicalPath}" has no column — "${unstored}" is @db.ignore or a navigation relation`);
 	const designType = resolveDesignType(node);
 	if (nestedObjects) return {
-		column: documentPath(idx.columnMap, logicalPath),
+		column: documentPath(idx.documentColumnMap, logicalPath),
 		designType,
 		optional
 	};
@@ -4965,7 +5020,7 @@ var AtscriptDbView = class extends AtscriptDbReadable {
 		const ignored = this.ignoredFields;
 		const meta = this.getMetadata();
 		const nested = this._nested;
-		const viewName = (path) => nested ? meta.documentPath(path) : meta.pathToPhysical.get(path);
+		const viewName = (path) => nested ? meta.physicalPath(path) : meta.pathToPhysical.get(path);
 		const fail = (field, message) => {
 			throw new Error(`View "${this.tableName}" field "${field}": ${message}`);
 		};
@@ -5050,6 +5105,328 @@ function isAtscriptDbView(readable) {
 	return readable.isView;
 }
 //#endregion
+//#region src/schema/schema-hash.ts
+/** Extracts sorted field snapshots from a readable's field descriptors. */
+function extractFieldSnapshots(fields, typeMapper) {
+	return fields.filter((f) => !f.ignored).map((f) => {
+		const snap = {
+			physicalName: f.physicalName,
+			designType: f.designType,
+			optional: f.optional,
+			isPrimaryKey: f.isPrimaryKey,
+			storage: f.storage
+		};
+		if (f.defaultValue) snap.defaultValue = f.defaultValue;
+		if (typeMapper) snap.mappedType = typeMapper(f);
+		if (f.encrypted) snap.encrypted = true;
+		return snap;
+	}).toSorted((a, b) => a.physicalName.localeCompare(b.physicalName));
+}
+/**
+* Extracts a canonical, serializable snapshot from a readable's metadata.
+* Sorted deterministically so the hash is stable across runs.
+*
+* @param readable - The table/view readable.
+* @param typeMapper - Optional adapter-specific type mapper. When provided,
+*   each field's mapped type (e.g., "VARCHAR(255)") is stored in the snapshot
+*   for precise type change detection.
+*/
+function computeTableSnapshot(readable, typeMapper, tableOptions) {
+	const fields = extractFieldSnapshots(readable.fieldDescriptors, typeMapper);
+	const indexes = [...readable.indexes.values()].map((idx) => ({
+		key: idx.key,
+		type: idx.type,
+		fields: idx.fields.map((f) => ({
+			name: f.name,
+			sort: f.sort
+		}))
+	})).toSorted((a, b) => a.key.localeCompare(b.key));
+	const foreignKeys = [...readable.foreignKeys.values()].map((fk) => ({
+		fields: [...fk.fields].toSorted(),
+		targetTable: fk.targetTable,
+		targetFields: [...fk.targetFields].toSorted(),
+		onDelete: fk.onDelete,
+		onUpdate: fk.onUpdate
+	})).toSorted((a, b) => a.fields.join(",").localeCompare(b.fields.join(",")));
+	const snapshot = {
+		tableName: readable.tableName,
+		fields,
+		indexes,
+		foreignKeys
+	};
+	if (tableOptions?.length) snapshot.tableOptions = [...tableOptions].toSorted((a, b) => a.key.localeCompare(b.key));
+	return snapshot;
+}
+/**
+* Extracts a canonical, serializable snapshot from a view's metadata.
+* Captures view plan (entry table, joins, filter, materialization) for
+* detecting view definition changes.
+*/
+function computeViewSnapshot(view) {
+	const fields = extractFieldSnapshots(view.fieldDescriptors);
+	if (view.isExternal) return {
+		tableName: view.tableName,
+		viewType: "E",
+		fields
+	};
+	const plan = view.viewPlan;
+	const qualify = (ref) => view.resolveFieldRef(ref, (n) => n);
+	const canonical = (node) => JSON.stringify(canonicalizeQueryNode(node, qualify));
+	const columns = view.getViewColumnMappings().map((m) => {
+		const col = {
+			column: m.viewColumn,
+			sourceTable: m.sourceTable,
+			sourceColumn: m.sourceColumn
+		};
+		if (m.json) {
+			col.jsonPath = JSON.stringify(m.json.path);
+			col.jsonType = m.json.type;
+		}
+		if (m.aggFn) col.aggFn = m.aggFn;
+		if (m.aggField) col.aggField = m.aggField;
+		if (m.aggFilter) col.aggFilter = canonical(m.aggFilter);
+		return col;
+	}).toSorted((a, b) => a.column < b.column ? -1 : a.column > b.column ? 1 : 0);
+	const result = {
+		tableName: view.tableName,
+		viewType: plan.materialized ? "M" : "V",
+		entryTable: plan.entryTable,
+		joinTables: plan.joins.map((j) => {
+			const join = {
+				targetTable: j.targetTable,
+				condition: canonical(j.condition)
+			};
+			if (j.kind === "left") join.kind = "left";
+			return join;
+		}),
+		columns
+	};
+	if (plan.filter) result.filterHash = fnv1a(canonical(plan.filter));
+	if (plan.having) result.havingHash = fnv1a(canonical(plan.having));
+	if (plan.materialized) result.materialized = true;
+	const renderRevision = view.dbAdapter.viewRenderRevision();
+	if (renderRevision !== void 0) result.renderRevision = renderRevision;
+	return {
+		...result,
+		fields
+	};
+}
+/**
+* Converts a view predicate (join condition, `@db.view.filter`,
+* `@db.view.having`) into a serializable structure whose JSON is a stable
+* function of its MEANING: field refs become `qualify(ref)` — the view's
+* `resolveFieldRef(ref, (n) => n)`, i.e. `"<table>.<field>"`, so a predicate
+* retargeted to another table with the same field name changes — operators
+* and literal values are kept as-is, `$and`/`$or` keep declaration order, and
+* no function references survive. Two identical models produce byte-identical
+* JSON.
+* @since 0.1.128
+*/
+function canonicalizeQueryNode(node, qualify) {
+	if ("$and" in node) return { and: node.$and.map((n) => canonicalizeQueryNode(n, qualify)) };
+	if ("$or" in node) return { or: node.$or.map((n) => canonicalizeQueryNode(n, qualify)) };
+	if ("$not" in node) return { not: canonicalizeQueryNode(node.$not, qualify) };
+	const comp = node;
+	const out = {
+		l: qualify(comp.left),
+		op: comp.op
+	};
+	if (comp.right !== void 0) out.r = comp.right !== null && typeof comp.right === "object" && "field" in comp.right ? { f: qualify(comp.right) } : comp.right;
+	return out;
+}
+/**
+* Computes a deterministic hash string from multiple table snapshots.
+* Uses FNV-1a for speed — not cryptographic, just needs stability + collision resistance.
+*/
+function computeSchemaHash(snapshots) {
+	const sorted = [...snapshots].toSorted((a, b) => a.tableName.localeCompare(b.tableName));
+	return fnv1a(JSON.stringify(sorted));
+}
+/**
+* Computes a hash for a single table/view snapshot.
+* Used for per-table change detection via stored snapshots.
+*/
+function computeTableHash(snapshot) {
+	return fnv1a(JSON.stringify(snapshot));
+}
+/**
+* Converts stored snapshot fields to `TExistingColumn[]` format
+* for use with `computeColumnDiff`. Used by adapters that lack
+* native column introspection (e.g., MongoDB).
+*
+* The `type` field uses `mappedType` when available (adapter-specific),
+* falling back to `designType`.
+*/
+function snapshotToExistingColumns(snapshot) {
+	return snapshot.fields.map((f) => ({
+		name: f.physicalName,
+		type: f.mappedType ?? f.designType,
+		notnull: !f.optional,
+		pk: f.isPrimaryKey,
+		dflt_value: serializeDefaultValue(f.defaultValue)
+	}));
+}
+/**
+* Extracts table options from a stored snapshot for diff comparison.
+* Used as fallback when an adapter lacks native table option introspection.
+*/
+function snapshotToExistingTableOptions(snapshot) {
+	return snapshot.tableOptions ?? [];
+}
+/** Serializes a TDbDefaultValue to a comparable string. */
+function serializeDefaultValue(dv) {
+	if (!dv) return;
+	if (dv.kind === "value") return dv.value;
+	return `fn:${dv.fn}`;
+}
+/** FNV-1a 32-bit hash → hex string */
+function fnv1a(str) {
+	let hash = 2166136261;
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.codePointAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return Math.trunc(hash).toString(16).padStart(8, "0");
+}
+//#endregion
+//#region src/schema/fk-diff.ts
+/** Canonical key for an FK: sorted local field names, comma-joined. */
+function fkKey(fields) {
+	return [...fields].toSorted().join(",");
+}
+/**
+* Compares desired FK constraints against stored snapshot to detect
+* additions, removals, and property changes (target table, target fields,
+* onDelete, onUpdate).
+*/
+function computeForeignKeyDiff(desired, existingSnapshot) {
+	const added = [];
+	const removed = [];
+	const changed = [];
+	const existingByKey = /* @__PURE__ */ new Map();
+	for (const fk of existingSnapshot) existingByKey.set(fkKey(fk.fields), fk);
+	const desiredKeys = /* @__PURE__ */ new Set();
+	for (const fk of desired.values()) {
+		const key = fkKey(fk.fields);
+		desiredKeys.add(key);
+		const existing = existingByKey.get(key);
+		if (!existing) added.push(fk);
+		else if (fkPropertiesDiffer(fk, existing)) changed.push({
+			desired: fk,
+			existing
+		});
+	}
+	for (const [key, fk] of existingByKey) if (!desiredKeys.has(key)) removed.push(fk);
+	return {
+		added,
+		removed,
+		changed
+	};
+}
+/** Whether the FK diff contains any changes. */
+function hasForeignKeyChanges(diff) {
+	return diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
+}
+function fkPropertiesDiffer(desired, existing) {
+	if (desired.targetTable !== existing.targetTable) return true;
+	if (fkKey(desired.targetFields) !== fkKey(existing.targetFields)) return true;
+	if ((desired.onDelete ?? void 0) !== (existing.onDelete ?? void 0)) return true;
+	if ((desired.onUpdate ?? void 0) !== (existing.onUpdate ?? void 0)) return true;
+	return false;
+}
+//#endregion
+//#region src/schema/column-diff.ts
+/**
+* Whether a live column's type differs from the type the adapter's
+* `typeMapper` gives the field — the one rule schema sync diffs column types
+* by (case-insensitive). Exported for adapters that must agree with it (the
+* PostgreSQL recreate converts exactly the columns this reports changed).
+* @since 0.1.137
+*/
+function isColumnTypeChanged(existingType, expectedType) {
+	return existingType.toUpperCase() !== expectedType.toUpperCase();
+}
+/**
+* Computes the difference between desired schema fields and existing database columns.
+*
+* @param desired - Field descriptors from the Atscript type (after flattening).
+* @param existing - Columns currently in the database (from introspection).
+* @param typeMapper - Optional function to map field metadata to DB-native type strings.
+*                     Receives the full field meta (design type, annotations, PK status, etc.)
+*                     so adapters can produce context-aware types (e.g., `VARCHAR(255)` from maxLength).
+*                     Required for type change detection.
+*/
+function computeColumnDiff(desired, existing, typeMapper) {
+	const existingByName = new Map(existing.map((c) => [c.name, c]));
+	const desiredByName = /* @__PURE__ */ new Map();
+	const renamedOldNames = /* @__PURE__ */ new Set();
+	const added = [];
+	const renamed = [];
+	const typeChanged = [];
+	const nullableChanged = [];
+	const defaultChanged = [];
+	const conflicts = [];
+	for (const field of desired) {
+		if (field.ignored) continue;
+		desiredByName.set(field.physicalName, field);
+		const existingCol = existingByName.get(field.physicalName);
+		if (existingCol) if (field.renamedFrom && existingByName.has(field.renamedFrom)) {
+			conflicts.push({
+				field,
+				oldName: field.renamedFrom,
+				conflictsWith: field.physicalName
+			});
+			renamedOldNames.add(field.renamedFrom);
+		} else {
+			if (typeMapper) {
+				if (isColumnTypeChanged(existingCol.type, typeMapper(field))) typeChanged.push({
+					field,
+					existingType: existingCol.type
+				});
+			}
+			if (!field.isPrimaryKey && !existingCol.pk) {
+				const desiredNotNull = !field.optional;
+				if (existingCol.notnull !== desiredNotNull) nullableChanged.push({
+					field,
+					wasNullable: !existingCol.notnull
+				});
+			}
+			const desiredDefault = serializeDefaultValue(field.defaultValue);
+			if (existingCol.dflt_value !== void 0 && existingCol.dflt_value !== desiredDefault) defaultChanged.push({
+				field,
+				oldDefault: existingCol.dflt_value,
+				newDefault: desiredDefault
+			});
+		}
+		else if (field.renamedFrom && existingByName.has(field.renamedFrom)) {
+			renamed.push({
+				field,
+				oldName: field.renamedFrom
+			});
+			renamedOldNames.add(field.renamedFrom);
+		} else added.push(field);
+	}
+	const diff = {
+		added,
+		removed: existing.filter((c) => !desiredByName.has(c.name) && !renamedOldNames.has(c.name)),
+		renamed,
+		typeChanged,
+		nullableChanged,
+		defaultChanged,
+		conflicts
+	};
+	if (existing.length > 0) {
+		const newNameByOld = new Map(renamed.map((r) => [r.oldName, r.field.physicalName]));
+		const from = existing.filter((c) => c.pk).map((c) => newNameByOld.get(c.name) ?? c.name);
+		const to = desired.filter((f) => !f.ignored && f.isPrimaryKey).map((f) => f.physicalName);
+		if (fkKey(from) !== fkKey(to)) diff.primaryKeyChanged = {
+			from,
+			to
+		};
+	}
+	return diff;
+}
+//#endregion
 Object.defineProperty(exports, "ADAPTER_FILTER_REASON", {
 	enumerable: true,
 	get: function() {
@@ -5176,6 +5553,12 @@ Object.defineProperty(exports, "canFilterLeaf", {
 		return canFilterLeaf;
 	}
 });
+Object.defineProperty(exports, "canonicalizeQueryNode", {
+	enumerable: true,
+	get: function() {
+		return canonicalizeQueryNode;
+	}
+});
 Object.defineProperty(exports, "checkHavingKeys", {
 	enumerable: true,
 	get: function() {
@@ -5194,6 +5577,42 @@ Object.defineProperty(exports, "collectQueryPaths", {
 		return collectQueryPaths;
 	}
 });
+Object.defineProperty(exports, "computeColumnDiff", {
+	enumerable: true,
+	get: function() {
+		return computeColumnDiff;
+	}
+});
+Object.defineProperty(exports, "computeForeignKeyDiff", {
+	enumerable: true,
+	get: function() {
+		return computeForeignKeyDiff;
+	}
+});
+Object.defineProperty(exports, "computeSchemaHash", {
+	enumerable: true,
+	get: function() {
+		return computeSchemaHash;
+	}
+});
+Object.defineProperty(exports, "computeTableHash", {
+	enumerable: true,
+	get: function() {
+		return computeTableHash;
+	}
+});
+Object.defineProperty(exports, "computeTableSnapshot", {
+	enumerable: true,
+	get: function() {
+		return computeTableSnapshot;
+	}
+});
+Object.defineProperty(exports, "computeViewSnapshot", {
+	enumerable: true,
+	get: function() {
+		return computeViewSnapshot;
+	}
+});
 Object.defineProperty(exports, "createFailureCollector", {
 	enumerable: true,
 	get: function() {
@@ -5212,6 +5631,12 @@ Object.defineProperty(exports, "findAncestorInSet", {
 		return findAncestorInSet;
 	}
 });
+Object.defineProperty(exports, "fkKey", {
+	enumerable: true,
+	get: function() {
+		return fkKey;
+	}
+});
 Object.defineProperty(exports, "guardAggregate", {
 	enumerable: true,
 	get: function() {
@@ -5242,6 +5667,12 @@ Object.defineProperty(exports, "guardQuery", {
 		return guardQuery;
 	}
 });
+Object.defineProperty(exports, "hasForeignKeyChanges", {
+	enumerable: true,
+	get: function() {
+		return hasForeignKeyChanges;
+	}
+});
 Object.defineProperty(exports, "isAtscriptDbView", {
 	enumerable: true,
 	get: function() {
@@ -5254,6 +5685,12 @@ Object.defineProperty(exports, "isBucketableField", {
 		return isBucketableField;
 	}
 });
+Object.defineProperty(exports, "isColumnTypeChanged", {
+	enumerable: true,
+	get: function() {
+		return isColumnTypeChanged;
+	}
+});
 Object.defineProperty(exports, "isGeoIndexableType", {
 	enumerable: true,
 	get: function() {
@@ -5302,6 +5739,18 @@ Object.defineProperty(exports, "resolveDesignType", {
 		return resolveDesignType;
 	}
 });
+Object.defineProperty(exports, "snapshotToExistingColumns", {
+	enumerable: true,
+	get: function() {
+		return snapshotToExistingColumns;
+	}
+});
+Object.defineProperty(exports, "snapshotToExistingTableOptions", {
+	enumerable: true,
+	get: function() {
+		return snapshotToExistingTableOptions;
+	}
+});
 Object.defineProperty(exports, "sortFieldNames", {
 	enumerable: true,
 	get: function() {