@atscript/db 0.1.136 → 0.1.137

package/dist/sync.cjs

@@ -1,315 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_db_view = require("./db-view-BAzhEUxB.cjs");
-//#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;
-	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
-/**
-* 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 (typeMapper(field).toUpperCase() !== existingCol.type.toUpperCase()) 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
+const require_column_diff = require("./column-diff-CgxgFKzx.cjs");
 //#region src/schema/table-option-diff.ts
 /**
 * Computes the difference between desired and existing table options.
@@ -839,8 +529,8 @@ var SyncEntry = class SyncEntry {
 async function viewDefinitionChanged(view, store) {
 	const storedSnapshot = await store.readTableSnapshot(view.tableName, true);
 	if (!storedSnapshot) return false;
-	const currentHash = computeTableHash(computeViewSnapshot(view));
-	return computeTableHash(storedSnapshot) !== currentHash;
+	const currentHash = require_column_diff.computeTableHash(require_column_diff.computeViewSnapshot(view));
+	return require_column_diff.computeTableHash(storedSnapshot) !== currentHash;
 }
 /**
 * The plan entry of one table as `plan()` reports it (and as `run()` reports
@@ -935,14 +625,14 @@ async function executeSyncTable(facts, safe, deps, exec) {
 			init.status = "alter";
 		}
 		phase = "Column sync";
-		const hasFkChanges = fkDiff ? hasForeignKeyChanges(fkDiff) : false;
+		const hasFkChanges = fkDiff ? require_column_diff.hasForeignKeyChanges(fkDiff) : false;
 		if (adapter.getExistingColumns && adapter.syncColumns) {
 			const existing = facts.existing ?? await adapter.getExistingColumns();
 			if (existing.length === 0 && !init.renamedFrom) {
 				await adapter.ensureTable(ensureOpts);
 				init.status = "create";
 			} else if (existing.length > 0) {
-				const diff = facts.diff ?? computeColumnDiff(readable.fieldDescriptors, existing, adapter.typeMapper?.bind(adapter));
+				const diff = facts.diff ?? require_column_diff.computeColumnDiff(readable.fieldDescriptors, existing, adapter.typeMapper?.bind(adapter));
 				if (hasFkChanges && !adapter.syncForeignKeys && adapter.recreateTable) {
 					await adapter.recreateTable();
 					init.recreated = true;
@@ -953,7 +643,7 @@ async function executeSyncTable(facts, safe, deps, exec) {
 					};
 				} else {
 					if (hasFkChanges && fkDiff && adapter.dropForeignKeys) {
-						const keysToDrop = [...fkDiff.removed.map((fk) => fkKey(fk.fields)), ...fkDiff.changed.map((fk) => fkKey(fk.desired.fields))];
+						const keysToDrop = [...fkDiff.removed.map((fk) => require_column_diff.fkKey(fk.fields)), ...fkDiff.changed.map((fk) => require_column_diff.fkKey(fk.desired.fields))];
 						if (keysToDrop.length > 0) {
 							await adapter.dropForeignKeys(keysToDrop);
 							droppedFks.push(...keysToDrop);
@@ -967,7 +657,7 @@ async function executeSyncTable(facts, safe, deps, exec) {
 			const existed = adapter.tableExists ? await adapter.tableExists() : false;
 			await adapter.ensureTable(ensureOpts);
 			if (!existed) init.status = "create";
-		} else await applyColumnDiff(adapter, readable, facts.diff ?? computeColumnDiff(readable.fieldDescriptors, snapshotToExistingColumns(storedSnapshot), deps.resolveTypeMapper(adapter)), init, safe, deps.logger, ensureOpts);
+		} else await applyColumnDiff(adapter, readable, facts.diff ?? require_column_diff.computeColumnDiff(readable.fieldDescriptors, require_column_diff.snapshotToExistingColumns(storedSnapshot), deps.resolveTypeMapper(adapter)), init, safe, deps.logger, ensureOpts);
 		else {
 			const existed = adapter.tableExists ? await adapter.tableExists() : true;
 			if (!init.recreated) {
@@ -1118,7 +808,7 @@ function safeModeSkips(facts) {
 	const adapter = readable.dbAdapter;
 	const out = [];
 	if (facts.planEntry.status === "error") return out;
-	if (fkDiff && hasForeignKeyChanges(fkDiff) && !adapter.syncForeignKeys && adapter.recreateTable) return out;
+	if (fkDiff && require_column_diff.hasForeignKeyChanges(fkDiff) && !adapter.syncForeignKeys && adapter.recreateTable) return out;
 	const strategy = diff && diff.typeChanged.length > 0 ? typeChangeStrategy(readable, diff) : "modify";
 	if (strategy === "drop") out.push("recreate");
 	else if (strategy === "recreate") return out;
@@ -1321,7 +1011,7 @@ var SchemaSync = class {
 	logger;
 	constructor(space, logger) {
 		this.space = space;
-		this.logger = logger || require_db_view.NoopLogger;
+		this.logger = logger || require_column_diff.NoopLogger;
 		this.store = new SyncStore(space);
 	}
 	/**
@@ -1348,20 +1038,20 @@ var SchemaSync = class {
 		const snapshots = [];
 		for (const r of allReadables) {
 			if (r.isView) {
-				snapshots.push(computeViewSnapshot(r));
+				snapshots.push(require_column_diff.computeViewSnapshot(r));
 				continue;
 			}
 			r.fieldDescriptors;
 			await r.dbAdapter.prepareTypeMapper?.();
 			const tm = r.dbAdapter.typeMapper?.bind(r.dbAdapter);
 			const opts = r.dbAdapter.getDesiredTableOptions?.();
-			snapshots.push(computeTableSnapshot(r, tm, opts));
+			snapshots.push(require_column_diff.computeTableSnapshot(r, tm, opts));
 		}
 		return {
 			tables,
 			views,
 			externalViews,
-			hash: computeSchemaHash(snapshots)
+			hash: require_column_diff.computeSchemaHash(snapshots)
 		};
 	}
 	/**
@@ -1669,7 +1359,7 @@ var SchemaSync = class {
 			pendingRename,
 			dbName,
 			storedSnapshot,
-			fkDiff: storedSnapshot ? computeForeignKeyDiff(readable.foreignKeys, storedSnapshot.foreignKeys) : void 0,
+			fkDiff: storedSnapshot ? require_column_diff.computeForeignKeyDiff(readable.foreignKeys, storedSnapshot.foreignKeys) : void 0,
 			dropsTable: false,
 			planEntry: init
 		};
@@ -1681,7 +1371,7 @@ var SchemaSync = class {
 				init.columnsToAdd = readable.fieldDescriptors.filter((f) => !f.ignored);
 			} else if (facts.existing && facts.existing.length > 0) {
 				const typeMapper = adapter.typeMapper?.bind(adapter);
-				facts.diff = computeColumnDiff(readable.fieldDescriptors, facts.existing, typeMapper);
+				facts.diff = require_column_diff.computeColumnDiff(readable.fieldDescriptors, facts.existing, typeMapper);
 				this.populatePlanFromDiff(facts.diff, init, readable, safe);
 			}
 		} else if (adapter.syncColumns) if (!storedSnapshot) {
@@ -1692,8 +1382,8 @@ var SchemaSync = class {
 				}
 			}
 		} else {
-			const existing = snapshotToExistingColumns(storedSnapshot);
-			facts.diff = computeColumnDiff(readable.fieldDescriptors, existing, this.resolveTypeMapper(adapter));
+			const existing = require_column_diff.snapshotToExistingColumns(storedSnapshot);
+			facts.diff = require_column_diff.computeColumnDiff(readable.fieldDescriptors, existing, this.resolveTypeMapper(adapter));
 			this.populatePlanFromDiff(facts.diff, init, readable, safe);
 		}
 		else if (adapter.tableExists) {
@@ -1708,7 +1398,7 @@ var SchemaSync = class {
 				if (optionDiff.changed.some((c) => c.destructive)) init.recreated = true;
 			}
 		}
-		if (init.status !== "create" && init.status !== "error" && facts.fkDiff && hasForeignKeyChanges(facts.fkDiff)) {
+		if (init.status !== "create" && init.status !== "error" && facts.fkDiff && require_column_diff.hasForeignKeyChanges(facts.fkDiff)) {
 			const fkDiff = facts.fkDiff;
 			init.status = "alter";
 			init.fkAdded = fkDiff.added.map((fk) => ({
@@ -1760,7 +1450,7 @@ var SchemaSync = class {
 							addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the referencing table "${child.name}" is renamed in the same run (from "${child.pendingRename}") — rename it in a separate run first, then retarget the foreign key and re-run.`);
 							continue;
 						}
-						if (!(child !== void 0 && [...child.readable.foreignKeys.values()].some((desired) => desired.targetTable === t.name && fkKey(desired.fields) === fkKey(fk.fields) && fkKey(desired.targetFields) === fkKey(pk.to)))) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but "${fk.table}.${fk.fields.join(",")}" still references the old key — retarget the foreign key (or migrate manually) and re-run.`);
+						if (!(child !== void 0 && [...child.readable.foreignKeys.values()].some((desired) => desired.targetTable === t.name && require_column_diff.fkKey(desired.fields) === require_column_diff.fkKey(fk.fields) && require_column_diff.fkKey(desired.targetFields) === require_column_diff.fkKey(pk.to)))) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but "${fk.table}.${fk.fields.join(",")}" still references the old key — retarget the foreign key (or migrate manually) and re-run.`);
 					}
 					for (const f of t.readable.fieldDescriptors) if (!f.ignored && !f.isPrimaryKey && f.defaultValue?.kind === "fn" && f.defaultValue.fn === "increment") addRefusal(refusals, t.name, `"${t.name}.${f.physicalName}" is auto-increment but no longer part of the primary key; auto-increment columns must be primary-key columns.`);
 				}
@@ -1909,7 +1599,7 @@ var SchemaSync = class {
 		if (!safe) for (const t of d.tables) {
 			if (!t.diff?.primaryKeyChanged) continue;
 			const keysByChild = /* @__PURE__ */ new Map();
-			for (const fk of t.inboundFks ?? []) keysByChild.set(fk.table, [...keysByChild.get(fk.table) ?? [], fkKey(fk.fields)]);
+			for (const fk of t.inboundFks ?? []) keysByChild.set(fk.table, [...keysByChild.get(fk.table) ?? [], require_column_diff.fkKey(fk.fields)]);
 			for (const [childName, fkKeys] of keysByChild) {
 				const child = d.tableByDbName.get(childName);
 				if (child?.readable.dbAdapter.dropForeignKeys) {
@@ -1992,7 +1682,7 @@ var SchemaSync = class {
 			const adapter = readable.dbAdapter;
 			const tm = adapter.typeMapper?.bind(adapter);
 			const opts = adapter.getDesiredTableOptions?.();
-			const snapshot = readable.isView ? computeViewSnapshot(readable) : computeTableSnapshot(readable, tm, opts);
+			const snapshot = readable.isView ? require_column_diff.computeViewSnapshot(readable) : require_column_diff.computeTableSnapshot(readable, tm, opts);
 			await this.store.writeTableSnapshot(readable.tableName, snapshot);
 		}
 		for (const name of droppedNames) await this.store.deleteTableSnapshot(name);
@@ -2057,7 +1747,7 @@ var SchemaSync = class {
 	*/
 	reportOutcome(result, onError) {
 		if (onError === "silent" || result.entries.length === 0) return;
-		const out = this.logger === require_db_view.NoopLogger ? console : this.logger;
+		const out = this.logger === require_column_diff.NoopLogger ? console : this.logger;
 		const counts = /* @__PURE__ */ new Map();
 		for (const entry of result.entries) counts.set(entry.status, (counts.get(entry.status) ?? 0) + 1);
 		const summary = [...counts.entries()].map(([status, n]) => `${n} ${status}`).join(", ");
@@ -2152,7 +1842,7 @@ var SchemaSync = class {
 		if (adapter.getExistingTableOptions) existing = await adapter.getExistingTableOptions(tableName);
 		else {
 			const snapshot = await this.store.readTableSnapshot(tableName ?? readable.tableName);
-			existing = snapshot ? snapshotToExistingTableOptions(snapshot) : [];
+			existing = snapshot ? require_column_diff.snapshotToExistingTableOptions(snapshot) : [];
 		}
 		if (existing.length === 0) return null;
 		const destructiveKeys = adapter.destructiveOptionKeys?.();
@@ -2219,19 +1909,19 @@ async function planSchema(space, types, opts) {
 //#endregion
 exports.SchemaSync = SchemaSync;
 exports.SyncEntry = SyncEntry;
-exports.canonicalizeQueryNode = canonicalizeQueryNode;
-exports.computeColumnDiff = computeColumnDiff;
-exports.computeForeignKeyDiff = computeForeignKeyDiff;
-exports.computeSchemaHash = computeSchemaHash;
-exports.computeTableHash = computeTableHash;
+exports.canonicalizeQueryNode = require_column_diff.canonicalizeQueryNode;
+exports.computeColumnDiff = require_column_diff.computeColumnDiff;
+exports.computeForeignKeyDiff = require_column_diff.computeForeignKeyDiff;
+exports.computeSchemaHash = require_column_diff.computeSchemaHash;
+exports.computeTableHash = require_column_diff.computeTableHash;
 exports.computeTableOptionDiff = computeTableOptionDiff;
-exports.computeTableSnapshot = computeTableSnapshot;
-exports.computeViewSnapshot = computeViewSnapshot;
-exports.fkKey = fkKey;
-exports.hasForeignKeyChanges = hasForeignKeyChanges;
+exports.computeTableSnapshot = require_column_diff.computeTableSnapshot;
+exports.computeViewSnapshot = require_column_diff.computeViewSnapshot;
+exports.fkKey = require_column_diff.fkKey;
+exports.hasForeignKeyChanges = require_column_diff.hasForeignKeyChanges;
 exports.planSchema = planSchema;
 exports.readStoredSnapshot = readStoredSnapshot;
-exports.snapshotToExistingColumns = snapshotToExistingColumns;
-exports.snapshotToExistingTableOptions = snapshotToExistingTableOptions;
+exports.snapshotToExistingColumns = require_column_diff.snapshotToExistingColumns;
+exports.snapshotToExistingTableOptions = require_column_diff.snapshotToExistingTableOptions;
 exports.syncSchema = syncSchema;
 exports.topoOrder = topoOrder;

package/dist/sync.d.cts

@@ -1,5 +1,5 @@
-import { D as TColumnDiff, Ft as AtscriptDbReadable, G as TDbObjectKind, I as TDbDefaultValue, R as TDbFieldMeta, Ut as TGenericLogger, X as TDbStorageType, at as TExistingTableOption, ht as TReferencingForeignKey, it as TExistingForeignKey, mt as TPrimaryKeyChange, nt as TEnsureTableOptions, rt as TExistingColumn, yt as TTableOptionDiff, z as TDbForeignKey } from "./buckets-kKY0RKYN.cjs";
-import { i as AtscriptDbView, l as AtscriptQueryFieldRef$1, t as DbSpace, u as AtscriptQueryNode$1 } from "./db-space-ClG41vJh.cjs";
+import { $t as AtscriptDbReadable, Ft as DbSpace, G as TDbObjectKind, I as TDbDefaultValue, R as TDbFieldMeta, Rt as AtscriptDbView, Ut as AtscriptQueryFieldRef$1, Wt as AtscriptQueryNode$1, X as TDbStorageType, at as TExistingTableOption, ht as TReferencingForeignKey, it as TExistingForeignKey, mt as TPrimaryKeyChange, nt as TEnsureTableOptions, rt as TExistingColumn, sn as TGenericLogger, yt as TTableOptionDiff, z as TDbForeignKey } from "./buckets-C-27xmtq.cjs";
+import { t as computeColumnDiff } from "./column-diff-BmqvgBWw.cjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/schema/sync-entry.d.ts
@@ -305,6 +305,11 @@ interface TViewSnapshot {
   /** @since 0.1.128 — hash of the canonical `@db.view.having` predicate. */
   havingHash?: string;
   materialized?: boolean;
+  /**
+   * @since 0.1.137 — the adapter's `viewRenderRevision()`, present only when
+   * the adapter defines one (managed views only).
+   */
+  renderRevision?: string;
   fields: TFieldSnapshot[];
 }
 /**
@@ -554,19 +559,6 @@ declare class SchemaSync {
   private buildExecutorDeps;
 }
 //#endregion
-//#region src/schema/column-diff.d.ts
-/**
- * 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.
- */
-declare function computeColumnDiff(desired: readonly TDbFieldMeta[], existing: TExistingColumn[], typeMapper?: (field: TDbFieldMeta) => string): TColumnDiff;
-//#endregion
 //#region src/schema/table-option-diff.d.ts
 /**
  * Computes the difference between desired and existing table options.

package/dist/sync.d.mts

@@ -1,5 +1,5 @@
-import { D as TColumnDiff, Ft as AtscriptDbReadable, G as TDbObjectKind, I as TDbDefaultValue, R as TDbFieldMeta, Ut as TGenericLogger, X as TDbStorageType, at as TExistingTableOption, ht as TReferencingForeignKey, it as TExistingForeignKey, mt as TPrimaryKeyChange, nt as TEnsureTableOptions, rt as TExistingColumn, yt as TTableOptionDiff, z as TDbForeignKey } from "./buckets-y4EzoX7D.mjs";
-import { i as AtscriptDbView, l as AtscriptQueryFieldRef$1, t as DbSpace, u as AtscriptQueryNode$1 } from "./db-space-BX4K3vb6.mjs";
+import { $t as AtscriptDbReadable, Ft as DbSpace, G as TDbObjectKind, I as TDbDefaultValue, R as TDbFieldMeta, Rt as AtscriptDbView, Ut as AtscriptQueryFieldRef$1, Wt as AtscriptQueryNode$1, X as TDbStorageType, at as TExistingTableOption, ht as TReferencingForeignKey, it as TExistingForeignKey, mt as TPrimaryKeyChange, nt as TEnsureTableOptions, rt as TExistingColumn, sn as TGenericLogger, yt as TTableOptionDiff, z as TDbForeignKey } from "./buckets-BFG2RYRW.mjs";
+import { t as computeColumnDiff } from "./column-diff-DPkbZIVE.mjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/schema/sync-entry.d.ts
@@ -305,6 +305,11 @@ interface TViewSnapshot {
   /** @since 0.1.128 — hash of the canonical `@db.view.having` predicate. */
   havingHash?: string;
   materialized?: boolean;
+  /**
+   * @since 0.1.137 — the adapter's `viewRenderRevision()`, present only when
+   * the adapter defines one (managed views only).
+   */
+  renderRevision?: string;
   fields: TFieldSnapshot[];
 }
 /**
@@ -554,19 +559,6 @@ declare class SchemaSync {
   private buildExecutorDeps;
 }
 //#endregion
-//#region src/schema/column-diff.d.ts
-/**
- * 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.
- */
-declare function computeColumnDiff(desired: readonly TDbFieldMeta[], existing: TExistingColumn[], typeMapper?: (field: TDbFieldMeta) => string): TColumnDiff;
-//#endregion
 //#region src/schema/table-option-diff.d.ts
 /**
  * Computes the difference between desired and existing table options.