@atscript/db 0.1.38

package/dist/sync.mjs

@@ -0,0 +1,1186 @@
+import { NoopLogger } from "./logger-B7oxCfLQ.mjs";
+
+//#region packages/db/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);
+		return snap;
+	}).sort((a, b) => a.physicalName.localeCompare(b.physicalName));
+}
+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
+		}))
+	})).sort((a, b) => a.key.localeCompare(b.key));
+	const foreignKeys = [...readable.foreignKeys.values()].map((fk) => ({
+		fields: [...fk.fields].sort(),
+		targetTable: fk.targetTable,
+		targetFields: [...fk.targetFields].sort(),
+		onDelete: fk.onDelete,
+		onUpdate: fk.onUpdate
+	})).sort((a, b) => a.fields.join(",").localeCompare(b.fields.join(",")));
+	const snapshot = {
+		tableName: readable.tableName,
+		fields,
+		indexes,
+		foreignKeys
+	};
+	if (tableOptions?.length) snapshot.tableOptions = [...tableOptions].sort((a, b) => a.key.localeCompare(b.key));
+	return snapshot;
+}
+function computeViewSnapshot(view) {
+	const fields = extractFieldSnapshots(view.fieldDescriptors);
+	if (view.isExternal) return {
+		tableName: view.tableName,
+		viewType: "E",
+		fields
+	};
+	const plan = view.viewPlan;
+	const result = {
+		tableName: view.tableName,
+		viewType: plan.materialized ? "M" : "V",
+		entryTable: plan.entryTable,
+		joinTables: plan.joins.map((j) => j.targetTable),
+		materialized: plan.materialized || undefined,
+		fields
+	};
+	if (plan.filter) result.filterHash = fnv1a(JSON.stringify(plan.filter, (_, v) => typeof v === "function" ? "[fn]" : v));
+	return result;
+}
+function computeSchemaHash(snapshots) {
+	const sorted = [...snapshots].sort((a, b) => a.tableName.localeCompare(b.tableName));
+	const json = JSON.stringify(sorted);
+	return fnv1a(json);
+}
+function computeTableHash(snapshot) {
+	return fnv1a(JSON.stringify(snapshot));
+}
+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)
+	}));
+}
+function snapshotToExistingTableOptions(snapshot) {
+	return snapshot.tableOptions ?? [];
+}
+function serializeDefaultValue(dv) {
+	if (!dv) return undefined;
+	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 packages/db/src/schema/column-diff.ts
+function computeColumnDiff(desired, existing, typeMapper) {
+	const existingByName = new Map(existing.map((c) => [c.name, c]));
+	const desiredByName = new Map();
+	const renamedOldNames = 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) {
+				const expectedType = typeMapper(field);
+				if (expectedType.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 !== undefined && 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 removed = existing.filter((c) => !desiredByName.has(c.name) && !renamedOldNames.has(c.name));
+	return {
+		added,
+		removed,
+		renamed,
+		typeChanged,
+		nullableChanged,
+		defaultChanged,
+		conflicts
+	};
+}
+
+//#endregion
+//#region packages/db/src/schema/fk-diff.ts
+function fkKey(fields) {
+	return [...fields].sort().join(",");
+}
+function computeForeignKeyDiff(desired, existingSnapshot) {
+	const added = [];
+	const removed = [];
+	const changed = [];
+	const existingByKey = new Map();
+	for (const fk of existingSnapshot) existingByKey.set(fkKey(fk.fields), fk);
+	const desiredKeys = 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
+	};
+}
+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 ?? undefined) !== (existing.onDelete ?? undefined)) return true;
+	if ((desired.onUpdate ?? undefined) !== (existing.onUpdate ?? undefined)) return true;
+	return false;
+}
+
+//#endregion
+//#region packages/db/src/schema/table-option-diff.ts
+function computeTableOptionDiff(desired, existing, destructiveKeys) {
+	const existingByKey = new Map(existing.map((o) => [o.key, o.value]));
+	const changed = [];
+	for (const opt of desired) {
+		const existingValue = existingByKey.get(opt.key);
+		if (existingValue !== undefined && existingValue !== opt.value) changed.push({
+			key: opt.key,
+			oldValue: existingValue,
+			newValue: opt.value,
+			destructive: destructiveKeys?.has(opt.key) ?? false
+		});
+	}
+	return { changed };
+}
+
+//#endregion
+//#region packages/db/src/schema/sync-store.ts
+function _define_property$2(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var SyncStore = class {
+	async ensureControlTable() {
+		if (!this.controlTable) {
+			const { AtscriptControl } = await import("./control_as-bjmwe24C.mjs");
+			this.controlTable = this.space.getTable(AtscriptControl);
+		}
+		await this.controlTable.ensureTable();
+	}
+	async readControlValue(_id) {
+		const row = await this.controlTable.findOne({
+			filter: { _id: { $eq: _id } },
+			controls: {}
+		});
+		return row?.value ?? null;
+	}
+	async writeControlValue(_id, value) {
+		const existing = await this.readControlValue(_id);
+		if (existing !== null) await this.controlTable.replaceOne({
+			_id,
+			value
+		});
+else await this.controlTable.insertOne({
+			_id,
+			value
+		});
+	}
+	async readHash() {
+		return this.readControlValue("schema_version");
+	}
+	async writeHash(hash) {
+		await this.writeControlValue("schema_version", hash);
+	}
+	async readTableSnapshot(tableName, _asView) {
+		const value = await this.readControlValue(`table_snapshot:${tableName}`);
+		return value ? JSON.parse(value) : null;
+	}
+	async writeTableSnapshot(tableName, snapshot) {
+		await this.writeControlValue(`table_snapshot:${tableName}`, JSON.stringify(snapshot));
+	}
+	async deleteTableSnapshot(tableName) {
+		try {
+			await this.controlTable.deleteOne(`table_snapshot:${tableName}`);
+		} catch {}
+	}
+	async readTrackedList() {
+		const value = await this.readControlValue("synced_tables");
+		if (!value) return [];
+		const parsed = JSON.parse(value);
+		if (Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0] === "string") return parsed.map((name) => ({
+			name,
+			isView: false
+		}));
+		return parsed.map((e) => ({
+			...e,
+			viewType: e.viewType ?? (e.isView ? "V" : undefined)
+		}));
+	}
+	async writeTrackedList(readables) {
+		const entries = readables.map((r) => {
+			const isView = r.isView;
+			let viewType;
+			if (isView) {
+				const view = r;
+				viewType = view.isExternal ? "E" : view.viewPlan.materialized ? "M" : "V";
+			}
+			return {
+				name: r.tableName,
+				isView,
+				viewType
+			};
+		});
+		entries.sort((a, b) => a.name.localeCompare(b.name));
+		await this.writeControlValue("synced_tables", JSON.stringify(entries));
+	}
+	async tryAcquireLock(podId, ttlMs) {
+		const now = Date.now();
+		const existing = await this.controlTable.findOne({
+			filter: { _id: { $eq: "sync_lock" } },
+			controls: {}
+		});
+		if (existing) {
+			const expiresAt = existing.expiresAt;
+			if (expiresAt && expiresAt < now) await this.controlTable.deleteOne("sync_lock");
+else return false;
+		}
+		try {
+			await this.controlTable.insertOne({
+				_id: "sync_lock",
+				lockedBy: podId,
+				lockedAt: now,
+				expiresAt: now + ttlMs
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async refreshLock(podId, ttlMs) {
+		const existing = await this.controlTable.findOne({
+			filter: { _id: { $eq: "sync_lock" } },
+			controls: {}
+		});
+		if (!existing) return "missing";
+		if (existing.lockedBy !== podId) return "stolen";
+		await this.controlTable.replaceOne({
+			_id: "sync_lock",
+			lockedBy: podId,
+			lockedAt: existing.lockedAt,
+			expiresAt: Date.now() + ttlMs
+		});
+		return "refreshed";
+	}
+	async releaseLock(podId) {
+		try {
+			const existing = await this.controlTable.findOne({
+				filter: { _id: { $eq: "sync_lock" } },
+				controls: {}
+			});
+			if (existing && existing.lockedBy === podId) await this.controlTable.deleteOne("sync_lock");
+		} catch {}
+	}
+	async waitForLock(timeoutMs, pollIntervalMs) {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			const lock = await this.controlTable.findOne({
+				filter: { _id: { $eq: "sync_lock" } },
+				controls: {}
+			});
+			if (!lock) return;
+			const expiresAt = lock.expiresAt;
+			if (expiresAt && expiresAt < Date.now()) {
+				await this.controlTable.deleteOne("sync_lock");
+				return;
+			}
+			await new Promise((resolve) => {
+				setTimeout(resolve, pollIntervalMs);
+			});
+		}
+		throw new Error(`Schema sync lock wait timed out after ${timeoutMs}ms`);
+	}
+	constructor(space) {
+		_define_property$2(this, "space", void 0);
+		_define_property$2(this, "controlTable", void 0);
+		this.space = space;
+	}
+};
+async function readStoredSnapshot(space, tableName, _asView) {
+	const { AtscriptControl } = await import("./control_as-bjmwe24C.mjs");
+	const table = space.getTable(AtscriptControl);
+	await table.ensureTable();
+	const row = await table.findOne({
+		filter: { _id: { $eq: `table_snapshot:${tableName}` } },
+		controls: {}
+	});
+	const value = row?.value ?? null;
+	return value ? JSON.parse(value) : null;
+}
+
+//#endregion
+//#region packages/db/src/schema/sync-entry.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const noColor = {
+	green: (s) => s,
+	red: (s) => s,
+	cyan: (s) => s,
+	yellow: (s) => s,
+	bold: (s) => s,
+	dim: (s) => s,
+	underline: (s) => s
+};
+var SyncEntry = class {
+	/** Whether this entry involves destructive operations */ get destructive() {
+		if (this.status === "drop") return this.viewType !== "V" && this.viewType !== "E";
+		return this.columnsToDrop.length > 0 || this.typeChanges.length > 0 || this.recreated || this.optionChanges.some((c) => c.destructive);
+	}
+	/** Whether this entry represents any change (not in-sync) */ get hasChanges() {
+		return this.status !== "in-sync" && this.status !== "error";
+	}
+	/** Whether this entry has errors */ get hasErrors() {
+		return this.status === "error" || this.errors.length > 0;
+	}
+	/** Render this entry for display */ print(mode, colors) {
+		const c = colors ?? noColor;
+		return mode === "plan" ? this.printPlan(c) : this.printResult(c);
+	}
+	labelAndPrefix(c) {
+		return {
+			label: c.bold(c.underline(this.name)),
+			vp: this.viewType ? `${c.dim(`[${this.viewType}]`)} ` : ""
+		};
+	}
+	printError(c, label, vp) {
+		return [`  ${c.red(`✗ ${vp}${label} — error`)}`, ...this.errors.map((err) => `      ${c.red(err)}`)];
+	}
+	printPlan(c) {
+		const { label, vp } = this.labelAndPrefix(c);
+		if (this.status === "error") return this.printError(c, label, vp);
+		if (this.status === "drop") {
+			const kind = this.viewType ? "drop view" : "drop table";
+			return [`  ${c.red(`- ${vp}${label} — ${kind}`)}`];
+		}
+		if (this.status === "create") return [
+			`  ${c.green(`+ ${vp}${label} — create`)}`,
+			...this.columnsToAdd.map((col) => `      ${c.green(`+ ${col.physicalName} (${col.designType})${col.isPrimaryKey ? " PK" : ""}${col.optional ? " nullable" : ""} — add`)}`),
+			""
+		];
+		if (this.status === "alter") {
+			const renameInfo = this.renamedFrom ? ` ${c.yellow(`(renamed from ${this.renamedFrom})`)}` : "";
+			return [
+				`  ${c.cyan(`~ ${vp}${label} — alter${renameInfo}`)}`,
+				...this.columnsToAdd.map((col) => `      ${c.green(`+ ${col.physicalName} (${col.designType}) — add`)}`),
+				...this.columnsToRename.map((r) => `      ${c.yellow(`~ ${r.from} → ${r.to} — rename`)}`),
+				...this.typeChanges.map((tc) => {
+					const action = this.syncMethod ? ` — ${this.syncMethod}` : " — requires migration";
+					return `      ${c.red(`! ${tc.column}: ${tc.fromType} → ${tc.toType}${action}`)}`;
+				}),
+				...this.nullableChanges.map((nc) => `      ${c.yellow(`~ ${nc.column} — ${nc.toNullable ? "nullable" : "non-nullable"}`)}`),
+				...this.defaultChanges.map((dc) => `      ${c.yellow(`~ ${dc.column} — default ${dc.oldDefault ?? "none"} → ${dc.newDefault ?? "none"}`)}`),
+				...this.columnsToDrop.map((col) => `      ${c.red(`- ${col} — drop`)}`),
+				...this.optionChanges.map((oc) => {
+					const tag = oc.destructive ? c.red("!") : c.yellow("~");
+					const action = oc.destructive ? " — requires recreation" : "";
+					return `      ${tag} ${c.cyan(`option ${oc.key}`)}: ${oc.oldValue} → ${oc.newValue}${action}`;
+				}),
+				...this.fkAdded.map((fk) => `      ${c.green(`+ FK(${fk.fields.join(",")}) → ${fk.targetTable} — add`)}`),
+				...this.fkRemoved.map((fk) => `      ${c.red(`- FK(${fk.fields.join(",")}) → ${fk.targetTable} — remove`)}`),
+				...this.fkChanged.map((fk) => `      ${c.yellow(`~ FK(${fk.fields.join(",")}) → ${fk.targetTable} — ${fk.details}`)}`),
+				""
+			];
+		}
+		return [this.printInSync(c)];
+	}
+	printResult(c) {
+		const { label, vp } = this.labelAndPrefix(c);
+		if (this.status === "error") return this.printError(c, label, vp);
+		if (this.status === "drop") {
+			const kind = this.viewType ? "dropped view" : "dropped table";
+			return [`  ${c.red(`- ${vp}${label} — ${kind}`)}`];
+		}
+		if (this.status === "create") return [
+			`  ${c.green(`+ ${vp}${label} — created`)}`,
+			...this.columnsAdded.map((col) => `      ${c.green(`+ ${col} — added`)}`),
+			""
+		];
+		const hasChanges = this.columnsAdded.length > 0 || this.columnsRenamed.length > 0 || this.columnsDropped.length > 0 || this.optionChanges.length > 0;
+		if (hasChanges || this.recreated || this.renamedFrom) {
+			const rlabel = this.recreated ? "recreated" : "altered";
+			const renameInfo = this.renamedFrom ? ` ${c.yellow(`(renamed from ${this.renamedFrom})`)}` : "";
+			const color = this.recreated ? c.yellow : c.cyan;
+			return [
+				`  ${color(`~ ${vp}${label} — ${rlabel}${renameInfo}`)}`,
+				...this.columnsAdded.map((col) => `      ${c.green(`+ ${col} — added`)}`),
+				...this.columnsRenamed.map((col) => `      ${c.yellow(`~ ${col} — renamed`)}`),
+				...this.columnsDropped.map((col) => `      ${c.red(`- ${col} — dropped`)}`),
+				...this.optionChanges.map((oc) => `      ${c.cyan(`~ option ${oc.key}: ${oc.oldValue} → ${oc.newValue}`)}`),
+				""
+			];
+		}
+		const lines = [this.printInSync(c)];
+		if (this.errors.length > 0) lines.push(...this.errors.map((err) => `    ${c.red(`Error: ${err}`)}`));
+		return lines;
+	}
+	printInSync(c) {
+		const prefix = this.viewType ? `${c.dim(`[${this.viewType}]`)} ` : "";
+		return `  ${c.green("✓")} ${prefix}${c.bold(this.name)} ${c.dim("— in sync")}`;
+	}
+	constructor(init) {
+		_define_property$1(this, "name", void 0);
+		/** 'V' = virtual view, 'M' = materialized view, 'E' = external view, undefined = table */ _define_property$1(this, "viewType", void 0);
+		_define_property$1(this, "status", void 0);
+		_define_property$1(this, "syncMethod", void 0);
+		_define_property$1(this, "columnsToAdd", void 0);
+		_define_property$1(this, "columnsToRename", void 0);
+		_define_property$1(this, "typeChanges", void 0);
+		_define_property$1(this, "nullableChanges", void 0);
+		_define_property$1(this, "defaultChanges", void 0);
+		_define_property$1(this, "columnsToDrop", void 0);
+		_define_property$1(this, "optionChanges", void 0);
+		_define_property$1(this, "fkAdded", void 0);
+		_define_property$1(this, "fkRemoved", void 0);
+		_define_property$1(this, "fkChanged", void 0);
+		_define_property$1(this, "columnsAdded", void 0);
+		_define_property$1(this, "columnsRenamed", void 0);
+		_define_property$1(this, "columnsDropped", void 0);
+		_define_property$1(this, "recreated", void 0);
+		_define_property$1(this, "errors", void 0);
+		_define_property$1(this, "renamedFrom", void 0);
+		this.name = init.name;
+		this.viewType = init.viewType;
+		this.status = init.status;
+		this.syncMethod = init.syncMethod;
+		this.columnsToAdd = init.columnsToAdd ?? [];
+		this.columnsToRename = init.columnsToRename ?? [];
+		this.typeChanges = init.typeChanges ?? [];
+		this.nullableChanges = init.nullableChanges ?? [];
+		this.defaultChanges = init.defaultChanges ?? [];
+		this.columnsToDrop = init.columnsToDrop ?? [];
+		this.optionChanges = init.optionChanges ?? [];
+		this.fkAdded = init.fkAdded ?? [];
+		this.fkRemoved = init.fkRemoved ?? [];
+		this.fkChanged = init.fkChanged ?? [];
+		this.columnsAdded = init.columnsAdded ?? [];
+		this.columnsRenamed = init.columnsRenamed ?? [];
+		this.columnsDropped = init.columnsDropped ?? [];
+		this.recreated = init.recreated ?? false;
+		this.errors = init.errors ?? [];
+		this.renamedFrom = init.renamedFrom;
+	}
+};
+
+//#endregion
+//#region packages/db/src/schema/sync-executor.ts
+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;
+}
+async function executeSyncTable(readable, safe, trackedNames, deps) {
+	const adapter = readable.dbAdapter;
+	const name = readable.tableName;
+	const init = {
+		name,
+		status: "in-sync",
+		syncMethod: readable.syncMethod
+	};
+	if (readable.renamedFrom && trackedNames.has(readable.renamedFrom) && adapter.renameTable) {
+		await adapter.renameTable(readable.renamedFrom);
+		init.renamedFrom = readable.renamedFrom;
+		init.status = "alter";
+	}
+	let fkDiff;
+	const fkSnapshotName = init.renamedFrom ?? name;
+	const storedSnapshot = await deps.store.readTableSnapshot(fkSnapshotName);
+	if (storedSnapshot) fkDiff = computeForeignKeyDiff(readable.foreignKeys, storedSnapshot.foreignKeys);
+	const hasFkChanges = fkDiff ? hasForeignKeyChanges(fkDiff) : false;
+	if (adapter.getExistingColumns && adapter.syncColumns) {
+		const existing = await adapter.getExistingColumns();
+		if (existing.length === 0 && !init.renamedFrom) {
+			await adapter.ensureTable();
+			init.status = "create";
+		} else if (existing.length > 0) if (hasFkChanges && !init.recreated && !adapter.syncForeignKeys && adapter.recreateTable) {
+			await adapter.recreateTable();
+			init.recreated = true;
+			init.status = "alter";
+		} else {
+			if (hasFkChanges && fkDiff && adapter.dropForeignKeys) {
+				const keysToDrop = [...fkDiff.removed.map((fk) => fkKey(fk.fields)), ...fkDiff.changed.map((fk) => fkKey(fk.desired.fields))];
+				if (keysToDrop.length > 0) {
+					await adapter.dropForeignKeys(keysToDrop);
+					init.status = "alter";
+				}
+			}
+			const typeMapper = adapter.typeMapper?.bind(adapter);
+			const diff = computeColumnDiff(readable.fieldDescriptors, existing, typeMapper);
+			await applyColumnDiff(adapter, readable, diff, init, safe, deps.logger);
+		}
+	} else if (adapter.syncColumns) if (!storedSnapshot) {
+		const existed = adapter.tableExists ? await adapter.tableExists() : false;
+		await adapter.ensureTable();
+		if (!existed) init.status = "create";
+	} else {
+		const existing = snapshotToExistingColumns(storedSnapshot);
+		const diff = computeColumnDiff(readable.fieldDescriptors, existing, deps.resolveTypeMapper(adapter));
+		await applyColumnDiff(adapter, readable, diff, init, safe, deps.logger);
+	}
+else {
+		const existed = adapter.tableExists ? await adapter.tableExists() : true;
+		if (!init.recreated) {
+			await adapter.ensureTable();
+			if (!existed) init.status = "create";
+		}
+	}
+	if (init.status !== "create" && !init.recreated && !safe) {
+		const optionDiff = await deps.diffTableOptions(readable);
+		if (optionDiff && optionDiff.changed.length > 0) {
+			init.optionChanges = optionDiff.changed;
+			const hasDestructive = optionDiff.changed.some((c) => c.destructive);
+			const nonDestructive = optionDiff.changed.filter((c) => !c.destructive);
+			if (nonDestructive.length > 0 && adapter.applyTableOptions) {
+				await adapter.applyTableOptions(nonDestructive);
+				init.status = "alter";
+			}
+			if (hasDestructive) {
+				const syncMethod = readable.syncMethod;
+				if (syncMethod === "recreate" && adapter.recreateTable) {
+					deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — recreating with data preservation`);
+					await adapter.recreateTable();
+					init.status = "alter";
+					init.recreated = true;
+				} else if (adapter.dropTable) {
+					deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — dropping and recreating`);
+					await adapter.dropTable();
+					await adapter.ensureTable();
+					init.status = "alter";
+					init.recreated = true;
+				}
+			}
+		}
+	}
+	await adapter.syncIndexes();
+	if (adapter.syncForeignKeys) await adapter.syncForeignKeys();
+	if (adapter.afterSyncTable) await adapter.afterSyncTable();
+	return new SyncEntry(init);
+}
+async function executeSyncView(view, trackedNames, deps) {
+	const renamedFrom = view.renamedFrom;
+	const isRenamed = renamedFrom && trackedNames.has(renamedFrom);
+	if (isRenamed) await deps.space.dropViewByName(renamedFrom);
+	let definitionChanged = false;
+	if (!isRenamed && trackedNames.has(view.tableName)) {
+		definitionChanged = await viewDefinitionChanged(view, deps.store);
+		if (definitionChanged) await deps.space.dropViewByName(view.tableName);
+	}
+	await view.dbAdapter.ensureTable();
+	const viewType = view.viewPlan.materialized ? "M" : "V";
+	let status;
+	if (isRenamed || definitionChanged) status = "alter";
+else if (trackedNames.has(view.tableName)) status = "in-sync";
+else status = "create";
+	return new SyncEntry({
+		name: view.tableName,
+		status,
+		viewType,
+		renamedFrom: isRenamed ? renamedFrom : undefined,
+		recreated: definitionChanged || undefined
+	});
+}
+async function applyColumnDiff(adapter, readable, diff, init, safe, logger) {
+	const name = readable.tableName;
+	if (diff.conflicts.length > 0) {
+		const errors = diff.conflicts.map((c) => `Column rename conflict on ${name}: cannot rename "${c.oldName}" → "${c.field.physicalName}" because "${c.conflictsWith}" already exists.`);
+		for (const msg of errors) logger.error?.(`[schema-sync] ${msg}`);
+		init.errors = [...init.errors ?? [], ...errors];
+		init.status = "error";
+	}
+	let needsSyncColumns = false;
+	if (diff.typeChanged.length > 0 && init.status !== "error") {
+		const syncMethod = readable.syncMethod;
+		if (syncMethod === "drop" && adapter.dropTable) {
+			await adapter.dropTable();
+			await adapter.ensureTable();
+			init.recreated = true;
+			init.status = "alter";
+		} else if (syncMethod === "recreate" && adapter.recreateTable) {
+			await adapter.recreateTable();
+			init.recreated = true;
+			init.status = "alter";
+		} else if (adapter.supportsColumnModify && adapter.syncColumns) {
+			needsSyncColumns = true;
+			init.status = "alter";
+		} else {
+			const errors = [];
+			for (const change of diff.typeChanged) {
+				const msg = `Type change on ${name}.${change.field.physicalName} ` + `(${change.existingType} → ${change.field.designType}). ` + `Add @db.sync.method "recreate" or "drop", or migrate manually.`;
+				logger.error?.(`[schema-sync] ${msg}`);
+				errors.push(msg);
+			}
+			init.errors = errors;
+			init.status = "error";
+		}
+	}
+	if (!safe && !init.recreated && init.status !== "error" && (diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0)) if (adapter.supportsColumnModify && adapter.syncColumns) {
+		needsSyncColumns = true;
+		init.status = "alter";
+	} else if (adapter.recreateTable) {
+		await adapter.recreateTable();
+		init.recreated = true;
+		init.status = "alter";
+	} else init.status = "alter";
+else if (diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0) init.status = "alter";
+	if (!init.recreated && init.status !== "error" && (diff.added.length > 0 || diff.renamed.length > 0 || needsSyncColumns) && adapter.syncColumns) {
+		const syncResult = await adapter.syncColumns(diff);
+		init.columnsAdded = syncResult.added;
+		init.columnsRenamed = syncResult.renamed;
+		if (syncResult.added.length > 0 || (syncResult.renamed?.length ?? 0) > 0 || needsSyncColumns) init.status = "alter";
+	}
+	if (!safe && !init.recreated && init.status !== "error" && diff.removed.length > 0 && adapter.dropColumns) {
+		const colNames = diff.removed.map((c) => c.name);
+		await adapter.dropColumns(colNames);
+		init.columnsDropped = colNames;
+		init.status = "alter";
+	}
+}
+
+//#endregion
+//#region packages/db/src/schema/schema-sync.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+/** Builds a human-readable description of what changed in an FK constraint. */ function buildFkChangeDetails(desired, existing) {
+	const parts = [];
+	if (existing.targetTable !== desired.targetTable) parts.push(`retarget ${existing.targetTable} → ${desired.targetTable}`);
+	if ([...existing.targetFields].sort().join(",") !== [...desired.targetFields].sort().join(",")) parts.push(`fields ${existing.targetFields.join(",")} → ${desired.targetFields.join(",")}`);
+	if ((existing.onDelete ?? undefined) !== (desired.onDelete ?? undefined)) parts.push(`onDelete ${existing.onDelete ?? "noAction"} → ${desired.onDelete ?? "noAction"}`);
+	if ((existing.onUpdate ?? undefined) !== (desired.onUpdate ?? undefined)) parts.push(`onUpdate ${existing.onUpdate ?? "noAction"} → ${desired.onUpdate ?? "noAction"}`);
+	return parts.join(", ");
+}
+var SchemaSync = class {
+	/**
+	* Resolves types into categorized readables and computes the schema hash.
+	* Passes each adapter's typeMapper for precise type tracking in snapshots.
+	*/ async resolveAndHash(types) {
+		const tables = [];
+		const views = [];
+		const externalViews = [];
+		for (const type of types) {
+			const readable = this.space.get(type);
+			if (readable.isView) {
+				const view = readable;
+				if (view.isExternal) externalViews.push(view);
+else views.push(readable);
+			} else tables.push(readable);
+		}
+		const allReadables = [
+			...tables,
+			...views,
+			...externalViews
+		];
+		const snapshots = allReadables.map((r) => {
+			if (r.isView) return computeViewSnapshot(r);
+			const tm = r.dbAdapter.typeMapper?.bind(r.dbAdapter);
+			const opts = (r.fieldDescriptors, r.dbAdapter.getDesiredTableOptions?.());
+			return computeTableSnapshot(r, tm, opts);
+		});
+		const hash = computeSchemaHash(snapshots);
+		return {
+			tables,
+			views,
+			externalViews,
+			hash
+		};
+	}
+	/**
+	* Checks an external view: verifies it exists in the DB and columns match.
+	* Returns a SyncEntry with status 'in-sync' or 'error'.
+	*/ async checkExternalView(view) {
+		const adapter = view.dbAdapter;
+		const name = view.tableName;
+		if (adapter.getExistingColumns) {
+			const existing = await adapter.getExistingColumns();
+			if (existing.length === 0) return new SyncEntry({
+				name,
+				viewType: "E",
+				status: "error",
+				errors: [`External view "${name}" not found in the database`]
+			});
+			const existingNames = new Set(existing.map((c) => c.name));
+			const missing = view.fieldDescriptors.filter((f) => !f.ignored && !existingNames.has(f.physicalName)).map((f) => f.physicalName);
+			if (missing.length > 0) return new SyncEntry({
+				name,
+				viewType: "E",
+				status: "error",
+				errors: [`External view "${name}" is missing columns: ${missing.join(", ")}`]
+			});
+		} else if (adapter.tableExists) {
+			const exists = await adapter.tableExists();
+			if (!exists) return new SyncEntry({
+				name,
+				viewType: "E",
+				status: "error",
+				errors: [`External view "${name}" not found in the database`]
+			});
+		}
+		return new SyncEntry({
+			name,
+			viewType: "E",
+			status: "in-sync"
+		});
+	}
+	/**
+	* Detects tables/views present in the previous sync but absent from the current schema.
+	* Returns SyncEntry instances with status 'drop'.
+	*/ async detectRemoved(currentReadables, previous) {
+		previous ?? (previous = await this.store.readTrackedList());
+		const currentSet = new Set(currentReadables.map((t) => t.tableName));
+		const renameFromSet = new Set(currentReadables.map((r) => r.renamedFrom).filter(Boolean));
+		const removed = [];
+		for (const entry of previous) if (!currentSet.has(entry.name) && !renameFromSet.has(entry.name)) removed.push(new SyncEntry({
+			name: entry.name,
+			viewType: entry.viewType,
+			status: "drop"
+		}));
+		return removed;
+	}
+	/**
+	* Starts a periodic heartbeat that extends the lock's TTL while sync runs.
+	* Returns a handle with `stop()` to cancel and `getAbortReason()` to check
+	* whether the lock was stolen or unexpectedly removed.
+	*/ startHeartbeat(podId, ttlMs) {
+		let abortReason;
+		let stopped = false;
+		const intervalMs = Math.max(Math.floor(ttlMs / 3), 1e3);
+		const timer = setInterval(async () => {
+			if (stopped) return;
+			try {
+				const status = await this.store.refreshLock(podId, ttlMs);
+				if (stopped) return;
+				if (status === "stolen") {
+					abortReason = "Schema sync lock was stolen by another pod";
+					this.logger.warn("[schema-sync] Lock stolen by another pod — aborting after current operation");
+				} else if (status === "missing") {
+					abortReason = "Schema sync lock was unexpectedly removed";
+					this.logger.warn("[schema-sync] Lock row missing — aborting after current operation");
+				}
+			} catch (error) {
+				if (stopped) return;
+				this.logger.warn("[schema-sync] Failed to refresh lock heartbeat (will retry):", error instanceof Error ? error.message : error);
+			}
+		}, intervalMs);
+		if (typeof timer === "object" && "unref" in timer) timer.unref();
+		return {
+			stop() {
+				stopped = true;
+				clearInterval(timer);
+			},
+			getAbortReason: () => abortReason
+		};
+	}
+	/** Throws if the heartbeat detected a stolen/missing lock. */ assertLockHeld(getAbortReason) {
+		const reason = getAbortReason();
+		if (reason) throw new Error(reason);
+	}
+	/**
+	* Runs schema synchronization with distributed locking.
+	*/ async run(types, opts) {
+		const podId = opts?.podId ?? crypto.randomUUID();
+		const lockTtlMs = opts?.lockTtlMs ?? 3e4;
+		const waitTimeoutMs = opts?.waitTimeoutMs ?? 6e4;
+		const pollIntervalMs = opts?.pollIntervalMs ?? 500;
+		const force = opts?.force ?? false;
+		const safe = opts?.safe ?? false;
+		const { tables, views, externalViews, hash } = await this.resolveAndHash(types);
+		await this.store.ensureControlTable();
+		if (!force) {
+			const storedHash = await this.store.readHash();
+			if (storedHash === hash) return {
+				status: "up-to-date",
+				schemaHash: hash,
+				entries: []
+			};
+		}
+		const acquired = await this.store.tryAcquireLock(podId, lockTtlMs);
+		if (!acquired) {
+			await this.store.waitForLock(waitTimeoutMs, pollIntervalMs);
+			const storedHash = await this.store.readHash();
+			if (storedHash === hash) return {
+				status: "synced-by-peer",
+				schemaHash: hash,
+				entries: []
+			};
+			const retryAcquired = await this.store.tryAcquireLock(podId, lockTtlMs);
+			if (!retryAcquired) throw new Error("Failed to acquire schema sync lock after waiting");
+		}
+		const heartbeat = this.startHeartbeat(podId, lockTtlMs);
+		try {
+			if (!force) {
+				const storedHash = await this.store.readHash();
+				if (storedHash === hash) return {
+					status: "synced-by-peer",
+					schemaHash: hash,
+					entries: []
+				};
+			}
+			const allReadables = [
+				...tables,
+				...views,
+				...externalViews
+			];
+			const previouslyTracked = await this.store.readTrackedList();
+			const trackedNames = new Set(previouslyTracked.map((e) => e.name));
+			const deps = this.buildExecutorDeps();
+			const entries = [];
+			for (const readable of tables) {
+				this.assertLockHeld(heartbeat.getAbortReason);
+				entries.push(await executeSyncTable(readable, safe, trackedNames, deps));
+			}
+			this.assertLockHeld(heartbeat.getAbortReason);
+			const removed = await this.detectRemoved(allReadables, previouslyTracked);
+			for (const readable of views) {
+				this.assertLockHeld(heartbeat.getAbortReason);
+				entries.push(await executeSyncView(readable, trackedNames, deps));
+			}
+			const externalEntries = await Promise.all(externalViews.map((v) => this.checkExternalView(v)));
+			entries.push(...externalEntries);
+			this.assertLockHeld(heartbeat.getAbortReason);
+			if (!safe) {
+				for (const entry of removed) {
+					if (entry.viewType === "E") continue;
+					if (entry.viewType) await this.space.dropViewByName(entry.name);
+else await this.space.dropTableByName(entry.name);
+				}
+				entries.push(...removed.filter((e) => e.viewType !== "E"));
+			}
+			this.assertLockHeld(heartbeat.getAbortReason);
+			for (const readable of allReadables) {
+				const adapter = readable.dbAdapter;
+				const tm = adapter.typeMapper?.bind(adapter);
+				const opts$1 = adapter.getDesiredTableOptions?.();
+				const snapshot = readable.isView ? computeViewSnapshot(readable) : computeTableSnapshot(readable, tm, opts$1);
+				await this.store.writeTableSnapshot(readable.tableName, snapshot);
+			}
+			if (!safe) for (const entry of removed) {
+				if (entry.viewType === "E") continue;
+				await this.store.deleteTableSnapshot(entry.name);
+			}
+			for (const readable of allReadables) if (readable.renamedFrom) await this.store.deleteTableSnapshot(readable.renamedFrom);
+			await this.store.writeTrackedList(allReadables);
+			await this.store.writeHash(hash);
+			return {
+				status: "synced",
+				schemaHash: hash,
+				entries
+			};
+		} finally {
+			heartbeat.stop();
+			await this.store.releaseLock(podId);
+		}
+	}
+	/**
+	* Computes a dry-run plan showing what `run()` would do, without executing any DDL.
+	*/ async plan(types, opts) {
+		const force = opts?.force ?? false;
+		const safe = opts?.safe ?? false;
+		const { tables, views, externalViews, hash } = await this.resolveAndHash(types);
+		const allReadables = [
+			...tables,
+			...views,
+			...externalViews
+		];
+		await this.store.ensureControlTable();
+		const previouslyTracked = await this.store.readTrackedList();
+		const trackedNames = new Set(previouslyTracked.map((e) => e.name));
+		let planEntries = await Promise.all(tables.map((r) => this.planTable(r, trackedNames)));
+		const viewEntries = await Promise.all(views.map((v) => this.planView(v, trackedNames)));
+		const externalEntries = await Promise.all(externalViews.map((v) => this.checkExternalView(v)));
+		if (!force) {
+			const storedHash = await this.store.readHash();
+			if (storedHash === hash) return {
+				status: "up-to-date",
+				schemaHash: hash,
+				entries: [
+					...planEntries,
+					...viewEntries,
+					...externalEntries
+				]
+			};
+		}
+		let removed = await this.detectRemoved(allReadables, previouslyTracked);
+		if (safe) {
+			planEntries = planEntries.map((e) => new SyncEntry({
+				...e,
+				columnsToDrop: [],
+				typeChanges: [],
+				recreated: false
+			}));
+			removed = [];
+		}
+		removed = removed.filter((e) => e.viewType !== "E");
+		return {
+			status: "changes-needed",
+			schemaHash: hash,
+			entries: [
+				...planEntries,
+				...viewEntries,
+				...externalEntries,
+				...removed
+			]
+		};
+	}
+	/** Fallback typeMapper for snapshot-based Path B: compares designType directly, skips unions. */ resolveTypeMapper(adapter) {
+		return adapter.typeMapper?.bind(adapter) ?? ((f) => f.designType === "union" ? "union" : f.designType);
+	}
+	async planTable(readable, trackedNames) {
+		const adapter = readable.dbAdapter;
+		const name = readable.tableName;
+		const init = {
+			name,
+			status: "in-sync",
+			syncMethod: readable.syncMethod
+		};
+		const renamedFrom = readable.renamedFrom;
+		const pendingRename = renamedFrom && trackedNames.has(renamedFrom);
+		if (pendingRename) {
+			init.renamedFrom = renamedFrom;
+			init.status = "alter";
+		}
+		const fkSnapshotName = pendingRename ? renamedFrom : name;
+		const storedSnapshot = await this.store.readTableSnapshot(fkSnapshotName);
+		if (adapter.getExistingColumns) {
+			const existing = pendingRename && adapter.getExistingColumnsForTable ? await adapter.getExistingColumnsForTable(renamedFrom) : await adapter.getExistingColumns();
+			if (existing.length === 0 && !pendingRename) {
+				init.status = "create";
+				init.columnsToAdd = readable.fieldDescriptors.filter((f) => !f.ignored);
+			} else if (existing.length > 0) {
+				const typeMapper = adapter.typeMapper?.bind(adapter);
+				const diff = computeColumnDiff(readable.fieldDescriptors, existing, typeMapper);
+				this.populatePlanFromDiff(diff, init, name, readable.syncMethod, adapter.supportsColumnModify);
+			}
+		} else if (adapter.syncColumns) if (!storedSnapshot) {
+			if (!pendingRename) {
+				const exists = adapter.tableExists ? await adapter.tableExists() : false;
+				if (!exists) {
+					init.status = "create";
+					init.columnsToAdd = readable.fieldDescriptors.filter((f) => !f.ignored);
+				}
+			}
+		} else {
+			const existing = snapshotToExistingColumns(storedSnapshot);
+			const diff = computeColumnDiff(readable.fieldDescriptors, existing, this.resolveTypeMapper(adapter));
+			this.populatePlanFromDiff(diff, init, name, readable.syncMethod, adapter.supportsColumnModify);
+		}
+else if (adapter.tableExists) {
+			const exists = await adapter.tableExists();
+			if (!exists) init.status = "create";
+		} else init.status = "create";
+		if (init.status !== "create") {
+			const optionDiff = await this.diffTableOptions(readable);
+			if (optionDiff && optionDiff.changed.length > 0) {
+				init.status = "alter";
+				init.optionChanges = optionDiff.changed;
+				if (optionDiff.changed.some((c) => c.destructive)) init.recreated = true;
+			}
+		}
+		if (init.status !== "create" && storedSnapshot) {
+			const fkDiff = computeForeignKeyDiff(readable.foreignKeys, storedSnapshot.foreignKeys);
+			if (hasForeignKeyChanges(fkDiff)) {
+				init.status = "alter";
+				init.fkAdded = fkDiff.added.map((fk) => ({
+					fields: fk.fields,
+					targetTable: fk.targetTable
+				}));
+				init.fkRemoved = fkDiff.removed.map((fk) => ({
+					fields: fk.fields,
+					targetTable: fk.targetTable
+				}));
+				init.fkChanged = fkDiff.changed.map((fk) => ({
+					fields: fk.desired.fields,
+					targetTable: fk.desired.targetTable,
+					details: buildFkChangeDetails(fk.desired, fk.existing)
+				}));
+			}
+		}
+		return new SyncEntry(init);
+	}
+	/**
+	* Populates plan init from a column diff (shared by Path A and Path B).
+	*/ populatePlanFromDiff(diff, init, name, syncMethod, adapterSupportsModify) {
+		init.columnsToAdd = diff.added;
+		init.columnsToRename = diff.renamed.map((r) => ({
+			from: r.oldName,
+			to: r.field.physicalName
+		}));
+		init.typeChanges = diff.typeChanged.map((tc) => ({
+			column: tc.field.physicalName,
+			fromType: tc.existingType,
+			toType: tc.field.designType
+		}));
+		init.nullableChanges = diff.nullableChanged.map((nc) => ({
+			column: nc.field.physicalName,
+			toNullable: nc.field.optional
+		}));
+		init.defaultChanges = diff.defaultChanged.map((dc) => ({
+			column: dc.field.physicalName,
+			oldDefault: dc.oldDefault,
+			newDefault: dc.newDefault
+		}));
+		init.columnsToDrop = diff.removed.map((c) => c.name);
+		const hasChanges = diff.added.length > 0 || diff.renamed.length > 0 || diff.typeChanged.length > 0 || diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0 || diff.removed.length > 0;
+		if (hasChanges) init.status = "alter";
+		if (diff.conflicts.length > 0) {
+			init.status = "error";
+			init.errors = [...init.errors ?? [], ...diff.conflicts.map((c) => `Column rename conflict on ${name}: cannot rename "${c.oldName}" → "${c.field.physicalName}" because "${c.conflictsWith}" already exists.`)];
+		}
+		if (diff.typeChanged.length > 0 && !syncMethod && !adapterSupportsModify) {
+			init.status = "error";
+			init.errors = [...init.errors ?? [], ...diff.typeChanged.map((tc) => `Type change on ${name}.${tc.field.physicalName} ` + `(${tc.existingType} → ${tc.field.designType}). ` + `Add @db.sync.method "recreate" or "drop", or migrate manually.`)];
+		}
+	}
+	/**
+	* Computes table option diff using DB-first introspection with snapshot fallback.
+	* Returns null if the adapter has no table options.
+	*/ async diffTableOptions(readable) {
+		const adapter = readable.dbAdapter;
+		const desired = adapter.getDesiredTableOptions?.();
+		if (!desired || desired.length === 0) return null;
+		let existing;
+		if (adapter.getExistingTableOptions) existing = await adapter.getExistingTableOptions();
+else {
+			const snapshot = await this.store.readTableSnapshot(readable.tableName);
+			existing = snapshot ? snapshotToExistingTableOptions(snapshot) : [];
+		}
+		if (existing.length === 0) return null;
+		const destructiveKeys = adapter.destructiveOptionKeys?.();
+		return computeTableOptionDiff(desired, existing, destructiveKeys);
+	}
+	async planView(view, trackedNames) {
+		const viewType = view.viewPlan.materialized ? "M" : "V";
+		const renamedFrom = view.renamedFrom;
+		const isRenamed = renamedFrom && trackedNames.has(renamedFrom);
+		let status;
+		if (isRenamed) status = "alter";
+else if (trackedNames.has(view.tableName)) status = await viewDefinitionChanged(view, this.store) ? "alter" : "in-sync";
+else status = "create";
+		return new SyncEntry({
+			name: view.tableName,
+			status,
+			viewType,
+			renamedFrom: isRenamed ? renamedFrom : undefined,
+			recreated: status === "alter" && !isRenamed ? true : undefined
+		});
+	}
+	buildExecutorDeps() {
+		return {
+			store: this.store,
+			space: this.space,
+			logger: this.logger,
+			resolveTypeMapper: this.resolveTypeMapper.bind(this),
+			diffTableOptions: this.diffTableOptions.bind(this)
+		};
+	}
+	constructor(space, logger) {
+		_define_property(this, "space", void 0);
+		_define_property(this, "store", void 0);
+		_define_property(this, "logger", void 0);
+		this.space = space;
+		this.logger = logger || NoopLogger;
+		this.store = new SyncStore(space);
+	}
+};
+
+//#endregion
+//#region packages/db/src/sync.ts
+async function syncSchema(space, types, opts) {
+	const sync = new SchemaSync(space);
+	return sync.run(types, opts);
+}
+
+//#endregion
+export { SchemaSync, SyncEntry, computeColumnDiff, computeForeignKeyDiff, computeSchemaHash, computeTableHash, computeTableOptionDiff, computeTableSnapshot, computeViewSnapshot, fkKey, hasForeignKeyChanges, readStoredSnapshot, snapshotToExistingColumns, snapshotToExistingTableOptions, syncSchema };