@atscript/db 0.1.161 → 0.1.163

package/dist/shared.d.mts

@@ -1,11 +1,35 @@
-import { AnnotationSpec, AtscriptDoc, SemanticInterfaceNode, SemanticNode, SemanticPropNode, SemanticQueryExprNode, SemanticQueryFieldRefNode, SemanticStructureNode, TAnnotationTokens, TMessages, TQueryScope, Token } from "@atscript/core";
+import { s as stableJson } from "./object-Czia_qD4.mjs";
+import { n as ENCRYPTED_SEARCH_FEATURES, t as ENCRYPTED_INCOMPATIBLE } from "./search-fields-CHqqcC3W.mjs";
+import { AnnotationSpec, AtscriptDoc, SemanticInterfaceNode, SemanticNode, SemanticPropNode, SemanticQueryExprNode, SemanticQueryFieldRefNode, SemanticStructureNode, TAnnotationSpecConfig, TAnnotationTokens, TMessages, TQueryScope, Token } from "@atscript/core";
 
 //#region src/shared/annotation-utils.d.ts
-/** Asserts the field carrying this annotation does not also carry any of `others`. */
+/**
+ * Names of a field's effective annotations: its own plus the ones it inherits
+ * through its type ref (`price: Order.price`), with the `passedWhenReferred:
+ * false` ones dropped — the set codegen writes into the field's runtime
+ * metadata (`AtscriptDoc.evalAnnotationsForNode`). Compile checks that mirror
+ * a runtime metadata check read this, not the own-only `countAnnotations`.
+ * @since 0.1.162
+ */
+declare function effectiveAnnotationNames(field: SemanticNode, doc?: AtscriptDoc): Set<string>;
+/**
+ * Asserts the field carrying this annotation does not also carry any of
+ * `others` — its own or inherited through its type ref (since 0.1.162).
+ */
 declare function validateExclusiveWith(token: Token, selfName: string, others: Array<{
   key: string;
   displayName?: string;
-}>): TMessages;
+}>, doc?: AtscriptDoc): TMessages;
+/**
+ * Reports each of `pairs` (`[annotation, why]`) the field carrying `token`
+ * also carries — its own or inherited through its type ref (the field's
+ * effective annotations, what the runtime mirror reads off the metadata):
+ * `${tag} cannot coexist with @${annotation} — ${why}`.
+ * @since 0.1.162
+ */
+declare function validateIncompatible(token: Token, tag: string, pairs: ReadonlyArray<readonly [annotation: string, why: string]>, doc?: AtscriptDoc): TMessages;
+/** Whether a prop is a field of a view interface (`@db.view` / `@db.view.for`). */
+declare function isViewField(field: SemanticNode): boolean;
 /** Primitive base type (`string`, `number`, `decimal`, …) of a resolved definition, if it is a primitive. */
 declare function primitiveBaseType(def: SemanticNode | undefined): string | undefined;
 /**
@@ -164,4 +188,74 @@ declare const NOT_DIMENSION_REASON = "not a dimension";
  */
 declare function isStrictAggregateStruct(struct: SemanticStructureNode): boolean;
 //#endregion
-export { NOT_DIMENSION_REASON, TFKFieldMatch, TRefArgumentOptions, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isNullableUnion, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, searchFieldVerdict, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };
+//#region src/shared/view-validation.d.ts
+/** Read seals of a view field ({@link viewFieldSeals}). @since 0.1.162 */
+interface TViewFieldSeals {
+  writeOnly: boolean;
+  encrypted: boolean;
+}
+/**
+ * The read seals a view field takes from the source field it reads, as the
+ * compiler sees them (compile-time mirror of the runtime `sourceFieldSeals`,
+ * which stamps them onto the view column — these annotations are
+ * `passedWhenReferred: false`, so they are not in the field's own metadata):
+ * - `writeOnly` — the source path or an ancestor object is `@db.writeOnly`;
+ * - `encrypted` — the source path or an ancestor object is `@db.encrypted`.
+ *
+ * (A `@db.json` source is no seal: a view reads a primitive JSON column's
+ * typed value, and an object one needs its own `@db.json`.)
+ *
+ * The source is the chain ref (`pin?: Account.pin`), or else the entry table's
+ * same-named field (or an aggregate's field) of a `@db.view.for` view. A source
+ * field that is itself a view field passes on its own seals. Computed fields
+ * and fields of anything but a view report no seal.
+ * @since 0.1.162
+ */
+declare function viewFieldSeals(field: SemanticNode, doc: AtscriptDoc, depth?: number): TViewFieldSeals;
+/**
+ * A search / index feature (`@db.column.searchable`, `@db.index.fulltext`,
+ * `@db.index.geo`, `@db.search.vector`, `@db.search.filter`) on a field that
+ * would read ciphertext: a field inside an `@db.encrypted` object, or a view
+ * field over an encrypted source — or `undefined`. The field's own
+ * `@db.encrypted` is reported by that spec.
+ * @since 0.1.162
+ */
+declare function encryptedSearchProblem(token: Token, doc: AtscriptDoc, annotation: string): TMessages[number] | undefined;
+/**
+ * An annotation's `validate` refusing it on a field that reads ciphertext
+ * ({@link encryptedSearchProblem}) — for the search features of sibling
+ * adapter plugins too.
+ * @since 0.1.162
+ */
+declare function refuseCiphertext(annotation: string): TAnnotationSpecConfig["validate"];
+/**
+ * Navigation relation annotations — a navigation field holds another table's
+ * rows, never part of this table's stored value.
+ * @since 0.1.162
+ */
+declare const NAV_ANNOTATIONS: readonly ["db.rel.to", "db.rel.from", "db.rel.via"];
+/** Whether a prop is a navigation field ({@link NAV_ANNOTATIONS}). */
+declare function isNavProp(prop: SemanticNode): boolean;
+/**
+ * Walks the fields stored in `root` (an interface, a structure or a type ref)
+ * depth-first — nested objects and type refs included, navigation fields and
+ * arrays skipped — and returns the first non-`undefined` result of `visit`.
+ * `path` is the field's dotted path below `prefix`; `viaRef` tells whether
+ * a type ref was followed to reach it.
+ * @since 0.1.162
+ */
+declare function findStoredField<T>(root: SemanticNode | undefined, doc: AtscriptDoc, visit: (prop: SemanticNode, path: string, viaRef: boolean) => T | undefined, prefix?: string): T | undefined;
+/**
+ * A search feature ({@link ENCRYPTED_SEARCH_FEATURES}) declared inside the
+ * TYPE of the `@db.encrypted` field carrying `token`, reached through a type
+ * ref (`@db.encrypted profile: Address`, where `Address` has
+ * `@db.index.fulltext city`) — the shared type's own annotations cannot see
+ * that this use encrypts them. Fields declared inline are reported by their
+ * own annotation (see {@link encryptedSearchProblem}).
+ * @since 0.1.162
+ */
+declare function encryptedTypeSearchProblem(token: Token, doc: AtscriptDoc): TMessages[number] | undefined;
+/** Name of the nearest `@db.encrypted` prop enclosing `field` (inline nested objects), if any. */
+declare function encryptedAncestorName(field: SemanticNode): string | undefined;
+//#endregion
+export { ENCRYPTED_INCOMPATIBLE, ENCRYPTED_SEARCH_FEATURES, NAV_ANNOTATIONS, NOT_DIMENSION_REASON, TFKFieldMatch, TRefArgumentOptions, type TViewFieldSeals, earlierJoinTargets, effectiveAnnotationNames, encryptedAncestorName, encryptedSearchProblem, encryptedTypeSearchProblem, findFKFieldsPointingTo, findStoredField, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isNavProp, isNullableUnion, isStrictAggregateStruct, isViewField, joinTargets, primitiveBaseType, refActionAnnotation, refuseCiphertext, searchFieldVerdict, stableJson, validateExclusiveWith, validateFieldBaseType, validateIncompatible, validateQueryScope, validateRefArgument, validateSiblingStringField, viewFieldSeals, viewJoins, viewScopeTypes };

package/dist/shared.mjs

@@ -1,3 +1,5 @@
+import { n as ENCRYPTED_SEARCH_FEATURES, t as ENCRYPTED_INCOMPATIBLE } from "./search-fields-BPNsxrCk.mjs";
+import { s as stableJson } from "./object-PQ1J8jri.mjs";
 import { n as isStrictAggregateStruct, t as NOT_DIMENSION_REASON } from "./aggregate-rules-jdPrxqWa.mjs";
-import { C as validateExclusiveWith, S as searchFieldVerdict, T as validateSiblingStringField, _ as getParentTypeName, a as hasAnyViewAnnotation, b as primitiveBaseType, c as joinTargets, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, i as forEachFieldRef, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as integerMemberIndexProblem, w as validateFieldBaseType, x as refActionAnnotation, y as isNullableUnion } from "./validation-utils-BGjqc2jU.mjs";
-export { NOT_DIMENSION_REASON, earlierJoinTargets, findFKFieldsPointingTo, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isNullableUnion, isStrictAggregateStruct, joinTargets, primitiveBaseType, refActionAnnotation, searchFieldVerdict, validateExclusiveWith, validateFieldBaseType, validateQueryScope, validateRefArgument, validateSiblingStringField, viewJoins, viewScopeTypes };
+import { A as getParentTypeName, B as validateSiblingStringField, C as viewJoins, D as getDbTableOwner, E as getAnnotationAlias, F as refActionAnnotation, I as searchFieldVerdict, L as validateExclusiveWith, M as isNullableUnion, N as isViewField, O as getNavTargetTypeName, P as primitiveBaseType, R as validateFieldBaseType, S as validateRefArgument, T as effectiveAnnotationNames, _ as hasAnyViewAnnotation, a as findStoredField, b as joinTargets, c as refuseCiphertext, d as viewFieldSeals, g as forEachFieldRef, h as findViewCycle, i as encryptedTypeSearchProblem, j as integerMemberIndexProblem, k as getParentStruct, m as findFKFieldsPointingTo, n as encryptedAncestorName, o as isNavProp, p as earlierJoinTargets, r as encryptedSearchProblem, t as NAV_ANNOTATIONS, v as isAliasDecl, w as viewScopeTypes, x as validateQueryScope, y as isDbSourceDecl, z as validateIncompatible } from "./view-validation-BcgDq7M9.mjs";
+export { ENCRYPTED_INCOMPATIBLE, ENCRYPTED_SEARCH_FEATURES, NAV_ANNOTATIONS, NOT_DIMENSION_REASON, earlierJoinTargets, effectiveAnnotationNames, encryptedAncestorName, encryptedSearchProblem, encryptedTypeSearchProblem, findFKFieldsPointingTo, findStoredField, findViewCycle, forEachFieldRef, getAnnotationAlias, getDbTableOwner, getNavTargetTypeName, getParentStruct, getParentTypeName, hasAnyViewAnnotation, integerMemberIndexProblem, isAliasDecl, isDbSourceDecl, isNavProp, isNullableUnion, isStrictAggregateStruct, isViewField, joinTargets, primitiveBaseType, refActionAnnotation, refuseCiphertext, searchFieldVerdict, stableJson, validateExclusiveWith, validateFieldBaseType, validateIncompatible, validateQueryScope, validateRefArgument, validateSiblingStringField, viewFieldSeals, viewJoins, viewScopeTypes };

package/dist/sync.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_db_error = require("./db-error-JcfJqqpk.cjs");
-const require_column_diff = require("./column-diff-DpeUbhEI.cjs");
-const require_validator = require("./validator-B4YDLUkj.cjs");
+const require_db_error = require("./db-error-DmF1_xrz.cjs");
+const require_column_diff = require("./column-diff-BIGX3sRH.cjs");
+const require_validator = require("./validator-DK9Ijpo7.cjs");
 //#region src/schema/json-column-copy.ts
 const NONE = {
 	copies: [],
@@ -506,6 +506,24 @@ async function readStoredSnapshot(space, tableName, _asView) {
 }
 //#endregion
 //#region src/schema/sync-entry.ts
+/** How each index change prints: its mark, color and past-tense word. */
+const INDEX_CHANGE_STYLE = {
+	add: {
+		mark: "+",
+		color: "green",
+		done: "added"
+	},
+	drop: {
+		mark: "-",
+		color: "red",
+		done: "dropped"
+	},
+	rebuild: {
+		mark: "~",
+		color: "yellow",
+		done: "rebuilt"
+	}
+};
 const noColor = {
 	green: (s) => s,
 	red: (s) => s,
@@ -560,6 +578,10 @@ var SyncEntry = class SyncEntry {
 	refused;
 	/** @since 0.1.141 — see {@link TSyncEntryInit.cascadeFrom}. */
 	cascadeFrom;
+	/** @since 0.1.162 — see {@link TSyncEntryInit.definitionChanged}. */
+	definitionChanged;
+	/** @since 0.1.162 — see {@link TSyncEntryInit.indexChanges}. */
+	indexChanges;
 	constructor(init) {
 		this.name = init.name;
 		this.viewType = init.viewType;
@@ -590,6 +612,8 @@ var SyncEntry = class SyncEntry {
 		this.dropGroup = init.dropGroup;
 		this.refused = init.refused ?? false;
 		this.cascadeFrom = init.cascadeFrom ?? [];
+		this.definitionChanged = init.definitionChanged ?? false;
+		this.indexChanges = init.indexChanges ?? [];
 	}
 	/**
 	* The init object this entry was built from — lets callers derive a
@@ -660,11 +684,13 @@ var SyncEntry = class SyncEntry {
 		return mode === "plan" ? [`      ${c.red(`! ${cols} — rebuild (${pk.populated ? "rows satisfy the new key" : "table is empty"})`)}`] : [`      ${c.yellow(`~ ${cols} — rebuilt`)}`];
 	}
 	/**
-	* `! col: t1 → t2 — drop` (plan), or `! type col (t1 → t2) — skipped (safe
-	* mode)` in plan and result when the `'drop'` recreate was skipped.
+	* `! col: t1 → t2 — drop` (plan), `~ col: t1 → t2 — type changed` (result),
+	* or `! type col (t1 → t2) — skipped (safe mode)` in plan and result when
+	* the `'drop'` recreate was skipped.
 	*/
-	printTypeChanges(c) {
+	printTypeChanges(c, mode) {
 		if (this.skipped.includes("recreate")) return this.typeChanges.map((tc) => `      ${c.yellow(`! type ${tc.column} (${tc.fromType} → ${tc.toType}) — skipped (safe mode)`)}`);
+		if (mode === "result") return this.typeChanges.map((tc) => `      ${c.yellow(`~ ${tc.column}: ${tc.fromType} → ${tc.toType} — type changed`)}`);
 		return this.typeChanges.map((tc) => {
 			const action = this.syncMethod ? ` — ${this.syncMethod}` : " — requires migration";
 			return `      ${c.red(`! ${tc.column}: ${tc.fromType} → ${tc.toType}${action}`)}`;
@@ -708,6 +734,26 @@ var SyncEntry = class SyncEntry {
 			return `      ${tag} ${c.cyan(`option ${oc.key}`)}: ${oc.oldValue} → ${oc.newValue}${action}`;
 		});
 	}
+	/** `+ FK(a) → t — add` / `- … — remove` / `~ … — details` (plan); `added` / `removed` (result). */
+	printForeignKeys(c, mode) {
+		const [add, remove] = mode === "plan" ? ["add", "remove"] : ["added", "removed"];
+		return [
+			...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 ? ` → ${fk.targetTable}` : ""} — ${remove}`)}`),
+			...this.fkChanged.map((fk) => `      ${c.yellow(`~ FK(${fk.fields.join(",")}) → ${fk.targetTable} — ${fk.details}`)}`)
+		];
+	}
+	/** `+ index name — add` / `- … — drop` / `~ … — rebuild` (plan); `added` / `dropped` / `rebuilt` (result). */
+	printIndexChanges(c, mode) {
+		return this.indexChanges.map((ic) => {
+			const { mark, color, done } = INDEX_CHANGE_STYLE[ic.action];
+			return `      ${c[color](`${mark} index ${ic.name} — ${mode === "plan" ? ic.action : done}`)}`;
+		});
+	}
+	/** `· definition changed` — why a managed view is recreated. */
+	printDefinitionChanged(c) {
+		return this.definitionChanged ? [`      ${c.dim("· definition changed")}`] : [];
+	}
 	/** `· after: a, b` (plan only — the executor already runs in this order). */
 	printDependsOn(c) {
 		if (this.dependsOn.length === 0) return [];
@@ -746,15 +792,15 @@ var SyncEntry = class SyncEntry {
 				...this.columnsToAdd.map((col) => `      ${c.green(`+ ${col.physicalName} (${col.designType})${col.derived ? " derived" : ""} — add`)}`),
 				...this.columnsToRename.map((r) => `      ${c.yellow(`~ ${r.from} → ${r.to} — rename`)}`),
 				...this.printJsonMigration(c, "plan"),
-				...this.printTypeChanges(c),
+				...this.printTypeChanges(c, "plan"),
 				...this.printNullableDefaults(c),
 				...this.printDerivedChanges(c, "plan"),
 				...this.printPkChange(c, "plan"),
 				...this.columnsToDrop.map((col) => `      ${c.red(`- ${col} — drop`)}`),
 				...this.printOptionChanges(c, "plan"),
-				...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}`)}`),
+				...this.printForeignKeys(c, "plan"),
+				...this.printIndexChanges(c, "plan"),
+				...this.printDefinitionChanged(c),
 				...this.printCascade(c),
 				...this.printDependsOn(c),
 				""
@@ -774,7 +820,7 @@ var SyncEntry = class SyncEntry {
 			...this.columnsAdded.map((col) => `      ${c.green(`+ ${col} — added`)}`),
 			""
 		];
-		if (this.columnsAdded.length > 0 || this.columnsRenamed.length > 0 || this.columnsDropped.length > 0 || this.optionChanges.length > 0 || this.pkChange !== void 0 || this.derivedChanges.length > 0 || this.jsonCopies.length > 0 || this.jsonified.length > 0 || this.skipped.length > 0 || this.recreated || this.renamedFrom) {
+		if (this.columnsAdded.length > 0 || this.columnsRenamed.length > 0 || this.columnsDropped.length > 0 || this.optionChanges.length > 0 || this.pkChange !== void 0 || this.derivedChanges.length > 0 || this.jsonCopies.length > 0 || this.jsonified.length > 0 || this.typeChanges.length > 0 || this.nullableChanges.length > 0 || this.defaultChanges.length > 0 || this.fkAdded.length > 0 || this.fkRemoved.length > 0 || this.fkChanged.length > 0 || this.indexChanges.length > 0 || this.skipped.length > 0 || this.recreated || this.renamedFrom || this.status === "alter") {
 			const rlabel = this.recreated ? "recreated" : "altered";
 			const renameInfo = this.renamedFrom ? ` ${c.yellow(`(renamed from ${this.renamedFrom})`)}` : "";
 			return [
@@ -783,11 +829,14 @@ var SyncEntry = class SyncEntry {
 				...this.columnsRenamed.map((col) => `      ${c.yellow(`~ ${col} — renamed`)}`),
 				...this.printJsonMigration(c, "result"),
 				...this.printPkChange(c, "result"),
-				...this.printTypeChanges(c),
+				...this.printTypeChanges(c, "result"),
 				...this.printNullableDefaults(c),
 				...this.printDerivedChanges(c, "result"),
 				...this.columnsDropped.map((col) => `      ${c.red(`- ${col} — dropped`)}`),
 				...this.printOptionChanges(c, "result"),
+				...this.printForeignKeys(c, "result"),
+				...this.printIndexChanges(c, "result"),
+				...this.printDefinitionChanged(c),
 				...this.printCascade(c),
 				""
 			];
@@ -921,10 +970,7 @@ async function executeSyncTable(facts, safe, deps, exec) {
 				await adapter.ensureTable(ensureOpts);
 				init.status = "create";
 			} else if (existing.length > 0) {
-				let diff = facts.diff ?? require_column_diff.computeColumnDiff(readable.columnDescriptors, existing, adapter.typeMapper?.bind(adapter), {
-					snapshot: storedSnapshot,
-					nativeDefaultFns: adapter.nativeDefaultFns()
-				});
+				let diff = facts.diff ?? require_column_diff.computeColumnDiff(readable.columnDescriptors, existing, adapter.typeMapper?.bind(adapter), columnDiffOptions(adapter, storedSnapshot));
 				const migration = facts.jsonMigration ?? planJsonColumnMigration(readable, diff, storedSnapshot);
 				if (migration.errors.length > 0) throw new Error(migration.errors.join(" "));
 				if (migration.copies.length > 0 || migration.jsonify.length > 0) {
@@ -961,10 +1007,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 ?? require_column_diff.computeColumnDiff(readable.columnDescriptors, require_column_diff.snapshotToExistingColumns(storedSnapshot, readable), deps.resolveTypeMapper(adapter), {
-			snapshot: storedSnapshot,
-			nativeDefaultFns: adapter.nativeDefaultFns()
-		}), init, safe, deps.logger, ensureOpts);
+		} else await applyColumnDiff(adapter, readable, facts.diff ?? require_column_diff.computeColumnDiff(readable.columnDescriptors, require_column_diff.snapshotToExistingColumns(storedSnapshot, readable), deps.resolveTypeMapper(adapter), columnDiffOptions(adapter, storedSnapshot)), init, safe, deps.logger, ensureOpts);
 		else {
 			const existed = adapter.tableExists ? await adapter.tableExists() : true;
 			if (!init.recreated) {
@@ -972,6 +1015,10 @@ async function executeSyncTable(facts, safe, deps, exec) {
 				if (!existed) init.status = "create";
 			}
 		}
+		if (hasFkChanges && fkDiff && init.status !== "create" && init.status !== "error") {
+			Object.assign(init, describeForeignKeyChanges(fkDiff));
+			init.status = "alter";
+		}
 		phase = "Table option sync";
 		const optionDiff = facts.optionDiff;
 		if (init.status !== "create" && !init.recreated && init.status !== "error" && optionDiff && optionDiff.changed.length > 0) {
@@ -1006,8 +1053,15 @@ async function executeSyncTable(facts, safe, deps, exec) {
 		if (init.pkChange && facts.populated === true) init.pkChange.populated = true;
 		if (init.status === "error") return new SyncEntry(init);
 		phase = "Index/FK sync";
-		await adapter.syncIndexes(keptIndexes(init));
-		if (adapter.syncForeignKeys && !exec.deferForeignKeysTo) await adapter.syncForeignKeys();
+		const indexChanges = await adapter.syncIndexes(keptIndexes(init));
+		if (Array.isArray(indexChanges) && indexChanges.length > 0 && init.status !== "create" && !init.recreated) {
+			init.indexChanges = indexChanges;
+			init.status = "alter";
+		}
+		if (adapter.syncForeignKeys && !exec.deferForeignKeysTo) {
+			const fkChanges = await adapter.syncForeignKeys();
+			if (init.status !== "create" && !init.recreated && mergeLiveForeignKeyChanges(init, fkChanges)) init.status = "alter";
+		}
 		if (adapter.afterSyncTable) await adapter.afterSyncTable();
 	} catch (error) {
 		const dropped = droppedFks.length > 0 ? ` Dropped foreign keys before the failure: ${droppedFks.join(", ")} — the ones still in the model are re-added by the next run's syncForeignKeys.` : "";
@@ -1036,8 +1090,13 @@ async function executeDeferredForeignKeys(readable, entry, deps) {
 	const adapter = readable.dbAdapter;
 	if (!adapter.syncForeignKeys || entry.status === "error") return entry;
 	try {
-		await adapter.syncForeignKeys();
-		return entry;
+		const fkChanges = await adapter.syncForeignKeys();
+		if (entry.status === "create" || entry.recreated) return entry;
+		const init = entry.toInit();
+		return mergeLiveForeignKeyChanges(init, fkChanges) ? new SyncEntry({
+			...init,
+			status: "alter"
+		}) : entry;
 	} catch (error) {
 		const msg = `FK sync failed on ${readable.tableName}: ${error.message}`;
 		deps.logger.error?.(`[schema-sync] ${msg}`);
@@ -1083,6 +1142,14 @@ function describeDerivedChanges(diff) {
 		derived: dc.field.derived !== void 0
 	}));
 }
+/** The {@link computeColumnDiff} options for a table of `adapter`. */
+function columnDiffOptions(adapter, snapshot) {
+	return {
+		snapshot,
+		nativeDefaultFns: adapter.nativeDefaultFns(),
+		reportedDefault: adapter.reportedDefault?.bind(adapter)
+	};
+}
 /** The plan-shaped summary of a diff's type changes (`entry.typeChanges`). */
 function describeTypeChanges(diff) {
 	return diff.typeChanged.map((tc) => ({
@@ -1121,6 +1188,28 @@ function markSkipped(init, kind) {
 	init.skipped = [...init.skipped ?? [], kind];
 }
 /**
+* Whether the run (without safe mode) recreates this existing table — an FK
+* change on an adapter without `syncForeignKeys`, a `'drop'` / `'recreate'`
+* type change, nullable / default DDL through `recreateTable`, or a key
+* rebuild without `rebuildPrimaryKey`. The plan predicts no index work for
+* such a table: the recreate rebuilds every index.
+*/
+function runRecreatesTable(facts, safe = false) {
+	const { readable, fkDiff } = facts;
+	const adapter = readable.dbAdapter;
+	if (!adapter.recreateTable) return false;
+	if (fkDiff && require_column_diff.hasForeignKeyChanges(fkDiff) && !adapter.syncForeignKeys) return true;
+	const diff = facts.diff;
+	if (!diff) return false;
+	if (diff.typeChanged.length > 0) {
+		const strategy = typeChangeStrategy(readable, diff);
+		if (strategy === "recreate" || strategy === "drop" && !safe) return true;
+	}
+	if (safe) return false;
+	if ((diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0) && !adapter.supportsColumnModify && !!adapter.getExistingColumns) return true;
+	return !!diff.primaryKeyChanged && !adapter.rebuildPrimaryKey;
+}
+/**
 * Whether nullable/default changes need DDL on this adapter: in-place modify,
 * or a recreate on a live-introspected one (SQLite). Snapshot-based adapters
 * (MongoDB) have no column constraint to change — they only update the
@@ -1130,6 +1219,20 @@ function needsDdlForNullableDefaults(adapter) {
 	return !!adapter.supportsColumnModify && !!adapter.syncColumns || !!adapter.recreateTable && !!adapter.getExistingColumns;
 }
 /**
+* The `syncIndexes` options the run will pass for this table — what the plan
+* passes `planIndexes`, so both report the same index work.
+*/
+function plannedIndexOptions(facts, safe) {
+	if (!safe) return;
+	const diff = afterJsonCopy(facts);
+	return keptIndexes({
+		name: facts.name,
+		status: "alter",
+		skipped: safeModeSkips(facts),
+		typeChanges: diff ? describeTypeChanges(diff) : []
+	});
+}
+/**
 * The indexes `syncIndexes` keeps as they are because safe mode skipped
 * the change they depend on — a skipped key rebuild, the columns of a
 * skipped type-change recreate (see `TSyncIndexesOptions`).
@@ -1178,6 +1281,68 @@ function describeJsonMigration(migration) {
 		jsonified: migration.jsonify.length > 0 ? migration.jsonify : void 0
 	};
 }
+/** 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].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(", ");
+}
+/**
+* The plan-shaped summaries of a foreign-key diff (`entry.fkAdded` /
+* `fkRemoved` / `fkChanged`) — on plan entries and on the run entries that
+* applied them.
+*/
+function describeForeignKeyChanges(fkDiff) {
+	return {
+		fkAdded: fkDiff.added.map((fk) => ({
+			fields: require_column_diff.fkColumns(fk).fields,
+			targetTable: fk.targetTable
+		})),
+		fkRemoved: fkDiff.removed.map((fk) => ({
+			fields: fk.fields,
+			targetTable: fk.targetTable
+		})),
+		fkChanged: fkDiff.changed.map((fk) => ({
+			fields: require_column_diff.fkColumns(fk.desired).fields,
+			targetTable: fk.desired.targetTable,
+			details: buildFkChangeDetails({
+				...fk.desired,
+				targetFields: require_column_diff.fkColumns(fk.desired).targetFields
+			}, fk.existing)
+		}))
+	};
+}
+/**
+* Folds the live FK changes `syncForeignKeys` / `planForeignKeys` report
+* into the entry: those the snapshot-based FK diff did not already name
+* (a constraint dropped or added by hand) join `fkAdded` / `fkRemoved`.
+* `true` when any was added.
+*/
+function mergeLiveForeignKeyChanges(init, changes) {
+	if (!changes || changes.length === 0) return false;
+	const known = new Set([
+		...init.fkAdded ?? [],
+		...init.fkRemoved ?? [],
+		...init.fkChanged ?? []
+	].map((fk) => require_column_diff.fkKey(fk.fields)));
+	let merged = false;
+	for (const change of changes) {
+		const key = require_column_diff.fkKey(change.fields);
+		if (known.has(key)) continue;
+		known.add(key);
+		const fk = {
+			fields: change.fields,
+			targetTable: change.targetTable ?? ""
+		};
+		if (change.action === "add") init.fkAdded = [...init.fkAdded ?? [], fk];
+		else init.fkRemoved = [...init.fkRemoved ?? [], fk];
+		merged = true;
+	}
+	return merged;
+}
 /** The plan-shaped nullable / default change summaries of a diff. */
 function describeNullableDefaults(diff) {
 	return {
@@ -1242,11 +1407,12 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensu
 	let needsSyncColumns = false;
 	if (diff.typeChanged.length > 0 && init.status !== "error") {
 		const strategy = typeChangeStrategy(readable, diff);
+		const typeChanges = describeTypeChanges(diff);
+		if (strategy !== "none") init.typeChanges = typeChanges;
 		if (strategy === "drop") if (safe) {
-			init.typeChanges = describeTypeChanges(diff);
 			markSkipped(init, "recreate");
 			init.status = "alter";
-			const cols = init.typeChanges.map((tc) => `${tc.column}: ${tc.fromType} → ${tc.toType}`).join(", ");
+			const cols = typeChanges.map((tc) => `${tc.column}: ${tc.fromType} → ${tc.toType}`).join(", ");
 			logger.warn?.(`[schema-sync] Type change on "${name}" (${cols}) — drop-and-recreate skipped (safe mode)`);
 		} else await dropAndRecreate(adapter, init, name, ensureOpts);
 		else if (strategy === "recreate") await recreateKeepingRenames(adapter, diff, init);
@@ -1261,12 +1427,15 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensu
 		}
 	}
 	if (diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0) {
-		if (!safe && !init.recreated && init.status !== "error") if (adapter.supportsColumnModify && adapter.syncColumns) {
-			needsSyncColumns = true;
-			init.status = "alter";
-		} else if (needsDdlForNullableDefaults(adapter)) await recreateKeepingRenames(adapter, diff, init);
-		else init.status = "alter";
-		else if (init.status !== "error") {
+		if (!safe && !init.recreated && init.status !== "error") {
+			if (adapter.supportsColumnModify && adapter.syncColumns) {
+				needsSyncColumns = true;
+				init.status = "alter";
+			} else if (needsDdlForNullableDefaults(adapter)) await recreateKeepingRenames(adapter, diff, init);
+			else init.status = "alter";
+			Object.assign(init, describeNullableDefaults(diff));
+		} else if (init.status !== "error") {
+			if (!safe || !needsDdlForNullableDefaults(adapter) || init.recreated) Object.assign(init, describeNullableDefaults(diff));
 			if (safe && !init.recreated && needsDdlForNullableDefaults(adapter)) {
 				Object.assign(init, describeNullableDefaults(diff));
 				markSkipped(init, "nullable-defaults");
@@ -1361,15 +1530,6 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensu
 function retain(group, ctx) {
 	ctx.retained.push(...group.map((name) => ctx.d.removedByName.get(name)));
 }
-/** 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].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(", ");
-}
 function sortedUnique(names) {
 	return [...new Set(names)].toSorted();
 }
@@ -1641,6 +1801,7 @@ var SchemaSync = class {
 			this.assertLockHeld(heartbeat.getAbortReason);
 			const refusals = this.preflight(d, safe);
 			if (refusals.size > 0) {
+				await this.planLiveWork(d, safe);
 				const result = {
 					status: "refused",
 					schemaHash: hash,
@@ -1705,6 +1866,7 @@ var SchemaSync = class {
 				renamedFrom: plan.isRenamed ? view.renamedFrom : void 0,
 				recreated: viewRecreated(plan) || void 0,
 				cascadeFrom: plan.upstreamRecreated,
+				definitionChanged: plan.definitionChanged || void 0,
 				dependsOn: viewSources.get(view.tableName).filter((n) => tableNames.has(n) || viewNames.has(n) || externalViewNames.has(n))
 			}));
 		}
@@ -1842,10 +2004,7 @@ var SchemaSync = class {
 				init.columnsToAdd = [...readable.columnDescriptors];
 			} else if (facts.existing && facts.existing.length > 0) {
 				const typeMapper = adapter.typeMapper?.bind(adapter);
-				facts.diff = require_column_diff.computeColumnDiff(readable.columnDescriptors, facts.existing, typeMapper, {
-					snapshot: storedSnapshot,
-					nativeDefaultFns: adapter.nativeDefaultFns()
-				});
+				facts.diff = require_column_diff.computeColumnDiff(readable.columnDescriptors, facts.existing, typeMapper, columnDiffOptions(adapter, storedSnapshot));
 				this.populatePlanFromDiff(facts.diff, init, readable, safe);
 				const migration = planJsonColumnMigration(readable, facts.diff, storedSnapshot);
 				facts.jsonMigration = migration;
@@ -1864,10 +2023,7 @@ var SchemaSync = class {
 			}
 		} else {
 			const existing = require_column_diff.snapshotToExistingColumns(storedSnapshot, readable);
-			facts.diff = require_column_diff.computeColumnDiff(readable.columnDescriptors, existing, this.resolveTypeMapper(adapter), {
-				snapshot: storedSnapshot,
-				nativeDefaultFns: adapter.nativeDefaultFns()
-			});
+			facts.diff = require_column_diff.computeColumnDiff(readable.columnDescriptors, existing, this.resolveTypeMapper(adapter), columnDiffOptions(adapter, storedSnapshot));
 			this.populatePlanFromDiff(facts.diff, init, readable, safe);
 		}
 		else if (adapter.tableExists) {
@@ -1885,22 +2041,7 @@ var SchemaSync = class {
 		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) => ({
-				fields: require_column_diff.fkColumns(fk).fields,
-				targetTable: fk.targetTable
-			}));
-			init.fkRemoved = fkDiff.removed.map((fk) => ({
-				fields: fk.fields,
-				targetTable: fk.targetTable
-			}));
-			init.fkChanged = fkDiff.changed.map((fk) => ({
-				fields: require_column_diff.fkColumns(fk.desired).fields,
-				targetTable: fk.desired.targetTable,
-				details: buildFkChangeDetails({
-					...fk.desired,
-					targetFields: require_column_diff.fkColumns(fk.desired).targetFields
-				}, fk.existing)
-			}));
+			Object.assign(init, describeForeignKeyChanges(fkDiff));
 		}
 		if (facts.diff?.primaryKeyChanged) {
 			const tableName = pendingRename ? dbName : void 0;
@@ -1918,6 +2059,26 @@ var SchemaSync = class {
 		return facts;
 	}
 	/**
+	* Folds the index / foreign-key work on each live table as it is now
+	* (`planIndexes` / `planForeignKeys`) into its plan entry. Read only when
+	* plan entries are reported (`plan()`, a refused run) — a run reports what
+	* `syncIndexes` / `syncForeignKeys` did.
+	*/
+	async planLiveWork(d, safe) {
+		await Promise.all(d.tables.map((t) => this.planTableLiveWork(t, safe)));
+	}
+	async planTableLiveWork(facts, safe) {
+		const adapter = facts.readable.dbAdapter;
+		const init = facts.planEntry;
+		if (!(init.status !== "create" && init.status !== "error" && (safe || !init.recreated) && !facts.pendingRename && !runRecreatesTable(facts, safe))) return;
+		const indexChanges = await adapter.planIndexes(plannedIndexOptions(facts, safe));
+		if (indexChanges.length > 0) {
+			init.indexChanges = indexChanges;
+			init.status = "alter";
+		}
+		if (adapter.planForeignKeys && mergeLiveForeignKeyChanges(init, await adapter.planForeignKeys())) init.status = "alter";
+	}
+	/**
 	* Pure validation over the discovery facts. Every refusal is a change that
 	* no order of DDL can apply safely; the messages are user-facing.
 	*/
@@ -2283,6 +2444,7 @@ var SchemaSync = class {
 		await this.store.ensureControlTable();
 		const d = await this.discover(resolved, safe);
 		const refusals = this.preflight(d, safe);
+		await this.planLiveWork(d, safe);
 		const entries = this.buildPlanEntries(d, safe, refusals);
 		if (!force) {
 			if (await this.store.readHash() === hash) return {
@@ -2435,6 +2597,7 @@ exports.fkKey = require_column_diff.fkKey;
 exports.hasForeignKeyChanges = require_column_diff.hasForeignKeyChanges;
 exports.planSchema = planSchema;
 exports.readStoredSnapshot = readStoredSnapshot;
+exports.sameDefaultValue = require_column_diff.sameDefaultValue;
 exports.snapshotToExistingColumns = require_column_diff.snapshotToExistingColumns;
 exports.snapshotToExistingTableOptions = require_column_diff.snapshotToExistingTableOptions;
 exports.syncSchema = syncSchema;