@atscript/db 0.1.38 → 0.1.40

package/dist/sync.mjs

@@ -1,7 +1,7 @@
-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) {
+import { _ as NoopLogger } from "./db-view-ZsoN91-q.mjs";
+//#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,
@@ -13,8 +13,17 @@ import { NoopLogger } from "./logger-B7oxCfLQ.mjs";
 		if (f.defaultValue) snap.defaultValue = f.defaultValue;
 		if (typeMapper) snap.mappedType = typeMapper(f);
 		return snap;
-	}).sort((a, b) => a.physicalName.localeCompare(b.physicalName));
+	}).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) => ({
@@ -24,23 +33,28 @@ function computeTableSnapshot(readable, typeMapper, tableOptions) {
 			name: f.name,
 			sort: f.sort
 		}))
-	})).sort((a, b) => a.key.localeCompare(b.key));
+	})).toSorted((a, b) => a.key.localeCompare(b.key));
 	const foreignKeys = [...readable.foreignKeys.values()].map((fk) => ({
-		fields: [...fk.fields].sort(),
+		fields: [...fk.fields].toSorted(),
 		targetTable: fk.targetTable,
-		targetFields: [...fk.targetFields].sort(),
+		targetFields: [...fk.targetFields].toSorted(),
 		onDelete: fk.onDelete,
 		onUpdate: fk.onUpdate
-	})).sort((a, b) => a.fields.join(",").localeCompare(b.fields.join(",")));
+	})).toSorted((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));
+	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 {
@@ -54,20 +68,35 @@ function computeViewSnapshot(view) {
 		viewType: plan.materialized ? "M" : "V",
 		entryTable: plan.entryTable,
 		joinTables: plan.joins.map((j) => j.targetTable),
-		materialized: plan.materialized || undefined,
+		materialized: plan.materialized || void 0,
 		fields
 	};
 	if (plan.filter) result.filterHash = fnv1a(JSON.stringify(plan.filter, (_, v) => typeof v === "function" ? "[fn]" : v));
 	return result;
 }
+/**
+* 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].sort((a, b) => a.tableName.localeCompare(b.tableName));
-	const json = JSON.stringify(sorted);
-	return fnv1a(json);
+	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,
@@ -77,15 +106,21 @@ function snapshotToExistingColumns(snapshot) {
 		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 undefined;
+	if (!dv) return;
 	if (dv.kind === "value") return dv.value;
 	return `fn:${dv.fn}`;
 }
-/** FNV-1a 32-bit hash → hex string */ function fnv1a(str) {
+/** 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);
@@ -93,13 +128,22 @@ function serializeDefaultValue(dv) {
 	}
 	return Math.trunc(hash).toString(16).padStart(8, "0");
 }
-
 //#endregion
-//#region packages/db/src/schema/column-diff.ts
+//#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 = new Map();
-	const renamedOldNames = new Set();
+	const desiredByName = /* @__PURE__ */ new Map();
+	const renamedOldNames = /* @__PURE__ */ new Set();
 	const added = [];
 	const renamed = [];
 	const typeChanged = [];
@@ -119,8 +163,7 @@ function computeColumnDiff(desired, existing, typeMapper) {
 			renamedOldNames.add(field.renamedFrom);
 		} else {
 			if (typeMapper) {
-				const expectedType = typeMapper(field);
-				if (expectedType.toUpperCase() !== existingCol.type.toUpperCase()) typeChanged.push({
+				if (typeMapper(field).toUpperCase() !== existingCol.type.toUpperCase()) typeChanged.push({
 					field,
 					existingType: existingCol.type
 				});
@@ -133,13 +176,13 @@ function computeColumnDiff(desired, existing, typeMapper) {
 				});
 			}
 			const desiredDefault = serializeDefaultValue(field.defaultValue);
-			if (existingCol.dflt_value !== undefined && existingCol.dflt_value !== desiredDefault) defaultChanged.push({
+			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)) {
+		else if (field.renamedFrom && existingByName.has(field.renamedFrom)) {
 			renamed.push({
 				field,
 				oldName: field.renamedFrom
@@ -147,10 +190,9 @@ else if (field.renamedFrom && existingByName.has(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,
+		removed: existing.filter((c) => !desiredByName.has(c.name) && !renamedOldNames.has(c.name)),
 		renamed,
 		typeChanged,
 		nullableChanged,
@@ -158,25 +200,30 @@ else if (field.renamedFrom && existingByName.has(field.renamedFrom)) {
 		conflicts
 	};
 }
-
 //#endregion
-//#region packages/db/src/schema/fk-diff.ts
+//#region src/schema/fk-diff.ts
+/** Canonical key for an FK: sorted local field names, comma-joined. */
 function fkKey(fields) {
-	return [...fields].sort().join(",");
+	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 = new Map();
+	const existingByKey = /* @__PURE__ */ new Map();
 	for (const fk of existingSnapshot) existingByKey.set(fkKey(fk.fields), fk);
-	const desiredKeys = new Set();
+	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({
+		else if (fkPropertiesDiffer(fk, existing)) changed.push({
 			desired: fk,
 			existing
 		});
@@ -188,25 +235,36 @@ else if (fkPropertiesDiffer(fk, existing)) changed.push({
 		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 ?? undefined) !== (existing.onDelete ?? undefined)) return true;
-	if ((desired.onUpdate ?? undefined) !== (existing.onUpdate ?? undefined)) 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 packages/db/src/schema/table-option-diff.ts
+//#region src/schema/table-option-diff.ts
+/**
+* Computes the difference between desired and existing table options.
+*
+* Options present in desired but absent from existing are ignored (initial state).
+* Options present in existing but absent from desired are ignored (sticky options).
+* Only value changes on matching keys are tracked.
+*
+* @param desired - Options from Atscript annotations (via adapter.getDesiredTableOptions()).
+* @param existing - Options from DB introspection or snapshot fallback.
+* @param destructiveKeys - Option keys where a value change requires table recreation.
+*/
 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({
+		if (existingValue !== void 0 && existingValue !== opt.value) changed.push({
 			key: opt.key,
 			oldValue: existingValue,
 			newValue: opt.value,
@@ -215,41 +273,32 @@ function computeTableOptionDiff(desired, existing, destructiveKeys) {
 	}
 	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;
-}
+//#region src/schema/sync-store.ts
 var SyncStore = class {
+	controlTable;
+	constructor(space) {
+		this.space = space;
+	}
 	async ensureControlTable() {
 		if (!this.controlTable) {
-			const { AtscriptControl } = await import("./control_as-bjmwe24C.mjs");
+			const { AtscriptControl } = await import("./control-IANbnfjG.mjs");
 			this.controlTable = this.space.getTable(AtscriptControl);
 		}
 		await this.controlTable.ensureTable();
 	}
 	async readControlValue(_id) {
-		const row = await this.controlTable.findOne({
+		return (await this.controlTable.findOne({
 			filter: { _id: { $eq: _id } },
 			controls: {}
-		});
-		return row?.value ?? null;
+		}))?.value ?? null;
 	}
 	async writeControlValue(_id, value) {
-		const existing = await this.readControlValue(_id);
-		if (existing !== null) await this.controlTable.replaceOne({
+		if (await this.readControlValue(_id) !== null) await this.controlTable.replaceOne({
 			_id,
 			value
 		});
-else await this.controlTable.insertOne({
+		else await this.controlTable.insertOne({
 			_id,
 			value
 		});
@@ -280,10 +329,9 @@ else await this.controlTable.insertOne({
 			name,
 			isView: false
 		}));
-		return parsed.map((e) => ({
-			...e,
-			viewType: e.viewType ?? (e.isView ? "V" : undefined)
-		}));
+		const entries = parsed;
+		for (const e of entries) e.viewType ??= e.isView ? "V" : void 0;
+		return entries;
 	}
 	async writeTrackedList(readables) {
 		const entries = readables.map((r) => {
@@ -311,7 +359,7 @@ else await this.controlTable.insertOne({
 		if (existing) {
 			const expiresAt = existing.expiresAt;
 			if (expiresAt && expiresAt < now) await this.controlTable.deleteOne("sync_lock");
-else return false;
+			else return false;
 		}
 		try {
 			await this.controlTable.insertOne({
@@ -368,36 +416,19 @@ else return false;
 		}
 		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 { AtscriptControl } = await import("./control-IANbnfjG.mjs");
 	const table = space.getTable(AtscriptControl);
 	await table.ensureTable();
-	const row = await table.findOne({
+	const value = (await table.findOne({
 		filter: { _id: { $eq: `table_snapshot:${tableName}` } },
 		controls: {}
-	});
-	const value = row?.value ?? null;
+	}))?.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;
-}
+//#region src/schema/sync-entry.ts
 const noColor = {
 	green: (s) => s,
 	red: (s) => s,
@@ -408,17 +439,64 @@ const noColor = {
 	underline: (s) => s
 };
 var SyncEntry = class {
-	/** Whether this entry involves destructive operations */ get destructive() {
+	name;
+	/** 'V' = virtual view, 'M' = materialized view, 'E' = external view, undefined = table */
+	viewType;
+	status;
+	syncMethod;
+	columnsToAdd;
+	columnsToRename;
+	typeChanges;
+	nullableChanges;
+	defaultChanges;
+	columnsToDrop;
+	optionChanges;
+	fkAdded;
+	fkRemoved;
+	fkChanged;
+	columnsAdded;
+	columnsRenamed;
+	columnsDropped;
+	recreated;
+	errors;
+	renamedFrom;
+	constructor(init) {
+		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;
+	}
+	/** 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() {
+	/** 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() {
+	/** Whether this entry has errors */
+	get hasErrors() {
 		return this.status === "error" || this.errors.length > 0;
 	}
-	/** Render this entry for display */ print(mode, colors) {
+	/** Render this entry for display */
+	print(mode, colors) {
 		const c = colors ?? noColor;
 		return mode === "plan" ? this.printPlan(c) : this.printResult(c);
 	}
@@ -481,13 +559,11 @@ var SyncEntry = class {
 			...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) {
+		if (this.columnsAdded.length > 0 || this.columnsRenamed.length > 0 || this.columnsDropped.length > 0 || this.optionChanges.length > 0 || 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.recreated ? (s) => c.yellow(s) : (s) => c.cyan(s))(`~ ${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`)}`),
@@ -503,52 +579,10 @@ var SyncEntry = class {
 		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
+//#region src/schema/sync-executor.ts
+/** Checks if a tracked view's definition changed since the last stored snapshot. */
 async function viewDefinitionChanged(view, store) {
 	const storedSnapshot = await store.readTableSnapshot(view.tableName, true);
 	if (!storedSnapshot) return false;
@@ -591,8 +625,7 @@ async function executeSyncTable(readable, safe, trackedNames, deps) {
 				}
 			}
 			const typeMapper = adapter.typeMapper?.bind(adapter);
-			const diff = computeColumnDiff(readable.fieldDescriptors, existing, typeMapper);
-			await applyColumnDiff(adapter, readable, diff, init, safe, deps.logger);
+			await applyColumnDiff(adapter, readable, computeColumnDiff(readable.fieldDescriptors, existing, typeMapper), init, safe, deps.logger);
 		}
 	} else if (adapter.syncColumns) if (!storedSnapshot) {
 		const existed = adapter.tableExists ? await adapter.tableExists() : false;
@@ -600,10 +633,9 @@ async function executeSyncTable(readable, safe, trackedNames, deps) {
 		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);
+		await applyColumnDiff(adapter, readable, computeColumnDiff(readable.fieldDescriptors, existing, deps.resolveTypeMapper(adapter)), init, safe, deps.logger);
 	}
-else {
+	else {
 		const existed = adapter.tableExists ? await adapter.tableExists() : true;
 		if (!init.recreated) {
 			await adapter.ensureTable();
@@ -621,8 +653,7 @@ else {
 				init.status = "alter";
 			}
 			if (hasDestructive) {
-				const syncMethod = readable.syncMethod;
-				if (syncMethod === "recreate" && adapter.recreateTable) {
+				if (readable.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";
@@ -655,14 +686,14 @@ async function executeSyncView(view, trackedNames, deps) {
 	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";
+	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
+		renamedFrom: isRenamed ? renamedFrom : void 0,
+		recreated: definitionChanged || void 0
 	});
 }
 async function applyColumnDiff(adapter, readable, diff, init, safe, logger) {
@@ -691,7 +722,7 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger) {
 		} 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.`;
+				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);
 			}
@@ -707,7 +738,7 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger) {
 		init.recreated = true;
 		init.status = "alter";
 	} else init.status = "alter";
-else if (diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0) 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;
@@ -721,32 +752,30 @@ else if (diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0) init
 		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) {
+//#region src/schema/schema-sync.ts
+/** 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"}`);
+	if ([...existing.targetFields].toSorted().join(",") !== [...desired.targetFields].toSorted().join(",")) parts.push(`fields ${existing.targetFields.join(",")} → ${desired.targetFields.join(",")}`);
+	if ((existing.onDelete ?? void 0) !== (desired.onDelete ?? void 0)) parts.push(`onDelete ${existing.onDelete ?? "noAction"} → ${desired.onDelete ?? "noAction"}`);
+	if ((existing.onUpdate ?? void 0) !== (desired.onUpdate ?? void 0)) parts.push(`onUpdate ${existing.onUpdate ?? "noAction"} → ${desired.onUpdate ?? "noAction"}`);
 	return parts.join(", ");
 }
 var SchemaSync = class {
+	store;
+	logger;
+	constructor(space, logger) {
+		this.space = space;
+		this.logger = logger || NoopLogger;
+		this.store = new SyncStore(space);
+	}
 	/**
 	* Resolves types into categorized readables and computes the schema hash.
 	* Passes each adapter's typeMapper for precise type tracking in snapshots.
-	*/ async resolveAndHash(types) {
+	*/
+	async resolveAndHash(types) {
 		const tables = [];
 		const views = [];
 		const externalViews = [];
@@ -755,32 +784,29 @@ var SchemaSync = class {
 			if (readable.isView) {
 				const view = readable;
 				if (view.isExternal) externalViews.push(view);
-else views.push(readable);
+				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
+			hash: computeSchemaHash([
+				...tables,
+				...views,
+				...externalViews
+			].map((r) => {
+				if (r.isView) return computeViewSnapshot(r);
+				const tm = r.dbAdapter.typeMapper?.bind(r.dbAdapter);
+				return computeTableSnapshot(r, tm, (r.fieldDescriptors, r.dbAdapter.getDesiredTableOptions?.()));
+			}))
 		};
 	}
 	/**
 	* 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) {
+	*/
+	async checkExternalView(view) {
 		const adapter = view.dbAdapter;
 		const name = view.tableName;
 		if (adapter.getExistingColumns) {
@@ -800,8 +826,7 @@ else views.push(readable);
 				errors: [`External view "${name}" is missing columns: ${missing.join(", ")}`]
 			});
 		} else if (adapter.tableExists) {
-			const exists = await adapter.tableExists();
-			if (!exists) return new SyncEntry({
+			if (!await adapter.tableExists()) return new SyncEntry({
 				name,
 				viewType: "E",
 				status: "error",
@@ -817,8 +842,9 @@ else views.push(readable);
 	/**
 	* 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());
+	*/
+	async detectRemoved(currentReadables, 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 = [];
@@ -833,7 +859,8 @@ else views.push(readable);
 	* 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) {
+	*/
+	startHeartbeat(podId, ttlMs) {
 		let abortReason;
 		let stopped = false;
 		const intervalMs = Math.max(Math.floor(ttlMs / 3), 1e3);
@@ -863,13 +890,15 @@ else views.push(readable);
 			getAbortReason: () => abortReason
 		};
 	}
-	/** Throws if the heartbeat detected a stolen/missing lock. */ assertLockHeld(getAbortReason) {
+	/** 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) {
+	*/
+	async run(types, opts) {
 		const podId = opts?.podId ?? crypto.randomUUID();
 		const lockTtlMs = opts?.lockTtlMs ?? 3e4;
 		const waitTimeoutMs = opts?.waitTimeoutMs ?? 6e4;
@@ -879,30 +908,25 @@ else views.push(readable);
 		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 {
+			if (await this.store.readHash() === hash) return {
 				status: "up-to-date",
 				schemaHash: hash,
 				entries: []
 			};
 		}
-		const acquired = await this.store.tryAcquireLock(podId, lockTtlMs);
-		if (!acquired) {
+		if (!await this.store.tryAcquireLock(podId, lockTtlMs)) {
 			await this.store.waitForLock(waitTimeoutMs, pollIntervalMs);
-			const storedHash = await this.store.readHash();
-			if (storedHash === hash) return {
+			if (await this.store.readHash() === 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");
+			if (!await this.store.tryAcquireLock(podId, lockTtlMs)) 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 {
+				if (await this.store.readHash() === hash) return {
 					status: "synced-by-peer",
 					schemaHash: hash,
 					entries: []
@@ -934,7 +958,7 @@ else views.push(readable);
 				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);
+					else await this.space.dropTableByName(entry.name);
 				}
 				entries.push(...removed.filter((e) => e.viewType !== "E"));
 			}
@@ -942,8 +966,8 @@ else await this.space.dropTableByName(entry.name);
 			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);
+				const opts = adapter.getDesiredTableOptions?.();
+				const snapshot = readable.isView ? computeViewSnapshot(readable) : computeTableSnapshot(readable, tm, opts);
 				await this.store.writeTableSnapshot(readable.tableName, snapshot);
 			}
 			if (!safe) for (const entry of removed) {
@@ -965,7 +989,8 @@ else await this.space.dropTableByName(entry.name);
 	}
 	/**
 	* Computes a dry-run plan showing what `run()` would do, without executing any DDL.
-	*/ async plan(types, opts) {
+	*/
+	async plan(types, opts) {
 		const force = opts?.force ?? false;
 		const safe = opts?.safe ?? false;
 		const { tables, views, externalViews, hash } = await this.resolveAndHash(types);
@@ -981,8 +1006,7 @@ else await this.space.dropTableByName(entry.name);
 		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 {
+			if (await this.store.readHash() === hash) return {
 				status: "up-to-date",
 				schemaHash: hash,
 				entries: [
@@ -995,7 +1019,23 @@ else await this.space.dropTableByName(entry.name);
 		let removed = await this.detectRemoved(allReadables, previouslyTracked);
 		if (safe) {
 			planEntries = planEntries.map((e) => new SyncEntry({
-				...e,
+				name: e.name,
+				viewType: e.viewType,
+				status: e.status,
+				syncMethod: e.syncMethod,
+				columnsToAdd: e.columnsToAdd,
+				columnsToRename: e.columnsToRename,
+				nullableChanges: e.nullableChanges,
+				defaultChanges: e.defaultChanges,
+				optionChanges: e.optionChanges,
+				fkAdded: e.fkAdded,
+				fkRemoved: e.fkRemoved,
+				fkChanged: e.fkChanged,
+				columnsAdded: e.columnsAdded,
+				columnsRenamed: e.columnsRenamed,
+				columnsDropped: e.columnsDropped,
+				errors: e.errors,
+				renamedFrom: e.renamedFrom,
 				columnsToDrop: [],
 				typeChanges: [],
 				recreated: false
@@ -1014,7 +1054,8 @@ else await this.space.dropTableByName(entry.name);
 			]
 		};
 	}
-	/** Fallback typeMapper for snapshot-based Path B: compares designType directly, skips unions. */ resolveTypeMapper(adapter) {
+	/** 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) {
@@ -1045,8 +1086,7 @@ else await this.space.dropTableByName(entry.name);
 			}
 		} else if (adapter.syncColumns) if (!storedSnapshot) {
 			if (!pendingRename) {
-				const exists = adapter.tableExists ? await adapter.tableExists() : false;
-				if (!exists) {
+				if (!(adapter.tableExists ? await adapter.tableExists() : false)) {
 					init.status = "create";
 					init.columnsToAdd = readable.fieldDescriptors.filter((f) => !f.ignored);
 				}
@@ -1056,9 +1096,8 @@ else await this.space.dropTableByName(entry.name);
 			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 if (adapter.tableExists) {
+			if (!await adapter.tableExists()) init.status = "create";
 		} else init.status = "create";
 		if (init.status !== "create") {
 			const optionDiff = await this.diffTableOptions(readable);
@@ -1091,7 +1130,8 @@ else if (adapter.tableExists) {
 	}
 	/**
 	* Populates plan init from a column diff (shared by Path A and Path B).
-	*/ populatePlanFromDiff(diff, init, name, syncMethod, adapterSupportsModify) {
+	*/
+	populatePlanFromDiff(diff, init, name, syncMethod, adapterSupportsModify) {
 		init.columnsToAdd = diff.added;
 		init.columnsToRename = diff.renamed.map((r) => ({
 			from: r.oldName,
@@ -1112,27 +1152,27 @@ else if (adapter.tableExists) {
 			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.added.length > 0 || diff.renamed.length > 0 || diff.typeChanged.length > 0 || diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0 || diff.removed.length > 0) 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.`)];
+			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) {
+	*/
+	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 {
+		else {
 			const snapshot = await this.store.readTableSnapshot(readable.tableName);
 			existing = snapshot ? snapshotToExistingTableOptions(snapshot) : [];
 		}
@@ -1146,14 +1186,14 @@ else {
 		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";
+		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
+			renamedFrom: isRenamed ? renamedFrom : void 0,
+			recreated: status === "alter" && !isRenamed ? true : void 0
 		});
 	}
 	buildExecutorDeps() {
@@ -1165,22 +1205,33 @@ else status = "create";
 			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
+//#region src/sync.ts
+/**
+* Synchronizes database schema with distributed locking.
+* Safe to call from multiple concurrent processes/pods.
+*
+* ```typescript
+* import { syncSchema } from '@atscript/db/sync'
+*
+* const db = new DbSpace(() => new SqliteAdapter(driver))
+* await syncSchema(db, [UsersType, PostsType, CommentsType])
+* ```
+*
+* The function:
+* 1. Creates an `__atscript_control` table for lock coordination
+* 2. Computes a schema hash — skips entirely if nothing changed
+* 3. Acquires a distributed lock so only one process syncs
+* 4. Creates tables, adds new columns, syncs indexes
+* 5. Stores the new hash and releases the lock
+*
+* @param space - The DbSpace containing the adapter factory.
+* @param types - Atscript annotated types to synchronize.
+* @param opts - Lock TTL, wait timeout, force mode, etc.
+*/
 async function syncSchema(space, types, opts) {
-	const sync = new SchemaSync(space);
-	return sync.run(types, opts);
+	return new SchemaSync(space).run(types, opts);
 }
-
 //#endregion
-export { SchemaSync, SyncEntry, computeColumnDiff, computeForeignKeyDiff, computeSchemaHash, computeTableHash, computeTableOptionDiff, computeTableSnapshot, computeViewSnapshot, fkKey, hasForeignKeyChanges, readStoredSnapshot, snapshotToExistingColumns, snapshotToExistingTableOptions, syncSchema };
+export { SchemaSync, SyncEntry, computeColumnDiff, computeForeignKeyDiff, computeSchemaHash, computeTableHash, computeTableOptionDiff, computeTableSnapshot, computeViewSnapshot, fkKey, hasForeignKeyChanges, readStoredSnapshot, snapshotToExistingColumns, snapshotToExistingTableOptions, syncSchema };