@atscript/db 0.1.135 → 0.1.137

package/dist/shared.mjs

@@ -1,2 +1,2 @@
-import { a as getAnnotationAlias, c as getParentStruct, d as validateExclusiveWith, f as validateFieldBaseType, i as validateRefArgument, l as getParentTypeName, n as hasAnyViewAnnotation, o as getDbTableOwner, p as validateSiblingStringField, r as validateQueryScope, s as getNavTargetTypeName, t as findFKFieldsPointingTo, u as refActionAnnotation } from "./validation-utils-MWOP1Ts4.mjs";
-export { findFKFieldsPointingTo, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, refActionAnnotation, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField };
+import { _ as validateSiblingStringField, a as validateRefArgument, c as getAnnotationAlias, d as getParentStruct, f as getParentTypeName, g as validateFieldBaseType, h as validateExclusiveWith, i as validateQueryScope, l as getDbTableOwner, m as refActionAnnotation, n as hasAnyViewAnnotation, o as viewJoins, p as primitiveBaseType, r as joinTargets, s as viewScopeTypes, t as findFKFieldsPointingTo, u as getNavTargetTypeName } from "./validation-utils-B4h-GW4d.mjs";
+export { findFKFieldsPointingTo, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, joinTargets, primitiveBaseType, refActionAnnotation, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };

package/dist/sync.cjs

@@ -1,292 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_db_view = require("./db-view-Dm7MpUGB.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 result = {
-		tableName: view.tableName,
-		viewType: plan.materialized ? "M" : "V",
-		entryTable: plan.entryTable,
-		joinTables: plan.joins.map((j) => ({
-			targetTable: j.targetTable,
-			condition: JSON.stringify(canonicalizeQueryNode(j.condition, qualify))
-		})),
-		materialized: plan.materialized || void 0,
-		fields
-	};
-	if (plan.filter) result.filterHash = fnv1a(JSON.stringify(canonicalizeQueryNode(plan.filter, qualify)));
-	if (plan.having) result.havingHash = fnv1a(JSON.stringify(canonicalizeQueryNode(plan.having, qualify)));
-	return result;
-}
-/**
-* 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.
@@ -816,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
@@ -912,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;
@@ -930,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);
@@ -944,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) {
@@ -1095,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;
@@ -1298,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);
 	}
 	/**
@@ -1325,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)
 		};
 	}
 	/**
@@ -1646,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
 		};
@@ -1658,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) {
@@ -1669,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) {
@@ -1685,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) => ({
@@ -1737,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.`);
 				}
@@ -1747,7 +1460,11 @@ var SchemaSync = class {
 				if (d.externalTargets.get(fk.targetTable) === false) addRefusal(refusals, t.name, `FK ${t.name}.${fk.fields.join(",")} references "${fk.targetTable}" which is neither in the sync inventory nor present in the database`);
 			}
 		}
-		for (const view of d.views) if (d.viewObjectKinds.get(view.tableName) === "table") addRefusal(refusals, view.tableName, `A physical table "${view.tableName}" exists where managed view "${view.tableName}" is declared — drop or rename it`);
+		for (const view of d.views) {
+			if (d.viewObjectKinds.get(view.tableName) === "table") addRefusal(refusals, view.tableName, `A physical table "${view.tableName}" exists where managed view "${view.tableName}" is declared — drop or rename it`);
+			const fns = view.dbAdapter.aggregateFns();
+			for (const col of view.getViewColumnMappings()) if (col.aggFn && !fns.has(col.aggFn)) addRefusal(refusals, view.tableName, `View "${view.tableName}" field "${col.viewPath}": aggregate "${col.aggFn}" is not supported by this adapter (aggregateFns())`);
+		}
 		if (!safe) for (const r of d.removed) {
 			if (r.isView) continue;
 			const referencers = [];
@@ -1882,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) {
@@ -1965,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);
@@ -2030,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(", ");
@@ -2125,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?.();
@@ -2192,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 { E as TColumnDiff, F as TDbDefaultValue, Ht as TGenericLogger, L as TDbFieldMeta, Pt as AtscriptDbReadable, R as TDbForeignKey, W as TDbObjectKind, Y as TDbStorageType, it as TExistingTableOption, mt as TReferencingForeignKey, nt as TExistingColumn, pt as TPrimaryKeyChange, rt as TExistingForeignKey, tt as TEnsureTableOptions, vt as TTableOptionDiff } from "./buckets-D6PBXKRJ.cjs";
-import { c as AtscriptQueryFieldRef$1, i as AtscriptDbView, l as AtscriptQueryNode$1, t as DbSpace } from "./db-space-BdtBNTeH.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
@@ -269,9 +269,27 @@ interface TViewJoinSnapshot {
   targetTable: string;
   /** Canonical JSON of the join condition (see {@link canonicalizeQueryNode}). */
   condition: string;
-  /** Reserved for optional joins; absent today so it does not perturb the hash. */
+  /** Emitted only for `"left"` — an inner join (the default) carries no key. @since 0.1.136 */
   kind?: "inner" | "left";
 }
+/**
+ * One column of a managed view as stored in its snapshot — the PHYSICAL
+ * source it reads, so a source rename (`@db.column`, flattening, a moved
+ * JSON leaf) or an aggregate change recreates the view.
+ * @since 0.1.136
+ */
+interface TViewColumnSnapshot {
+  column: string;
+  sourceTable: string;
+  sourceColumn: string;
+  /** JSON array of the path segments inside a JSON source column. */
+  jsonPath?: string;
+  jsonType?: string;
+  aggFn?: string;
+  aggField?: string;
+  /** Canonical JSON of a conditional aggregate's predicate. */
+  aggFilter?: string;
+}
 interface TViewSnapshot {
   tableName: string;
   viewType: "V" | "M" | "E";
@@ -281,10 +299,17 @@ interface TViewSnapshot {
    * join-less view (`[]`) serializes byte-identically to older snapshots.
    */
   joinTables?: TViewJoinSnapshot[];
+  /** @since 0.1.136 — view columns and their physical sources, sorted by `column`. */
+  columns?: TViewColumnSnapshot[];
   filterHash?: string;
   /** @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[];
 }
 /**
@@ -534,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.
@@ -649,4 +661,4 @@ declare function syncSchema(space: DbSpace, types: readonly TAtscriptAnnotatedTy
  */
 declare function planSchema(space: DbSpace, types: readonly TAtscriptAnnotatedType[], opts?: Pick<TSyncOptions, "force" | "safe">): Promise<TSyncPlan>;
 //#endregion
-export { SchemaSync, SyncEntry, type TDbObjectKind, type TDependencyEdge, type TEnsureTableOptions, type TExistingForeignKey, type TFieldSnapshot, type TForeignKeyDiff, type TForeignKeySnapshot, type TPrimaryKeyChange, type TReferencingForeignKey, type TSyncColors, type TSyncEntryInit, type TSyncEntryStatus, type TSyncOptions, type TSyncPlan, type TSyncResult, type TSyncSkippedWork, type TTableSnapshot, type TViewJoinSnapshot, type TViewSnapshot, canonicalizeQueryNode, computeColumnDiff, computeForeignKeyDiff, computeSchemaHash, computeTableHash, computeTableOptionDiff, computeTableSnapshot, computeViewSnapshot, fkKey, hasForeignKeyChanges, planSchema, readStoredSnapshot, snapshotToExistingColumns, snapshotToExistingTableOptions, syncSchema, topoOrder };
+export { SchemaSync, SyncEntry, type TDbObjectKind, type TDependencyEdge, type TEnsureTableOptions, type TExistingForeignKey, type TFieldSnapshot, type TForeignKeyDiff, type TForeignKeySnapshot, type TPrimaryKeyChange, type TReferencingForeignKey, type TSyncColors, type TSyncEntryInit, type TSyncEntryStatus, type TSyncOptions, type TSyncPlan, type TSyncResult, type TSyncSkippedWork, type TTableSnapshot, type TViewColumnSnapshot, type TViewJoinSnapshot, type TViewSnapshot, canonicalizeQueryNode, computeColumnDiff, computeForeignKeyDiff, computeSchemaHash, computeTableHash, computeTableOptionDiff, computeTableSnapshot, computeViewSnapshot, fkKey, hasForeignKeyChanges, planSchema, readStoredSnapshot, snapshotToExistingColumns, snapshotToExistingTableOptions, syncSchema, topoOrder };