@happyvertical/smrt-core 0.40.14 → 0.40.16

package/dist/manifest.json

@@ -1,8 +1,8 @@
 {
   "version": "1.0.0",
-  "timestamp": 1784377914316,
+  "timestamp": 1784534099516,
   "packageName": "@happyvertical/smrt-core",
-  "packageVersion": "0.40.14",
+  "packageVersion": "0.40.16",
   "objects": {
     "@happyvertical/smrt-core:SmrtClass": {
       "name": "smrtclass",

package/dist/migrations/backfill-tracker.d.ts

@@ -37,6 +37,7 @@ export declare class BackfillTracker {
     static requireExistingTable(db: DatabaseInterface): void;
     /** Forget a root initialization after a schema lifecycle reset. */
     static invalidateInitialization(db: DatabaseInterface): void;
+    private createTable;
     /**
      * Create the `_smrt_backfills` table if it doesn't already exist.
      * Safe to call repeatedly and concurrently.

package/dist/migrations/backfill-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backfill-tracker.d.ts","sourceRoot":"","sources":["../../src/migrations/backfill-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,iBAAiB,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,KAAK,EAAE,OAAO;CAI3B;AAQD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoB;IACvC,OAAO,CAAC,iBAAiB,CAA8B;gBAE3C,OAAO,EAAE,sBAAsB;IAI3C;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,CAC1B,EAAE,EAAE,iBAAiB,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI;IAOP;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI;IAOxD,mEAAmE;IACnE,MAAM,CAAC,wBAAwB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI;IAI5D;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDjC,iDAAiD;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ/C;;;;OAIG;IACG,aAAa,CACjB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAC3D,OAAO,CAAC,IAAI,CAAC;IAWhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,YAAY,CAAC,CAAC,EAClB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAC3D,OAAO,CAAC;QAAE,GAAG,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,GAAG,EAAE,IAAI,CAAC;QAAC,MAAM,EAAE,CAAC,CAAA;KAAE,CAAC;IAOnE,kDAAkD;IAC5C,WAAW,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;YAYhC,kBAAkB;IAgBhC,OAAO,CAAC,mBAAmB;CAM5B"}
+{"version":3,"file":"backfill-tracker.d.ts","sourceRoot":"","sources":["../../src/migrations/backfill-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAU5D,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,iBAAiB,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,KAAK,EAAE,OAAO;CAI3B;AAQD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoB;IACvC,OAAO,CAAC,iBAAiB,CAA8B;gBAE3C,OAAO,EAAE,sBAAsB;IAI3C;;;;OAIG;IACH,MAAM,CAAC,qBAAqB,CAC1B,EAAE,EAAE,iBAAiB,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI;IAOP;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI;IAOxD,mEAAmE;IACnE,MAAM,CAAC,wBAAwB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI;YAI9C,WAAW;IASzB;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA8CjC,iDAAiD;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ/C;;;;OAIG;IACG,aAAa,CACjB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAC3D,OAAO,CAAC,IAAI,CAAC;IAWhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACG,YAAY,CAAC,CAAC,EAClB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAC3D,OAAO,CAAC;QAAE,GAAG,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,GAAG,EAAE,IAAI,CAAC;QAAC,MAAM,EAAE,CAAC,CAAA;KAAE,CAAC;IAOnE,kDAAkD;IAC5C,WAAW,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;YAYhC,kBAAkB;IAgBhC,OAAO,CAAC,mBAAmB;CAM5B"}

package/dist/migrations/backfill-tracker.js

@@ -1,4 +1,5 @@
-import { CREATE_SMRT_BACKFILLS_TABLE } from "../system/schema.js";
+import { CREATE_SMRT_BACKFILLS_TABLE, getSystemTableDDLForEngine } from "../system/schema.js";
+import { assertPostgresSystemTimestampsCurrent, getDatabaseEngine } from "../system/compatibility.js";
 //#region src/migrations/backfill-tracker.ts
 /**
 * A tracker query proved that its inherited root initialization is stale.
@@ -42,6 +43,11 @@ var BackfillTracker = class {
 	static invalidateInitialization(db) {
 		deleteSharedInitialization(databaseTargetIdentity(db));
 	}
+	async createTable() {
+		const ddl = getSystemTableDDLForEngine(CREATE_SMRT_BACKFILLS_TABLE, getDatabaseEngine(this.db));
+		await this.db.query(ddl);
+		await assertPostgresSystemTimestampsCurrent(this.db);
+	}
 	/**
 	* Create the `_smrt_backfills` table if it doesn't already exist.
 	* Safe to call repeatedly and concurrently.
@@ -63,14 +69,14 @@ var BackfillTracker = class {
 			}
 		}
 		if (isRootDatabase(this.db)) {
-			const initialization = this.db.query(CREATE_SMRT_BACKFILLS_TABLE).then(() => void 0).catch((error) => {
+			const initialization = this.createTable().then(() => void 0).catch((error) => {
 				if (getSharedInitialization(target) === initialization) deleteSharedInitialization(target);
 				throw error;
 			});
 			setSharedInitialization(target, initialization);
 			return initialization;
 		}
-		if (!this.initializePromise) this.initializePromise = this.db.query(CREATE_SMRT_BACKFILLS_TABLE).then(() => void 0).catch((error) => {
+		if (!this.initializePromise) this.initializePromise = this.createTable().then(() => void 0).catch((error) => {
 			this.initializePromise = null;
 			throw error;
 		});

package/dist/migrations/backfill-tracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"backfill-tracker.js","names":[],"sources":["../../src/migrations/backfill-tracker.ts"],"sourcesContent":["/**\n * Tracks application-specific data backfills (not schema migrations).\n *\n * Sits next to `MigrationTracker` but is intentionally minimal — backfills\n * have no checksum, no rollback semantics, no DDL. They're \"this data\n * correction has run, don't run it again\" markers, keyed by a stable\n * backfill name the app chooses.\n *\n * Backed by the `_smrt_backfills` system table (see\n * `../system/schema.ts`). The table is created lazily on first use —\n * every public method (`isApplied`, `recordApplied`, `runIfPending`,\n * `listApplied`) awaits `initialize()` itself, so consumers never need\n * to call `initialize()` explicitly.\n */\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport { CREATE_SMRT_BACKFILLS_TABLE } from '../system/schema.js';\n\nexport interface BackfillTrackerOptions {\n  db: DatabaseInterface;\n}\n\nexport interface BackfillRecord {\n  name: string;\n  appliedAt: string;\n  description: string | null;\n  packageName: string | null;\n}\n\n/**\n * A tracker query proved that its inherited root initialization is stale.\n *\n * Transaction coordinators must roll back the current transaction, refresh\n * the root tracker outside that transaction, and retry with a fresh handle.\n */\nexport class BackfillTableUnavailableError extends Error {\n  constructor(cause: unknown) {\n    super('The shared _smrt_backfills table is unavailable.', { cause });\n    this.name = 'BackfillTableUnavailableError';\n  }\n}\n\n// Only root adapters can establish a durable shared initialization. A tracker\n// created around a transaction handle may have its DDL rolled back later, so\n// transaction-local successes must never poison this cache.\nconst initializationByObject = new WeakMap<object, Promise<void>>();\nconst inheritedInitializationByHandle = new WeakMap<object, object>();\n\nexport class BackfillTracker {\n  private readonly db: DatabaseInterface;\n  private initializePromise: Promise<void> | null = null;\n\n  constructor(options: BackfillTrackerOptions) {\n    this.db = options.db;\n  }\n\n  /**\n   * Mark a transaction handle as inheriting a table initialized durably by its\n   * root adapter. Framework transaction coordinators use this after root DDL\n   * commits so transaction-local trackers can skip redundant `CREATE TABLE`.\n   */\n  static inheritInitialization(\n    db: DatabaseInterface,\n    rootDb: DatabaseInterface,\n  ): void {\n    inheritedInitializationByHandle.set(\n      db as object,\n      databaseTargetIdentity(rootDb),\n    );\n  }\n\n  /**\n   * Suppress lazy DDL on a caller-owned transaction.\n   *\n   * Marker reads may proceed when the table already exists. A missing table\n   * raises `BackfillTableUnavailableError` so the caller can fail closed or\n   * retry with a root adapter.\n   */\n  static requireExistingTable(db: DatabaseInterface): void {\n    inheritedInitializationByHandle.set(\n      db as object,\n      databaseTargetIdentity(db),\n    );\n  }\n\n  /** Forget a root initialization after a schema lifecycle reset. */\n  static invalidateInitialization(db: DatabaseInterface): void {\n    deleteSharedInitialization(databaseTargetIdentity(db));\n  }\n\n  /**\n   * Create the `_smrt_backfills` table if it doesn't already exist.\n   * Safe to call repeatedly and concurrently.\n   */\n  async initialize(): Promise<void> {\n    if (inheritedInitializationByHandle.has(this.db as object)) {\n      return;\n    }\n\n    const target = databaseTargetIdentity(this.db);\n    const existing = getSharedInitialization(target);\n    if (existing) {\n      await existing;\n      if (!isRootDatabase(this.db)) return;\n      try {\n        await this.db.query('SELECT 1 FROM _smrt_backfills LIMIT 1');\n        return;\n      } catch (error) {\n        if (!isMissingBackfillTableError(error)) throw error;\n        if (getSharedInitialization(target) === existing) {\n          deleteSharedInitialization(target);\n        }\n        return this.initialize();\n      }\n    }\n\n    if (isRootDatabase(this.db)) {\n      const initialization = this.db\n        .query(CREATE_SMRT_BACKFILLS_TABLE)\n        .then(() => undefined)\n        .catch((error) => {\n          if (getSharedInitialization(target) === initialization) {\n            deleteSharedInitialization(target);\n          }\n          throw error;\n        });\n      setSharedInitialization(target, initialization);\n      return initialization;\n    }\n\n    if (!this.initializePromise) {\n      this.initializePromise = this.db\n        .query(CREATE_SMRT_BACKFILLS_TABLE)\n        .then(() => undefined)\n        .catch((error) => {\n          this.initializePromise = null;\n          throw error;\n        });\n    }\n    return this.initializePromise;\n  }\n\n  /** Has the backfill named `name` already run? */\n  async isApplied(name: string): Promise<boolean> {\n    const result = await this.queryBackfillTable(\n      'SELECT 1 FROM _smrt_backfills WHERE name = ? LIMIT 1',\n      name,\n    );\n    return result.rows.length > 0;\n  }\n\n  /**\n   * Record that the backfill named `name` ran. Uses INSERT ... ON CONFLICT\n   * so callers don't need to check `isApplied` first if they don't care\n   * about distinguishing \"already applied\" from \"just applied\".\n   */\n  async recordApplied(\n    name: string,\n    options: { description?: string; packageName?: string } = {},\n  ): Promise<void> {\n    await this.queryBackfillTable(\n      `INSERT INTO _smrt_backfills (name, description, package_name)\n       VALUES (?, ?, ?)\n       ON CONFLICT (name) DO NOTHING`,\n      name,\n      options.description ?? null,\n      options.packageName ?? null,\n    );\n  }\n\n  /**\n   * Convenience wrapper: if `name` hasn't been applied, run `fn` and\n   * record the result. Returns `{ ran, result }`:\n   *   - `{ ran: true,  result: T }`    — backfill was pending and `fn` ran\n   *   - `{ ran: false, result: null }` — backfill was already applied\n   *\n   * The discriminator avoids the `T | null` ambiguity an earlier shape had\n   * (a backfill that legitimately returns `null` was indistinguishable\n   * from \"already applied\"). Callers check `ran` to decide whether `fn`\n   * executed; `result` carries whatever `fn` returned.\n   *\n   * This is the common pattern an app's migrate orchestration follows:\n   * a list of `(name, runner)` pairs, each guarded by isApplied/run/record.\n   *\n   * **Single-runner only.** This is a check-then-act pattern with no\n   * locking: two processes that call `runIfPending` for the same `name`\n   * concurrently can both observe `isApplied === false`, both execute\n   * `fn`, and only then race to `recordApplied`. The `ON CONFLICT DO\n   * NOTHING` in `recordApplied` keeps the table clean but does NOT prevent\n   * `fn` from running twice. Acceptable when backfills are run from a\n   * single deploy-time migration step (the common case); if you need to\n   * fan out backfills across multiple workers, wrap the call in your own\n   * mutex (e.g. a Postgres advisory lock keyed by backfill name).\n   *\n   * **`fn` MUST be idempotent.** The order is `fn` → `recordApplied`, with\n   * no surrounding transaction. If `fn` succeeds but `recordApplied`\n   * throws (DB connection drops, transient error), the work has happened\n   * but is not recorded — the next call sees `isApplied === false` and\n   * re-runs `fn`. For non-idempotent work (slug rewrites that consume\n   * source rows, one-shot lookups), wrap the entire call in a transaction\n   * yourself or structure `fn` so a second execution is a no-op.\n   */\n  async runIfPending<T>(\n    name: string,\n    fn: () => Promise<T>,\n    options: { description?: string; packageName?: string } = {},\n  ): Promise<{ ran: false; result: null } | { ran: true; result: T }> {\n    if (await this.isApplied(name)) return { ran: false, result: null };\n    const result = await fn();\n    await this.recordApplied(name, options);\n    return { ran: true, result };\n  }\n\n  /** List every recorded backfill, oldest first. */\n  async listApplied(): Promise<BackfillRecord[]> {\n    const result = await this.queryBackfillTable(\n      'SELECT name, applied_at, description, package_name FROM _smrt_backfills ORDER BY applied_at ASC, name ASC',\n    );\n    return result.rows.map((row) => ({\n      name: String(row.name ?? ''),\n      appliedAt: normalizeAppliedAt(row.applied_at),\n      description: row.description == null ? null : String(row.description),\n      packageName: row.package_name == null ? null : String(row.package_name),\n    }));\n  }\n\n  private async queryBackfillTable(sql: string, ...params: unknown[]) {\n    await this.initialize();\n    try {\n      return await this.db.query(sql, ...params);\n    } catch (error) {\n      if (!isMissingBackfillTableError(error)) throw error;\n      const inheritedRoot = inheritedInitializationByHandle.get(\n        this.db as object,\n      );\n      this.resetInitialization(inheritedRoot);\n      if (inheritedRoot) throw new BackfillTableUnavailableError(error);\n      await this.initialize();\n      return this.db.query(sql, ...params);\n    }\n  }\n\n  private resetInitialization(inheritedRoot?: object): void {\n    this.initializePromise = null;\n    inheritedInitializationByHandle.delete(this.db as object);\n    deleteSharedInitialization(databaseTargetIdentity(this.db));\n    if (inheritedRoot) deleteSharedInitialization(inheritedRoot);\n  }\n}\n\nfunction databaseTargetIdentity(db: DatabaseInterface): object {\n  const client = db.client;\n  return client !== null &&\n    (typeof client === 'object' || typeof client === 'function')\n    ? client\n    : db;\n}\n\nfunction isRootDatabase(db: DatabaseInterface): boolean {\n  return typeof db.beginTransaction === 'function';\n}\n\nfunction getSharedInitialization(target: object): Promise<void> | undefined {\n  return initializationByObject.get(target);\n}\n\nfunction setSharedInitialization(\n  target: object,\n  initialization: Promise<void>,\n): void {\n  initializationByObject.set(target, initialization);\n}\n\nfunction deleteSharedInitialization(target: object): void {\n  initializationByObject.delete(target);\n}\n\nfunction isMissingBackfillTableError(error: unknown): boolean {\n  const pending: unknown[] = [error];\n  const seen = new Set<unknown>();\n  const missingPattern =\n    /(?:no such table|does not exist|doesn't exist|unknown table|not found)/iu;\n  while (pending.length > 0) {\n    const current = pending.pop();\n    if (typeof current === 'string') {\n      if (current.includes('_smrt_backfills') && missingPattern.test(current)) {\n        return true;\n      }\n      continue;\n    }\n    if (!current || typeof current !== 'object' || seen.has(current)) continue;\n    seen.add(current);\n    if (\n      current instanceof Error &&\n      current.message.includes('_smrt_backfills') &&\n      missingPattern.test(current.message)\n    ) {\n      return true;\n    }\n    const details = current as {\n      cause?: unknown;\n      context?: unknown;\n      details?: unknown;\n      originalError?: unknown;\n    };\n    pending.push(\n      details.cause,\n      details.context,\n      details.details,\n      details.originalError,\n    );\n    if (current instanceof AggregateError) pending.push(...current.errors);\n  }\n  return false;\n}\n\n/**\n * Convert a raw `applied_at` cell into an ISO 8601 string.\n *\n * Different DB drivers return this column in different shapes:\n *  - Postgres `node-pg` returns a JS `Date` directly.\n *  - SQLite drivers typically return the `CURRENT_TIMESTAMP` literal\n *    `'YYYY-MM-DD HH:MM:SS'` (no `T`, no timezone). V8's `Date`\n *    constructor parses this as local time, but that's\n *    implementation-defined and other runtimes may return Invalid Date.\n *  - A corrupted row could return any string.\n *\n * If the value parses to a valid Date we return `toISOString()`. If it\n * doesn't (or the column is null/empty), we fall back to the raw string —\n * better to surface a non-ISO timestamp than crash `listApplied()` with a\n * `RangeError` and take down the caller.\n */\nfunction normalizeAppliedAt(value: unknown): string {\n  if (value == null || value === '') return '';\n  const raw = String(value);\n  const parsed = new Date(raw);\n  if (Number.isNaN(parsed.getTime())) {\n    return raw;\n  }\n  return parsed.toISOString();\n}\n"],"mappings":"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"}
+{"version":3,"file":"backfill-tracker.js","names":[],"sources":["../../src/migrations/backfill-tracker.ts"],"sourcesContent":["/**\n * Tracks application-specific data backfills (not schema migrations).\n *\n * Sits next to `MigrationTracker` but is intentionally minimal — backfills\n * have no checksum, no rollback semantics, no DDL. They're \"this data\n * correction has run, don't run it again\" markers, keyed by a stable\n * backfill name the app chooses.\n *\n * Backed by the `_smrt_backfills` system table (see\n * `../system/schema.ts`). The table is created lazily on first use —\n * every public method (`isApplied`, `recordApplied`, `runIfPending`,\n * `listApplied`) awaits `initialize()` itself, so consumers never need\n * to call `initialize()` explicitly.\n */\nimport type { DatabaseInterface } from '@happyvertical/sql';\nimport {\n  assertPostgresSystemTimestampsCurrent,\n  getDatabaseEngine,\n} from '../system/compatibility.js';\nimport {\n  CREATE_SMRT_BACKFILLS_TABLE,\n  getSystemTableDDLForEngine,\n} from '../system/schema.js';\n\nexport interface BackfillTrackerOptions {\n  db: DatabaseInterface;\n}\n\nexport interface BackfillRecord {\n  name: string;\n  appliedAt: string;\n  description: string | null;\n  packageName: string | null;\n}\n\n/**\n * A tracker query proved that its inherited root initialization is stale.\n *\n * Transaction coordinators must roll back the current transaction, refresh\n * the root tracker outside that transaction, and retry with a fresh handle.\n */\nexport class BackfillTableUnavailableError extends Error {\n  constructor(cause: unknown) {\n    super('The shared _smrt_backfills table is unavailable.', { cause });\n    this.name = 'BackfillTableUnavailableError';\n  }\n}\n\n// Only root adapters can establish a durable shared initialization. A tracker\n// created around a transaction handle may have its DDL rolled back later, so\n// transaction-local successes must never poison this cache.\nconst initializationByObject = new WeakMap<object, Promise<void>>();\nconst inheritedInitializationByHandle = new WeakMap<object, object>();\n\nexport class BackfillTracker {\n  private readonly db: DatabaseInterface;\n  private initializePromise: Promise<void> | null = null;\n\n  constructor(options: BackfillTrackerOptions) {\n    this.db = options.db;\n  }\n\n  /**\n   * Mark a transaction handle as inheriting a table initialized durably by its\n   * root adapter. Framework transaction coordinators use this after root DDL\n   * commits so transaction-local trackers can skip redundant `CREATE TABLE`.\n   */\n  static inheritInitialization(\n    db: DatabaseInterface,\n    rootDb: DatabaseInterface,\n  ): void {\n    inheritedInitializationByHandle.set(\n      db as object,\n      databaseTargetIdentity(rootDb),\n    );\n  }\n\n  /**\n   * Suppress lazy DDL on a caller-owned transaction.\n   *\n   * Marker reads may proceed when the table already exists. A missing table\n   * raises `BackfillTableUnavailableError` so the caller can fail closed or\n   * retry with a root adapter.\n   */\n  static requireExistingTable(db: DatabaseInterface): void {\n    inheritedInitializationByHandle.set(\n      db as object,\n      databaseTargetIdentity(db),\n    );\n  }\n\n  /** Forget a root initialization after a schema lifecycle reset. */\n  static invalidateInitialization(db: DatabaseInterface): void {\n    deleteSharedInitialization(databaseTargetIdentity(db));\n  }\n\n  private async createTable(): Promise<void> {\n    const ddl = getSystemTableDDLForEngine(\n      CREATE_SMRT_BACKFILLS_TABLE,\n      getDatabaseEngine(this.db),\n    );\n    await this.db.query(ddl);\n    await assertPostgresSystemTimestampsCurrent(this.db);\n  }\n\n  /**\n   * Create the `_smrt_backfills` table if it doesn't already exist.\n   * Safe to call repeatedly and concurrently.\n   */\n  async initialize(): Promise<void> {\n    if (inheritedInitializationByHandle.has(this.db as object)) {\n      return;\n    }\n\n    const target = databaseTargetIdentity(this.db);\n    const existing = getSharedInitialization(target);\n    if (existing) {\n      await existing;\n      if (!isRootDatabase(this.db)) return;\n      try {\n        await this.db.query('SELECT 1 FROM _smrt_backfills LIMIT 1');\n        return;\n      } catch (error) {\n        if (!isMissingBackfillTableError(error)) throw error;\n        if (getSharedInitialization(target) === existing) {\n          deleteSharedInitialization(target);\n        }\n        return this.initialize();\n      }\n    }\n\n    if (isRootDatabase(this.db)) {\n      const initialization = this.createTable()\n        .then(() => undefined)\n        .catch((error) => {\n          if (getSharedInitialization(target) === initialization) {\n            deleteSharedInitialization(target);\n          }\n          throw error;\n        });\n      setSharedInitialization(target, initialization);\n      return initialization;\n    }\n\n    if (!this.initializePromise) {\n      this.initializePromise = this.createTable()\n        .then(() => undefined)\n        .catch((error) => {\n          this.initializePromise = null;\n          throw error;\n        });\n    }\n    return this.initializePromise;\n  }\n\n  /** Has the backfill named `name` already run? */\n  async isApplied(name: string): Promise<boolean> {\n    const result = await this.queryBackfillTable(\n      'SELECT 1 FROM _smrt_backfills WHERE name = ? LIMIT 1',\n      name,\n    );\n    return result.rows.length > 0;\n  }\n\n  /**\n   * Record that the backfill named `name` ran. Uses INSERT ... ON CONFLICT\n   * so callers don't need to check `isApplied` first if they don't care\n   * about distinguishing \"already applied\" from \"just applied\".\n   */\n  async recordApplied(\n    name: string,\n    options: { description?: string; packageName?: string } = {},\n  ): Promise<void> {\n    await this.queryBackfillTable(\n      `INSERT INTO _smrt_backfills (name, description, package_name)\n       VALUES (?, ?, ?)\n       ON CONFLICT (name) DO NOTHING`,\n      name,\n      options.description ?? null,\n      options.packageName ?? null,\n    );\n  }\n\n  /**\n   * Convenience wrapper: if `name` hasn't been applied, run `fn` and\n   * record the result. Returns `{ ran, result }`:\n   *   - `{ ran: true,  result: T }`    — backfill was pending and `fn` ran\n   *   - `{ ran: false, result: null }` — backfill was already applied\n   *\n   * The discriminator avoids the `T | null` ambiguity an earlier shape had\n   * (a backfill that legitimately returns `null` was indistinguishable\n   * from \"already applied\"). Callers check `ran` to decide whether `fn`\n   * executed; `result` carries whatever `fn` returned.\n   *\n   * This is the common pattern an app's migrate orchestration follows:\n   * a list of `(name, runner)` pairs, each guarded by isApplied/run/record.\n   *\n   * **Single-runner only.** This is a check-then-act pattern with no\n   * locking: two processes that call `runIfPending` for the same `name`\n   * concurrently can both observe `isApplied === false`, both execute\n   * `fn`, and only then race to `recordApplied`. The `ON CONFLICT DO\n   * NOTHING` in `recordApplied` keeps the table clean but does NOT prevent\n   * `fn` from running twice. Acceptable when backfills are run from a\n   * single deploy-time migration step (the common case); if you need to\n   * fan out backfills across multiple workers, wrap the call in your own\n   * mutex (e.g. a Postgres advisory lock keyed by backfill name).\n   *\n   * **`fn` MUST be idempotent.** The order is `fn` → `recordApplied`, with\n   * no surrounding transaction. If `fn` succeeds but `recordApplied`\n   * throws (DB connection drops, transient error), the work has happened\n   * but is not recorded — the next call sees `isApplied === false` and\n   * re-runs `fn`. For non-idempotent work (slug rewrites that consume\n   * source rows, one-shot lookups), wrap the entire call in a transaction\n   * yourself or structure `fn` so a second execution is a no-op.\n   */\n  async runIfPending<T>(\n    name: string,\n    fn: () => Promise<T>,\n    options: { description?: string; packageName?: string } = {},\n  ): Promise<{ ran: false; result: null } | { ran: true; result: T }> {\n    if (await this.isApplied(name)) return { ran: false, result: null };\n    const result = await fn();\n    await this.recordApplied(name, options);\n    return { ran: true, result };\n  }\n\n  /** List every recorded backfill, oldest first. */\n  async listApplied(): Promise<BackfillRecord[]> {\n    const result = await this.queryBackfillTable(\n      'SELECT name, applied_at, description, package_name FROM _smrt_backfills ORDER BY applied_at ASC, name ASC',\n    );\n    return result.rows.map((row) => ({\n      name: String(row.name ?? ''),\n      appliedAt: normalizeAppliedAt(row.applied_at),\n      description: row.description == null ? null : String(row.description),\n      packageName: row.package_name == null ? null : String(row.package_name),\n    }));\n  }\n\n  private async queryBackfillTable(sql: string, ...params: unknown[]) {\n    await this.initialize();\n    try {\n      return await this.db.query(sql, ...params);\n    } catch (error) {\n      if (!isMissingBackfillTableError(error)) throw error;\n      const inheritedRoot = inheritedInitializationByHandle.get(\n        this.db as object,\n      );\n      this.resetInitialization(inheritedRoot);\n      if (inheritedRoot) throw new BackfillTableUnavailableError(error);\n      await this.initialize();\n      return this.db.query(sql, ...params);\n    }\n  }\n\n  private resetInitialization(inheritedRoot?: object): void {\n    this.initializePromise = null;\n    inheritedInitializationByHandle.delete(this.db as object);\n    deleteSharedInitialization(databaseTargetIdentity(this.db));\n    if (inheritedRoot) deleteSharedInitialization(inheritedRoot);\n  }\n}\n\nfunction databaseTargetIdentity(db: DatabaseInterface): object {\n  const client = db.client;\n  return client !== null &&\n    (typeof client === 'object' || typeof client === 'function')\n    ? client\n    : db;\n}\n\nfunction isRootDatabase(db: DatabaseInterface): boolean {\n  return typeof db.beginTransaction === 'function';\n}\n\nfunction getSharedInitialization(target: object): Promise<void> | undefined {\n  return initializationByObject.get(target);\n}\n\nfunction setSharedInitialization(\n  target: object,\n  initialization: Promise<void>,\n): void {\n  initializationByObject.set(target, initialization);\n}\n\nfunction deleteSharedInitialization(target: object): void {\n  initializationByObject.delete(target);\n}\n\nfunction isMissingBackfillTableError(error: unknown): boolean {\n  const pending: unknown[] = [error];\n  const seen = new Set<unknown>();\n  const missingPattern =\n    /(?:no such table|does not exist|doesn't exist|unknown table|not found)/iu;\n  while (pending.length > 0) {\n    const current = pending.pop();\n    if (typeof current === 'string') {\n      if (current.includes('_smrt_backfills') && missingPattern.test(current)) {\n        return true;\n      }\n      continue;\n    }\n    if (!current || typeof current !== 'object' || seen.has(current)) continue;\n    seen.add(current);\n    if (\n      current instanceof Error &&\n      current.message.includes('_smrt_backfills') &&\n      missingPattern.test(current.message)\n    ) {\n      return true;\n    }\n    const details = current as {\n      cause?: unknown;\n      context?: unknown;\n      details?: unknown;\n      originalError?: unknown;\n    };\n    pending.push(\n      details.cause,\n      details.context,\n      details.details,\n      details.originalError,\n    );\n    if (current instanceof AggregateError) pending.push(...current.errors);\n  }\n  return false;\n}\n\n/**\n * Convert a raw `applied_at` cell into an ISO 8601 string.\n *\n * Different DB drivers return this column in different shapes:\n *  - Postgres `node-pg` returns a JS `Date` directly.\n *  - SQLite drivers typically return the `CURRENT_TIMESTAMP` literal\n *    `'YYYY-MM-DD HH:MM:SS'` (no `T`, no timezone). V8's `Date`\n *    constructor parses this as local time, but that's\n *    implementation-defined and other runtimes may return Invalid Date.\n *  - A corrupted row could return any string.\n *\n * If the value parses to a valid Date we return `toISOString()`. If it\n * doesn't (or the column is null/empty), we fall back to the raw string —\n * better to surface a non-ISO timestamp than crash `listApplied()` with a\n * `RangeError` and take down the caller.\n */\nfunction normalizeAppliedAt(value: unknown): string {\n  if (value == null || value === '') return '';\n  const raw = String(value);\n  const parsed = new Date(raw);\n  if (Number.isNaN(parsed.getTime())) {\n    return raw;\n  }\n  return parsed.toISOString();\n}\n"],"mappings":"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"}

package/dist/migrations/differ.d.ts

@@ -28,6 +28,15 @@ export interface DiffOptions {
      * flavored SQL on a connection whose caller meant Postgres or DuckDB.
      */
     engineHint?: string;
+    /**
+     * Explicit confirmation that every historical writer of legacy PostgreSQL
+     * Date columns used UTC wall times. Without this acknowledgement,
+     * TIMESTAMP/TEXT/JSON to TIMESTAMPTZ drift is reported as manual rather
+     * than reinterpreted automatically.
+     */
+    postgresTimestampMigration?: {
+        legacyTimezone: 'UTC';
+    };
 }
 /**
  * Normalize a partial-index `WHERE` predicate so semantically-identical
@@ -196,6 +205,9 @@ export declare class SchemaComparer {
      * - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)
      * - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings
      *   before newer manifests normalized the column type.
+     * - PostgreSQL TIMESTAMP→TIMESTAMPTZ: Legacy SMRT Date values were written
+     *   as UTC ISO wall times, so interpreting the naive value as UTC preserves
+     *   the originally supplied instant.
      * - INTEGER→REAL: Safe widening of integer to floating point
      * - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for
      *   legacy integer columns that were previously stored as text/real.
@@ -224,6 +236,12 @@ export declare class SchemaComparer {
      * generated migration must fail before the ALTER can silently change data.
      */
     private generatePostgresIntegerPreflightSQL;
+    /**
+     * Require a UTC migration session before reattaching the offset discarded by
+     * legacy PostgreSQL TIMESTAMP columns. This is a guardrail, not provenance:
+     * operators must also confirm historical default/raw writers used UTC.
+     */
+    private generatePostgresTimestampPreflightSQL;
     private quoteLiteral;
     /**
      * Generate SQL for adding a column

package/dist/migrations/differ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAGV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,YAAY,CAAC;AA8BxE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;;;OAOG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iDAAiD;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAsCrE;AAiBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAoC;gBAE3C,EAAE,EAAE,iBAAiB,EAAE,OAAO,GAAE,WAAgB;IAsB5D;;OAEG;IACG,OAAO,CACX,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAChD,OAAO,CAAC,UAAU,CAAC;IA4CtB;;OAEG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,EAAE,CAAC;IAkC1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwItB,OAAO,CAAC,0BAA0B;IAkBlC,OAAO,CAAC,gCAAgC;IAexC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,CAAC,cAAc;IA2KtB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,iBAAiB;IAezB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAI9B;;;;;;;;;;;;;;;;;;;OAmBG;YACW,oBAAoB;IAmDlC;;OAEG;YACW,iBAAiB;IAoB/B;;OAEG;IACH,OAAO,CAAC,aAAa;IAmDrB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAoI9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IAgB3C,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiD5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,iBAAiB,EACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAI9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAgBzD"}
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"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"}

package/dist/migrations/differ.js

@@ -466,13 +466,14 @@ var SchemaComparer = class {
 	* Normalize SQL types for comparison
 	*/
 	normalizeType(type) {
-		const upper = type.toUpperCase().trim();
+		const upper = type.toUpperCase().trim().replace(/\(\s*\d+\s*\)/g, "");
 		if (/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT)$/i.test(upper)) return "INTEGER";
 		if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR)/i.test(upper)) return "TEXT";
 		if (/^UUID$/i.test(upper)) return "UUID";
 		if (/^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(upper)) return "REAL";
 		if (/^(BOOLEAN|BOOL)/i.test(upper)) return "BOOLEAN";
-		if (/^(DATETIME|TIMESTAMP|DATE|TIME)/i.test(upper)) return "TIMESTAMP";
+		if (/^(TIMESTAMPTZ|TIMESTAMP\s+WITH\s+TIME\s+ZONE)$/i.test(upper)) return "TIMESTAMPTZ";
+		if (/^(DATETIME|TIMESTAMP(?:\s+WITHOUT\s+TIME\s+ZONE)?|DATE|TIME)$/i.test(upper)) return "TIMESTAMP";
 		if (/^(BLOB|BINARY|BYTEA)/i.test(upper)) return "BLOB";
 		if (/^(JSON|JSONB)/i.test(upper)) return "JSON";
 		return upper;
@@ -484,6 +485,9 @@ var SchemaComparer = class {
 	* - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)
 	* - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings
 	*   before newer manifests normalized the column type.
+	* - PostgreSQL TIMESTAMP→TIMESTAMPTZ: Legacy SMRT Date values were written
+	*   as UTC ISO wall times, so interpreting the naive value as UTC preserves
+	*   the originally supplied instant.
 	* - INTEGER→REAL: Safe widening of integer to floating point
 	* - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for
 	*   legacy integer columns that were previously stored as text/real.
@@ -495,12 +499,17 @@ var SchemaComparer = class {
 	isCompatibleTypeUpgrade(manifestType, dbType) {
 		const manifest = this.normalizeType(manifestType);
 		const db = this.normalizeType(dbType);
+		if (this.engine === "postgres" && manifest === "TIMESTAMP" && [
+			"TIMESTAMP",
+			"TEXT",
+			"JSON"
+		].includes(db) && this.ddlStrategy.mapType("TIMESTAMP") === "TIMESTAMPTZ") return this.options.postgresTimestampMigration?.legacyTimezone === "UTC";
 		if (manifest === "JSON" && db === "TEXT") return true;
 		if (manifest === "TEXT" && db === "JSON") return true;
 		if (manifest === "TEXT" && db === "UUID") return true;
 		if (manifest === "REAL" && db === "INTEGER") return true;
 		if (this.engine === "postgres" && manifest === "INTEGER" && (db === "TEXT" || db === "REAL")) return true;
-		if (manifest === "TIMESTAMP" && (db === "TEXT" || db === "JSON")) return true;
+		if (manifest === "TIMESTAMP" && (db === "TEXT" || db === "JSON") && this.engine !== "postgres") return true;
 		return false;
 	}
 	/**
@@ -524,7 +533,11 @@ var SchemaComparer = class {
 			case "postgres": {
 				const manifestNormalized = this.normalizeType(manifestType);
 				const dbNormalized = this.normalizeType(dbType);
-				const preflightSQL = manifestNormalized === "INTEGER" && (dbNormalized === "TEXT" || dbNormalized === "REAL") ? this.generatePostgresIntegerPreflightSQL(quotedTable, quotedCol, tableName, colName, dbNormalized) : null;
+				const preflightSQL = manifestNormalized === "INTEGER" && (dbNormalized === "TEXT" || dbNormalized === "REAL") ? this.generatePostgresIntegerPreflightSQL(quotedTable, quotedCol, tableName, colName, dbNormalized) : manifestNormalized === "TIMESTAMP" && [
+					"TIMESTAMP",
+					"TEXT",
+					"JSON"
+				].includes(dbNormalized) && this.normalizeType(targetType) === "TIMESTAMPTZ" ? this.generatePostgresTimestampPreflightSQL(tableName, colName) : null;
 				const clauses = [];
 				if (colDef.defaultValue !== void 0) clauses.push(`ALTER COLUMN ${quotedCol} DROP DEFAULT`);
 				let typeClause = `ALTER COLUMN ${quotedCol} TYPE ${targetType}`;
@@ -533,7 +546,8 @@ var SchemaComparer = class {
 				else if (manifestNormalized === "TEXT" && dbNormalized === "UUID") typeClause += ` USING ${quotedCol}::text`;
 				else if (manifestNormalized === "INTEGER" && dbNormalized === "TEXT") typeClause += ` USING trim(${quotedCol}::text)::integer`;
 				else if (manifestNormalized === "INTEGER" && dbNormalized === "REAL") typeClause += ` USING ${quotedCol}::integer`;
-				else if (manifestNormalized === "TIMESTAMP" && (dbNormalized === "TEXT" || dbNormalized === "JSON")) typeClause += ` USING NULLIF(NULLIF(trim(both '"' from ${quotedCol}::text), ''), 'null')::timestamp`;
+				else if (manifestNormalized === "TIMESTAMP" && (dbNormalized === "TEXT" || dbNormalized === "JSON")) typeClause += ` USING NULLIF(NULLIF(trim(both '"' from ${quotedCol}::text), ''), 'null')::timestamptz`;
+				else if (manifestNormalized === "TIMESTAMP" && dbNormalized === "TIMESTAMP" && this.normalizeType(targetType) === "TIMESTAMPTZ") typeClause += ` USING ${quotedCol} AT TIME ZONE 'UTC'`;
 				clauses.push(typeClause);
 				if (colDef.defaultValue !== void 0) {
 					const formattedDefault = this.ddlStrategy.formatDefaultValue(colDef.defaultValue, validatedType);
@@ -566,6 +580,15 @@ var SchemaComparer = class {
 		const message = `Cannot convert ${tableName}.${colName} to INTEGER: found non-integer values`;
 		return `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${quotedTable} WHERE ${invalidCondition}) THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;
 	}
+	/**
+	* Require a UTC migration session before reattaching the offset discarded by
+	* legacy PostgreSQL TIMESTAMP columns. This is a guardrail, not provenance:
+	* operators must also confirm historical default/raw writers used UTC.
+	*/
+	generatePostgresTimestampPreflightSQL(tableName, colName) {
+		const message = `Cannot convert ${tableName}.${colName} to TIMESTAMPTZ outside a UTC PostgreSQL session; confirm historical writers used UTC and SET TIME ZONE UTC`;
+		return `DO $$ BEGIN IF upper(current_setting('TimeZone')) NOT IN ('UTC', 'ETC/UTC', 'GMT') THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;
+	}
 	quoteLiteral(value) {
 		return `'${value.replace(/'/g, "''")}'`;
 	}

package/dist/migrations/differ.js.map

@@ -1 +1 @@
-{"version":3,"file":"differ.js","names":[],"sources":["../../src/migrations/differ.ts"],"sourcesContent":["/**\n * Schema Differ\n *\n * Compares manifest schemas to database schemas and generates\n * a SchemaDiff with the differences.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport { detectEngine, getDDLStrategy } from '../schema/ddl/index.js';\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type {\n  ColumnDefinition,\n  IndexDefinition,\n  SchemaChange,\n  SchemaDefinition,\n  SchemaDiff,\n  SQLDataType,\n} from '../schema/types.js';\nimport { isJsonPathIndex, renderIndexTarget } from '../schema/utils.js';\nimport type { DatabaseInterface, SqlTableSchemaInfo } from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Valid SQLDataType values for validation\n */\nconst VALID_SQL_DATA_TYPES: Set<SQLDataType> = new Set([\n  'TEXT',\n  'INTEGER',\n  'REAL',\n  'BLOB',\n  'BOOLEAN',\n  'JSON',\n  'TIMESTAMP',\n  'UUID',\n]);\n\ninterface GeneratedTypeUpgradeSQL {\n  sql: string;\n  statements?: string[];\n}\n\n/**\n * Check if a string is a valid SQLDataType\n */\nfunction isValidSQLDataType(type: string): type is SQLDataType {\n  return VALID_SQL_DATA_TYPES.has(type as SQLDataType);\n}\n\n/**\n * Options for schema comparison\n */\nexport interface DiffOptions {\n  /** Include dropped tables in diff (default: false for safety) */\n  includeDroppedTables?: boolean;\n  /** Include dropped columns in diff (default: false for safety) */\n  includeDroppedColumns?: boolean;\n  /**\n   * Drop indexes that exist in the database but are absent from the manifest\n   * AND are not functionally equivalent to anything in the manifest. Default:\n   * false. The differ always skips primary-key indexes (`*_pkey`) and the\n   * implicit indexes that PostgreSQL creates from inline UNIQUE constraints\n   * (`*_key`) — those are owned by table-level constraints, not by the\n   * index list, and dropping them here would break the constraint.\n   */\n  includeDroppedIndexes?: boolean;\n  /** Ignore type mismatches (just log warnings) */\n  ignoreTypeMismatches?: boolean;\n  /**\n   * Explicit engine hint forwarded to `detectEngine` when picking the DDL\n   * strategy used for *existing-table* SQL (ALTER/CREATE INDEX/etc.). Use\n   * this when `db.url` is empty or ambiguous (e.g. JSON adapter, in-memory\n   * wrappers where the URL lives on `db.config?.url`). Without it the\n   * comparer falls back to URL-only detection, which can produce SQLite-\n   * flavored SQL on a connection whose caller meant Postgres or DuckDB.\n   */\n  engineHint?: string;\n}\n\n/**\n * Suffix patterns for indexes that the differ refuses to drop.\n * - `_pkey`: PostgreSQL primary key implicit index.\n * - `_key`: PostgreSQL implicit index for inline `UNIQUE (...)` table\n *   constraints. Dropping these by name does not drop the underlying\n *   constraint, and dropping the constraint requires a separate DDL path\n *   (`ALTER TABLE ... DROP CONSTRAINT`) the differ does not emit today.\n */\nconst PROTECTED_INDEX_SUFFIXES = ['_pkey', '_key'];\n\nfunction isProtectedDbIndexName(name: string): boolean {\n  return PROTECTED_INDEX_SUFFIXES.some((suffix) => name.endsWith(suffix));\n}\n\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & {\n    config?: { url?: string };\n  };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\n/**\n * Normalize a partial-index `WHERE` predicate so semantically-identical\n * clauses from different sources compare equal (issue #1692).\n *\n * The manifest stores predicates roughly as written (`_meta_type = 'Article'`),\n * SQLite/DuckDB echo the original CREATE INDEX text verbatim, and PostgreSQL\n * re-renders them with type casts and extra parentheses\n * (`((_meta_type)::text = 'Article'::text)`). Normalization:\n *\n * - strips a leading `WHERE` keyword,\n * - removes PostgreSQL `::type` casts (single-word type names — the only kind\n *   SMRT-generated partial predicates produce, e.g. `_meta_type::text`),\n * - removes parentheses (SMRT only emits simple `col = 'literal'` predicates,\n *   so grouping carries no meaning here),\n * - lowercases everything OUTSIDE single-quoted string literals (SQL keywords\n *   and identifiers are case-insensitive; literals such as STI discriminator\n *   class names are case-sensitive, so they are preserved verbatim),\n * - collapses whitespace and tightens spacing around comparison operators.\n *\n * Returns '' for an absent/empty predicate (i.e. a non-partial index).\n */\nexport function normalizeIndexPredicate(where?: string | null): string {\n  if (!where) return '';\n  const stripped = where.trim().replace(/^WHERE\\s+/i, '');\n  if (!stripped) return '';\n\n  let out = '';\n  let i = 0;\n  while (i < stripped.length) {\n    if (stripped[i] === \"'\") {\n      // Consume a single-quoted string literal verbatim, honoring the SQL\n      // `''` escape for an embedded quote.\n      let literal = \"'\";\n      i++;\n      while (i < stripped.length) {\n        if (stripped[i] === \"'\") {\n          if (stripped[i + 1] === \"'\") {\n            literal += \"''\";\n            i += 2;\n            continue;\n          }\n          literal += \"'\";\n          i++;\n          break;\n        }\n        literal += stripped[i];\n        i++;\n      }\n      out += literal;\n    } else {\n      let run = '';\n      while (i < stripped.length && stripped[i] !== \"'\") {\n        run += stripped[i];\n        i++;\n      }\n      out += normalizeNonLiteralPredicateRun(run);\n    }\n  }\n  return out;\n}\n\n/**\n * Normalize the non-literal portion of a predicate (everything outside a\n * single-quoted string literal). Type casts and parentheses are dropped,\n * keywords/identifiers are lowercased, and whitespace is canonicalized.\n */\nfunction normalizeNonLiteralPredicateRun(run: string): string {\n  return run\n    .replace(/::[A-Za-z_]\\w*/g, '') // drop single-word PostgreSQL type casts\n    .replace(/[()]/g, '') // drop parentheses\n    .toLowerCase()\n    .replace(/\\s+/g, ' ')\n    .replace(/\\s*([=<>!]+)\\s*/g, '$1') // tighten comparison operators\n    .trim();\n}\n\n/**\n * Extract the normalized partial-index predicate from a `CREATE INDEX`\n * statement — the `WHERE` tail that follows the column-list close paren.\n * Works for both SQLite/DuckDB `sqlite_master.sql` text and PostgreSQL\n * `pg_indexes.indexdef`. Returns '' for a non-partial index.\n */\nexport function extractIndexPredicate(createIndexSql: string): string {\n  // The predicate is the tail after the column-list ')': `... (cols) WHERE x`.\n  // Anchoring on `) WHERE` (rather than a bare `WHERE`) avoids matching a\n  // column literally named \"where\" inside the indexed column list.\n  const match = createIndexSql.match(/\\)\\s*WHERE\\s+([\\s\\S]+?)\\s*;?\\s*$/i);\n  if (!match) return '';\n  return normalizeIndexPredicate(match[1]);\n}\n\n/**\n * SchemaComparer class for comparing manifest schemas to database\n */\nexport class SchemaComparer {\n  private db: DatabaseInterface;\n  private options: DiffOptions;\n  private engine: DatabaseEngine;\n  private ddlStrategy: ReturnType<typeof getDDLStrategy>;\n\n  constructor(db: DatabaseInterface, options: DiffOptions = {}) {\n    this.db = db;\n    this.options = {\n      includeDroppedTables: false,\n      includeDroppedColumns: false,\n      includeDroppedIndexes: false,\n      ignoreTypeMismatches: false,\n      ...options,\n    };\n    // Use the shared detectEngine utility for consistent detection.\n    // Handles :memory:, .json, and other edge cases. The JSON adapter is\n    // detected structurally (it exposes `exportTable`) because its url can be\n    // empty; otherwise fall back to URL-based detection, where `engineHint`\n    // lets callers override when `db.url` is empty or points at an adapter\n    // whose engine isn't obvious from the URL alone (some in-memory wrappers).\n    this.engine =\n      typeof (this.db as { exportTable?: unknown }).exportTable === 'function'\n        ? 'json'\n        : detectEngine(resolveDatabaseUrl(this.db), this.options.engineHint);\n    this.ddlStrategy = getDDLStrategy(this.engine);\n  }\n\n  /**\n   * Compare manifest schemas to database and return differences\n   */\n  async compare(\n    manifestSchemas: Record<string, SchemaDefinition>,\n  ): Promise<SchemaDiff> {\n    const diff: SchemaDiff = {\n      added_tables: [],\n      dropped_tables: [],\n      changes: [],\n      has_changes: false,\n    };\n\n    // Get list of existing tables\n    const existingTables = await this.getExistingTables();\n\n    // Check each manifest schema against database\n    for (const [tableName, schema] of Object.entries(manifestSchemas)) {\n      if (!existingTables.has(tableName)) {\n        // Table doesn't exist - add to added_tables\n        diff.added_tables.push(schema);\n        diff.has_changes = true;\n      } else {\n        // Table exists - compare columns and indexes\n        const tableChanges = await this.compareTable(tableName, schema);\n        if (tableChanges.length > 0) {\n          diff.changes.push(...tableChanges);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    // Check for dropped tables (if enabled)\n    if (this.options.includeDroppedTables) {\n      for (const tableName of existingTables) {\n        // Skip system tables\n        if (tableName.startsWith('_smrt_') || tableName.startsWith('sqlite_')) {\n          continue;\n        }\n        if (!manifestSchemas[tableName]) {\n          diff.dropped_tables.push(tableName);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    return diff;\n  }\n\n  /**\n   * Compare a single table's schema to manifest\n   */\n  async compareTable(\n    tableName: string,\n    manifest: SchemaDefinition,\n  ): Promise<SchemaChange[]> {\n    const changes: SchemaChange[] = [];\n\n    // Get current table schema from database\n    const dbSchema = await this.db.getTableSchema?.(tableName);\n    if (!dbSchema) {\n      // Table doesn't exist - this is an add_table case\n      return changes;\n    }\n\n    // Compare columns\n    const columnChanges = this.compareColumns(tableName, manifest, dbSchema);\n    changes.push(...columnChanges);\n\n    // Partial-index predicates are not surfaced by `getTableSchema()` (the\n    // @happyvertical/sql introspection returns only name/columns/unique), so\n    // introspect them separately. Without this, two indexes on the same\n    // column(s) that differ only by their WHERE clause — e.g. distinct STI\n    // child partial indexes — would compare equal and the differ would miss\n    // adds/drops/changes of the predicate (issue #1692).\n    const dbIndexPredicates = await this.getDbIndexPredicates(tableName);\n\n    // Compare indexes\n    const indexChanges = this.compareIndexes(\n      tableName,\n      manifest,\n      dbSchema,\n      dbIndexPredicates,\n    );\n    changes.push(...indexChanges);\n\n    return changes;\n  }\n\n  /**\n   * Compare columns between manifest and database\n   */\n  private compareColumns(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n    const dbColumnNames = new Set(Object.keys(dbSchema.columns));\n\n    // Check for new and modified columns\n    for (const [colName, colDef] of Object.entries(manifest.columns)) {\n      if (!dbColumnNames.has(colName)) {\n        // Column doesn't exist - add it\n        changes.push({\n          type: 'add_column',\n          table: tableName,\n          name: colName,\n          column: colDef,\n          sql: this.generateAddColumnSQL(tableName, colName, colDef),\n        });\n      } else {\n        // Column exists - check for type mismatch\n        const dbCol = dbSchema.columns[colName];\n\n        // Map manifest's abstract type to engine-specific type\n        // e.g., JSON → TEXT for SQLite, JSON → JSONB for PostgreSQL\n        // Validate the manifest type before mapping\n        const manifestType = colDef.type;\n        if (!isValidSQLDataType(manifestType)) {\n          // Invalid manifest type - treat as TEXT (safest fallback)\n          logger.warn(\n            `[SchemaComparer] Invalid manifest type \"${manifestType}\" for ${tableName}.${colName}, treating as TEXT`,\n          );\n        }\n        const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n          ? manifestType\n          : 'TEXT';\n        const expectedEngineType = this.ddlStrategy.mapType(validatedType);\n        const normalizedExpected = this.normalizeType(expectedEngineType);\n        const normalizedActual = this.normalizeType(dbCol.type);\n\n        // R11: native `uuid` and `text` are interchangeable for SMRT-owned\n        // identifiers/references, but not for arbitrary provenance text. Keep\n        // the tolerance directional:\n        //   - manifest UUID + DB text is tolerated for structural ID/ref\n        //     columns so old deployments are not forced into native UUID.\n        //   - manifest TEXT + DB uuid is tolerated only for structural ID/ref\n        //     columns that are intentionally UUID-compatible.\n        // Plain TEXT columns with DB uuid now surface as repairable drift.\n        const isUuidTextEquivalent = this.isUuidTextEquivalentColumn(\n          colName,\n          colDef,\n          normalizedExpected,\n          normalizedActual,\n        );\n\n        // #1335: native `json`/`jsonb` (DB) and `text` (manifest) are\n        // interchangeable for SMRT — the convention is to serialize JSON values\n        // into TEXT columns, and a native-json column already holds exactly that\n        // data. So the differ must NOT flag a json<->text difference in EITHER\n        // direction:\n        //   - manifest TEXT vs DB json   (native-json column, text-convention manifest)\n        //   - manifest JSON vs DB text   (the canary case: an enum/plain field\n        //     mis-inferred as JSON by a downstream scanner, sitting on a real\n        //     `text` column holding bare values like 'active')\n        // Generating an ALTER here is pure churn at best and data-destroying at\n        // worst: `status::jsonb` on a column holding 'active' raises\n        // \"invalid input syntax for type json\" and aborts the whole atomic\n        // migration. Like the uuid/text tolerance, this lives at the equality\n        // gate only (not in `normalizeType`) so `isCompatibleTypeUpgrade` still\n        // treats JSON and TEXT as distinct buckets for OTHER upgrade paths.\n        const isJsonTextEquivalent =\n          (normalizedExpected === 'JSON' && normalizedActual === 'TEXT') ||\n          (normalizedExpected === 'TEXT' && normalizedActual === 'JSON');\n\n        if (\n          normalizedExpected !== normalizedActual &&\n          !isUuidTextEquivalent &&\n          !isJsonTextEquivalent\n        ) {\n          // Check if this is a safe type upgrade that SMRT can handle\n          // Since SMRT owns the data lifecycle, we know the intent from the manifest\n          if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {\n            // Generate type upgrade SQL\n            const generatedSQL = this.generateTypeUpgradeSQL(\n              tableName,\n              colName,\n              colDef,\n              dbCol.type,\n            );\n            changes.push({\n              type: 'type_upgrade',\n              table: tableName,\n              name: colName,\n              column: colDef,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n              sql: generatedSQL.sql,\n              ...(generatedSQL.statements\n                ? { sqlStatements: generatedSQL.statements }\n                : {}),\n            });\n          } else if (!this.options.ignoreTypeMismatches) {\n            changes.push({\n              type: 'type_mismatch',\n              table: tableName,\n              name: colName,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n            });\n          }\n        }\n      }\n    }\n\n    // Check for dropped columns (if enabled)\n    if (this.options.includeDroppedColumns) {\n      const manifestColumnNames = new Set(Object.keys(manifest.columns));\n      for (const colName of dbColumnNames) {\n        if (!manifestColumnNames.has(colName)) {\n          changes.push({\n            type: 'drop_column',\n            table: tableName,\n            name: colName,\n            sql: this.generateDropColumnSQL(tableName, colName),\n          });\n        }\n      }\n    }\n\n    return changes;\n  }\n\n  private isUuidTextEquivalentColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n    normalizedExpected: string,\n    normalizedActual: string,\n  ): boolean {\n    const expectedUuidActualText =\n      normalizedExpected === 'UUID' && normalizedActual === 'TEXT';\n    const expectedTextActualUuid =\n      normalizedExpected === 'TEXT' && normalizedActual === 'UUID';\n\n    if (!expectedUuidActualText && !expectedTextActualUuid) {\n      return false;\n    }\n\n    return this.isStructuralUuidCompatibleColumn(columnName, colDef);\n  }\n\n  private isStructuralUuidCompatibleColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n  ): boolean {\n    return (\n      colDef.primaryKey === true ||\n      Boolean(colDef.foreignKey) ||\n      colDef.referenceKind === 'id' ||\n      colDef.referenceKind === 'foreignKey' ||\n      colDef.referenceKind === 'crossPackageRef' ||\n      colDef.referenceKind === 'tenantId' ||\n      (columnName === 'id' && colDef.type === 'TEXT')\n    );\n  }\n\n  /**\n   * Compare indexes between manifest and database\n   *\n   * Four classes of drift the differ now detects:\n   *\n   * 1. **Missing index** — manifest has an index neither the DB has by name\n   *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the\n   *    signature check protects against creating duplicates when STI child\n   *    classes register indexes with different name prefixes.)\n   *\n   * 2. **Same-name shape drift** — DB has an index with the manifest's name,\n   *    but its columns, uniqueness flag, or partial-index `WHERE` predicate\n   *    differ. This covers the uniqueness flip in issue #1165\n   *    (`tenants_slug_context_meta_type_idx` materialized non-unique while\n   *    the manifest declares it unique) and the predicate drift in issue\n   *    #1692 (a partial index whose `WHERE` clause was added, removed, or\n   *    altered). Emit `drop_index` + `add_index` so the next migrate cycle\n   *    recreates it with the correct shape.\n   *\n   * 3. **Orphan in DB** — DB has an index with no manifest counterpart by\n   *    name and no signature equivalent. Emit `drop_index` *only* when the\n   *    caller opts in via `includeDroppedIndexes`, and even then never for\n   *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by\n   *    table-level constraints and need a separate `DROP CONSTRAINT` path\n   *    that the differ does not emit yet.\n   *\n   * 4. **Partial-index predicate drift / collision** — two indexes on the\n   *    same column(s) and uniqueness that differ only by their `WHERE`\n   *    predicate (e.g. distinct STI child partial indexes) are no longer\n   *    collapsed to one signature, so the signature-equivalence path (b)\n   *    won't claim one for the other.\n   *\n   * @param dbIndexPredicates - Normalized `WHERE` predicate per DB index\n   *   name from {@link getDbIndexPredicates}. `null` means predicate\n   *   introspection was unavailable for this engine/adapter, in which case\n   *   the comparison falls back to predicate-unaware signatures (the prior\n   *   behavior) so existing partial indexes are never flagged as false drift.\n   */\n  private compareIndexes(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n    dbIndexPredicates: Map<string, string> | null = null,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n\n    // Only fold predicates into signatures when we actually read them back\n    // from the live DB. If introspection was unavailable both sides use the\n    // empty predicate, which reproduces the prior column+unique-only behavior\n    // and cannot manufacture false positives on existing partial indexes.\n    const predicateAware = dbIndexPredicates !== null;\n    const dbPredicateFor = (name: string): string =>\n      predicateAware ? (dbIndexPredicates?.get(name) ?? '') : '';\n    const manifestPredicateFor = (idx: IndexDefinition): string =>\n      predicateAware ? normalizeIndexPredicate(idx.where) : '';\n\n    // Index DB indexes by name and by signature for fast lookup.\n    // dbIndexSignatures groups *all* DB index names sharing a signature so\n    // duplicates under different names all get claimed by a single matching\n    // manifest entry — otherwise the orphan sweep would drop the un-claimed\n    // siblings even though they are functionally equivalent to the manifest.\n    const dbIndexesByName = new Map<\n      string,\n      { columns: string[]; unique: boolean }\n    >();\n    const dbIndexSignatures = new Map<string, Set<string>>();\n    for (const idx of dbSchema.indexes) {\n      const unique = idx.unique ?? false;\n      dbIndexesByName.set(idx.name, { columns: idx.columns, unique });\n      const signature = this.getIndexSignature(\n        idx.columns,\n        unique,\n        dbPredicateFor(idx.name),\n      );\n      let bucket = dbIndexSignatures.get(signature);\n      if (!bucket) {\n        bucket = new Set();\n        dbIndexSignatures.set(signature, bucket);\n      }\n      bucket.add(idx.name);\n    }\n\n    // Manifest signatures — used during the orphan sweep to skip DB indexes\n    // that match a manifest entry's signature even if no specific manifest\n    // entry \"claimed\" them by name.\n    const manifestSignatureSet = new Set<string>();\n    for (const idx of manifest.indexes) {\n      manifestSignatureSet.add(\n        this.getIndexSignature(idx, undefined, manifestPredicateFor(idx)),\n      );\n    }\n\n    // Track which DB indexes a manifest entry has claimed, so the orphan\n    // pass below doesn't re-flag indexes that match by signature alone.\n    const claimedDbIndexes = new Set<string>();\n\n    for (const idx of manifest.indexes) {\n      const manifestSignature = this.getIndexSignature(\n        idx,\n        undefined,\n        manifestPredicateFor(idx),\n      );\n\n      // (a) Same name in DB — verify shape matches.\n      const dbByName = dbIndexesByName.get(idx.name);\n      if (dbByName) {\n        claimedDbIndexes.add(idx.name);\n\n        // JSON-path indexes (`@meta({ indexed: true })`) cannot be reliably\n        // compared by DB introspection — SQLite expression indexes surface\n        // as `[null]` columns, so the signature would always mismatch and\n        // every diff run would emit drop+recreate. Trust the name match\n        // here; if the json path itself changes, the index name changes\n        // too (we encode the field name into it), so a name match is a\n        // stronger guarantee than the column list for this index family.\n        if (isJsonPathIndex(idx)) {\n          continue;\n        }\n\n        const dbSignature = this.getIndexSignature(\n          dbByName.columns,\n          dbByName.unique,\n          dbPredicateFor(idx.name),\n        );\n        if (dbSignature === manifestSignature) {\n          continue; // Same name, same shape — nothing to do.\n        }\n\n        // Same name, drifted shape. Most often this is a uniqueness flip\n        // (issue #1165: 3-column index materialized non-unique). Recreate.\n        //\n        // Rollback caveat: the auto-generated DOWN script for the\n        // `add_index` half drops the (newly correct) index, and the\n        // `drop_index` half has no DOWN. Rolling back a recreate leaves\n        // the table without the index entirely instead of restoring the\n        // wrong-shape original. Capturing the original shape would\n        // require richer DB introspection than the differ currently has,\n        // so this asymmetry is accepted — the failure mode after an\n        // un-rolled-back recreate is \"missing index\" rather than\n        // \"permanently broken UPSERT,\" which is recoverable.\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n        changes.push({\n          type: 'add_index',\n          table: tableName,\n          name: idx.name,\n          index: idx,\n          sql: this.generateAddIndexSQL(tableName, idx),\n        });\n        continue;\n      }\n\n      // (b) Different name in DB but functionally equivalent — keep as-is.\n      // Claim *every* DB name sharing this signature so duplicate-shape\n      // indexes (e.g., a stale `<name>_idx` plus the implicit `<name>_key`\n      // from the same constraint) all survive the orphan sweep.\n      const equivalentIndexNames = dbIndexSignatures.get(manifestSignature);\n      if (equivalentIndexNames && equivalentIndexNames.size > 0) {\n        for (const name of equivalentIndexNames) {\n          claimedDbIndexes.add(name);\n        }\n        continue;\n      }\n\n      // (c) Genuinely missing — add it.\n      changes.push({\n        type: 'add_index',\n        table: tableName,\n        name: idx.name,\n        index: idx,\n        sql: this.generateAddIndexSQL(tableName, idx),\n      });\n    }\n\n    // Orphan-index sweep (opt-in via includeDroppedIndexes).\n    if (this.options.includeDroppedIndexes) {\n      for (const idx of dbSchema.indexes) {\n        if (claimedDbIndexes.has(idx.name)) continue;\n        if (isProtectedDbIndexName(idx.name)) continue;\n\n        // Belt-and-suspenders: even if a DB index wasn't formally claimed\n        // by a manifest entry (e.g., shape-drift recreate consumed the\n        // claim slot), don't drop it if its signature still matches\n        // something the manifest declares. That would contradict the\n        // option doc (\"not functionally equivalent to anything in the\n        // manifest\") and risk dropping a still-needed index.\n        const idxSignature = this.getIndexSignature(\n          idx.columns,\n          idx.unique ?? false,\n          dbPredicateFor(idx.name),\n        );\n        if (manifestSignatureSet.has(idxSignature)) continue;\n\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n      }\n    }\n\n    return changes;\n  }\n\n  /**\n   * Generate a signature for an index based on its columns, uniqueness, and\n   * (normalized) partial-index predicate. Used for functional equivalence\n   * checking (Issue #741) and predicate-drift detection (Issue #1692).\n   *\n   * Note: Column order is preserved because it is semantically significant for\n   * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they\n   * have different query performance characteristics.\n   *\n   * The trailing predicate component distinguishes partial indexes that share\n   * columns and uniqueness but differ by their `WHERE` clause (e.g. distinct\n   * STI child partial indexes). Callers pass the already-normalized predicate\n   * so both the manifest (desired) and introspected (DB) sides compare equal\n   * for semantically-identical clauses. An empty string means \"no predicate\"\n   * (a non-partial index) and is also used on both sides when predicate\n   * introspection is unavailable, preserving the prior behavior.\n   *\n   * For JSON-path indexes (`@meta({ indexed: true })`) the signature is\n   * derived from the JSON path instead of an empty column list, so the\n   * differ can distinguish two jsonPath indexes against different paths.\n   *\n   * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)\n   * @param uniqueArg - Unique flag (used when first arg is a column array)\n   * @param predicateArg - Normalized partial-index predicate (default '')\n   * @returns Signature string\n   */\n  private getIndexSignature(\n    idxOrColumns: IndexDefinition | string[],\n    uniqueArg?: boolean,\n    predicateArg = '',\n  ): string {\n    if (Array.isArray(idxOrColumns)) {\n      return `${idxOrColumns.join(',')}:${Boolean(uniqueArg)}:${predicateArg}`;\n    }\n    const idx = idxOrColumns;\n    if (isJsonPathIndex(idx) && idx.jsonPath) {\n      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}:${predicateArg}`;\n    }\n    return `${(idx.columns ?? []).join(',')}:${Boolean(idx.unique)}:${predicateArg}`;\n  }\n\n  /**\n   * Whether the active engine supports partial indexes (`CREATE INDEX … WHERE`).\n   *\n   * SQLite and PostgreSQL do. DuckDB rejects them outright, and the JSON\n   * adapter is DuckDB-backed, so on those engines a \"partial\" index can only\n   * ever exist as a full index. Treating the predicate as significant there\n   * would (a) flag existing full indexes as false drift and (b) emit\n   * `CREATE INDEX … WHERE` DDL the engine rejects, breaking the migration.\n   * Gating on this keeps both the comparison and the generated DDL aligned\n   * with what the engine actually accepts (a partial index degrades to a\n   * full index), matching the pre-#1692 behavior on those engines.\n   */\n  private supportsPartialIndexes(): boolean {\n    return this.engine === 'sqlite' || this.engine === 'postgres';\n  }\n\n  /**\n   * Introspect partial-index predicates for a table, keyed by index name.\n   *\n   * `getTableSchema()` (the @happyvertical/sql introspection) returns only\n   * name/columns/unique, so the `WHERE` predicate is read directly here:\n   *\n   * - PostgreSQL: `pg_indexes.indexdef` carries the full CREATE INDEX text.\n   * - SQLite: the `sqlite_master.sql` column carries the original CREATE INDEX\n   *   text.\n   *\n   * Engines that don't support partial indexes (DuckDB / the DuckDB-backed\n   * JSON adapter) short-circuit to `null` so the comparison stays\n   * predicate-unaware there — see {@link supportsPartialIndexes}.\n   *\n   * Non-partial indexes are omitted from the map (callers treat a missing\n   * entry as the empty predicate). Returns `null` when the catalog query\n   * fails — e.g. an adapter exposing neither catalog — so the index\n   * comparison can fall back to predicate-unaware behavior rather than\n   * flagging every existing partial index as false drift.\n   */\n  private async getDbIndexPredicates(\n    tableName: string,\n  ): Promise<Map<string, string> | null> {\n    if (!this.supportsPartialIndexes()) {\n      return null;\n    }\n    const predicates = new Map<string, string>();\n    try {\n      if (this.engine === 'postgres') {\n        const result = await this.db.query(\n          `SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' AND tablename = ${this.quoteLiteral(\n            tableName,\n          )}`,\n        );\n        for (const row of result.rows as {\n          indexname?: string;\n          indexdef?: string;\n        }[]) {\n          if (!row.indexname || !row.indexdef) continue;\n          const predicate = extractIndexPredicate(row.indexdef);\n          if (predicate) predicates.set(row.indexname, predicate);\n        }\n        return predicates;\n      }\n\n      // SQLite exposes the `sqlite_master` catalog whose `sql` column preserves\n      // the original CREATE INDEX text. Implicit indexes carry a NULL `sql` and\n      // are skipped. (DuckDB / JSON already short-circuited above.)\n      const result = await this.db.query(\n        `SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ${this.quoteLiteral(\n          tableName,\n        )} AND name NOT LIKE 'sqlite_%'`,\n      );\n      for (const row of result.rows as {\n        name?: string;\n        sql?: string | null;\n      }[]) {\n        if (!row.name || !row.sql) continue;\n        const predicate = extractIndexPredicate(row.sql);\n        if (predicate) predicates.set(row.name, predicate);\n      }\n      return predicates;\n    } catch (err) {\n      logger.debug(\n        `[SchemaComparer] Partial-index predicate introspection unavailable for ${tableName}; falling back to predicate-unaware index comparison`,\n        { error: err instanceof Error ? err.message : String(err) },\n      );\n      return null;\n    }\n  }\n\n  /**\n   * Get list of existing tables from database\n   */\n  private async getExistingTables(): Promise<Set<string>> {\n    let query: string;\n    if (this.engine === 'postgres') {\n      query = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`;\n    } else {\n      // SQLite and DuckDB both expose the SQLite-compatible `sqlite_master`\n      // catalog — DuckDB ships it as a built-in compatibility view, so a single\n      // introspection query covers both engines. Verified against a live DuckDB\n      // v1.4.3 (json mode): `SELECT name FROM sqlite_master WHERE type='table'`\n      // returns user tables with the expected `name` column (#1579).\n      query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;\n    }\n\n    const result = await this.db.query(query);\n    const rows = result.rows as { name?: string; table_name?: string }[];\n    return new Set(\n      rows.map((r) => r.name || r.table_name || '').filter(Boolean),\n    );\n  }\n\n  /**\n   * Normalize SQL types for comparison\n   */\n  private normalizeType(type: string): string {\n    const upper = type.toUpperCase().trim();\n\n    // Integer types\n    if (/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT)$/i.test(upper)) {\n      return 'INTEGER';\n    }\n\n    // Text types\n    if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR)/i.test(upper)) {\n      return 'TEXT';\n    }\n\n    // UUID normalizes to its own bucket — deliberately NOT folded into TEXT.\n    // The text<->uuid drift tolerance (R11) is applied at the equality gate\n    // in `compare()` only, so that `isCompatibleTypeUpgrade` (which also\n    // calls normalizeType) still treats `uuid` as distinct from text and\n    // won't mis-classify e.g. `uuid`->`timestamp` as a compatible\n    // \"TEXT->TIMESTAMP\" upgrade.\n    if (/^UUID$/i.test(upper)) {\n      return 'UUID';\n    }\n\n    // Decimal types\n    if (/^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(upper)) {\n      return 'REAL';\n    }\n\n    // Boolean types\n    if (/^(BOOLEAN|BOOL)/i.test(upper)) {\n      return 'BOOLEAN';\n    }\n\n    // Date/time types\n    if (/^(DATETIME|TIMESTAMP|DATE|TIME)/i.test(upper)) {\n      return 'TIMESTAMP';\n    }\n\n    // Blob types\n    if (/^(BLOB|BINARY|BYTEA)/i.test(upper)) {\n      return 'BLOB';\n    }\n\n    // JSON types\n    if (/^(JSON|JSONB)/i.test(upper)) {\n      return 'JSON';\n    }\n\n    return upper;\n  }\n\n  /**\n   * Check if a type change is a safe upgrade that can be auto-migrated.\n   *\n   * SMRT controls the data lifecycle for these columns, so we know:\n   * - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)\n   * - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings\n   *   before newer manifests normalized the column type.\n   * - INTEGER→REAL: Safe widening of integer to floating point\n   * - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for\n   *   legacy integer columns that were previously stored as text/real.\n   *\n   * @param manifestType - The abstract type from the manifest (e.g., 'JSON')\n   * @param dbType - The actual type in the database (e.g., 'TEXT')\n   * @returns true if the change from dbType to manifestType is a safe upgrade\n   */\n  private isCompatibleTypeUpgrade(\n    manifestType: string,\n    dbType: string,\n  ): boolean {\n    const manifest = this.normalizeType(manifestType);\n    const db = this.normalizeType(dbType);\n\n    // TEXT → JSON is safe: SMRT serializes arrays/objects as JSON text\n    // When the manifest says JSON, the data is already valid JSON in TEXT column\n    if (manifest === 'JSON' && db === 'TEXT') {\n      return true;\n    }\n\n    // JSON → TEXT is also safe (downgrade, but data is preserved as-is)\n    if (manifest === 'TEXT' && db === 'JSON') {\n      return true;\n    }\n\n    // UUID → TEXT is safe for plain text/provenance fields that were\n    // mistakenly materialized as native uuid: the stored UUID value can be\n    // rendered losslessly as text.\n    if (manifest === 'TEXT' && db === 'UUID') {\n      return true;\n    }\n\n    // INTEGER → REAL is safe (widening)\n    if (manifest === 'REAL' && db === 'INTEGER') {\n      return true;\n    }\n\n    // PostgreSQL can safely repair legacy integer columns when the generated\n    // migration validates that every existing value is already an integer.\n    if (\n      this.engine === 'postgres' &&\n      manifest === 'INTEGER' &&\n      (db === 'TEXT' || db === 'REAL')\n    ) {\n      return true;\n    }\n\n    // TEXT/JSON → TIMESTAMP is a legacy-drift repair. Invalid values fail\n    // explicitly during migration rather than being silently coerced.\n    if (manifest === 'TIMESTAMP' && (db === 'TEXT' || db === 'JSON')) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Generate SQL for a type upgrade migration.\n   *\n   * Engine-specific SQL:\n   * - SQLite: TEXT and JSON are equivalent, no-op or comment\n   * - DuckDB: ALTER COLUMN TYPE (native type conversion)\n   * - PostgreSQL: ALTER COLUMN TYPE with USING clause\n   */\n  private generateTypeUpgradeSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n    dbType: string,\n  ): GeneratedTypeUpgradeSQL {\n    const quotedTable = this.quoteIdentifier(tableName);\n    const quotedCol = this.quoteIdentifier(colName);\n    const manifestType = colDef.type;\n\n    // Validate manifestType before mapping\n    const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n      ? manifestType\n      : 'TEXT';\n    const targetType = this.ddlStrategy.mapType(validatedType);\n\n    switch (this.engine) {\n      case 'sqlite':\n        // SQLite has dynamic typing - TEXT and JSON are functionally equivalent\n        // For SQLite, we just return a comment since no actual change is needed\n        if (\n          this.normalizeType(manifestType) === 'JSON' &&\n          this.normalizeType(dbType) === 'TEXT'\n        ) {\n          return {\n            sql: `-- SQLite: ${quotedCol} already stores JSON as TEXT (no change needed)`,\n          };\n        }\n        // For other type upgrades, SQLite requires recreating the table\n        return {\n          sql: `-- SQLite: Type upgrade for ${quotedCol} requires table recreation`,\n        };\n\n      case 'postgres': {\n        // PostgreSQL defaults must be dropped/reset around some type changes\n        // so drift repairs can succeed even when an existing default cannot\n        // be cast automatically to the target type.\n        const manifestNormalized = this.normalizeType(manifestType);\n        const dbNormalized = this.normalizeType(dbType);\n        const preflightSQL =\n          manifestNormalized === 'INTEGER' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'REAL')\n            ? this.generatePostgresIntegerPreflightSQL(\n                quotedTable,\n                quotedCol,\n                tableName,\n                colName,\n                dbNormalized,\n              )\n            : null;\n        const clauses: string[] = [];\n\n        if (colDef.defaultValue !== undefined) {\n          clauses.push(`ALTER COLUMN ${quotedCol} DROP DEFAULT`);\n        }\n\n        let typeClause = `ALTER COLUMN ${quotedCol} TYPE ${targetType}`;\n        if (manifestNormalized === 'JSON' && dbNormalized === 'TEXT') {\n          // #1335: a bare `${col}::jsonb` cast raises \"invalid input syntax for\n          // type json\" on any row whose text is not already valid JSON (e.g. a\n          // legacy enum column holding 'active'). `to_jsonb(col)` instead wraps\n          // ANY text value as a JSON string and never errors, so a genuine\n          // TEXT->JSON widening survives non-JSON legacy data. (Note: with the\n          // json<->text equality tolerance added in this fix, the normal\n          // compare path no longer reaches here; this keeps the SQL safe for\n          // callers that construct a type_upgrade directly.)\n          typeClause += ` USING to_jsonb(${quotedCol})`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'JSON') {\n          // #1335: a native-json column cast back to text is value-preserving\n          // (`::text` renders the stored JSON as its text form), so this arm is\n          // safe. (Note: like the TEXT->JSON arm above, the json<->text equality\n          // tolerance means the normal compare path no longer reaches here; this\n          // keeps the SQL safe for callers that construct a type_upgrade\n          // directly.)\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'UUID') {\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'TEXT'\n        ) {\n          typeClause += ` USING trim(${quotedCol}::text)::integer`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'REAL'\n        ) {\n          typeClause += ` USING ${quotedCol}::integer`;\n        } else if (\n          manifestNormalized === 'TIMESTAMP' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'JSON')\n        ) {\n          typeClause += ` USING NULLIF(NULLIF(trim(both '\"' from ${quotedCol}::text), ''), 'null')::timestamp`;\n        }\n\n        clauses.push(typeClause);\n\n        if (colDef.defaultValue !== undefined) {\n          const formattedDefault = this.ddlStrategy.formatDefaultValue(\n            colDef.defaultValue,\n            validatedType,\n          );\n          const defaultSql =\n            manifestNormalized === 'JSON'\n              ? `${formattedDefault}::${targetType.toLowerCase()}`\n              : formattedDefault;\n          clauses.push(`ALTER COLUMN ${quotedCol} SET DEFAULT ${defaultSql}`);\n        }\n\n        const alterSql = `ALTER TABLE ${quotedTable} ${clauses.join(', ')}`;\n\n        return preflightSQL\n          ? { sql: alterSql, statements: [preflightSQL, alterSql] }\n          : { sql: alterSql };\n      }\n\n      case 'duckdb':\n        // DuckDB supports ALTER COLUMN TYPE for type conversions\n        return {\n          sql: `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${targetType}`,\n        };\n\n      default: {\n        // Escape special characters in type names for safe comment generation\n        const safeDbType = dbType.replace(/[^\\w]/g, '_');\n        const safeManifestType = manifestType.replace(/[^\\w]/g, '_');\n        return {\n          sql: `-- Type upgrade for ${quotedCol}: ${safeDbType} → ${safeManifestType}`,\n        };\n      }\n    }\n  }\n\n  /**\n   * Quote a SQL identifier\n   */\n  private quoteIdentifier(name: string): string {\n    return `\"${name.replace(/\"/g, '\"\"')}\"`;\n  }\n\n  /**\n   * Generate a PostgreSQL preflight guard for narrowing legacy columns to\n   * INTEGER. PostgreSQL's REAL→INTEGER cast rounds fractional values, so the\n   * generated migration must fail before the ALTER can silently change data.\n   */\n  private generatePostgresIntegerPreflightSQL(\n    quotedTable: string,\n    quotedCol: string,\n    tableName: string,\n    colName: string,\n    dbNormalized: string,\n  ): string {\n    const invalidCondition =\n      dbNormalized === 'REAL'\n        ? `${quotedCol} IS NOT NULL AND ${quotedCol} <> trunc(${quotedCol})`\n        : `${quotedCol} IS NOT NULL AND trim(${quotedCol}::text) !~ '^[+-]?[0-9]+$'`;\n    const message = `Cannot convert ${tableName}.${colName} to INTEGER: found non-integer values`;\n\n    return `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${quotedTable} WHERE ${invalidCondition}) THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;\n  }\n\n  private quoteLiteral(value: string): string {\n    return `'${value.replace(/'/g, \"''\")}'`;\n  }\n\n  /**\n   * Generate SQL for adding a column\n   */\n  private generateAddColumnSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n  ): string {\n    // Build the ADD COLUMN definition inline (main) rather than delegating to\n    // the DDL strategy's generateColumnDefinition: that builder is for CREATE\n    // TABLE and would emit `PRIMARY KEY` (invalid in ALTER ... ADD COLUMN) and\n    // suppress single-column UNIQUE on engines that require inline unique at\n    // table-create time (DuckDB) — but an ADD COLUMN has no inline-constraint\n    // pass, so the UNIQUE must be emitted here. mapType still maps abstract\n    // types per dialect (UUID→native uuid / TEXT — R11); invalid types fall\n    // back to TEXT, matching the compareColumns guard.\n    const validatedType: SQLDataType = isValidSQLDataType(colDef.type)\n      ? colDef.type\n      : 'TEXT';\n    if (!isValidSQLDataType(colDef.type)) {\n      logger.warn(\n        `[SchemaComparer] Invalid manifest type \"${colDef.type}\" for ${tableName}.${colName}, treating as TEXT`,\n      );\n    }\n\n    const parts: string[] = [\n      this.quoteIdentifier(colName),\n      this.ddlStrategy.mapType(validatedType),\n    ];\n\n    if (colDef.notNull) {\n      parts.push('NOT NULL');\n    }\n    if (colDef.unique) {\n      parts.push('UNIQUE');\n    }\n    if (colDef.defaultValue !== undefined) {\n      const defaultVal = this.ddlStrategy.formatDefaultValue(\n        colDef.defaultValue,\n        validatedType,\n      );\n      parts.push(`DEFAULT ${defaultVal}`);\n    }\n    if (colDef.check) {\n      parts.push(`CHECK (${colDef.check})`);\n    }\n\n    const columnDefinition = parts.join(' ');\n\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${columnDefinition}`;\n  }\n\n  /**\n   * Generate SQL for dropping a column\n   */\n  private generateDropColumnSQL(tableName: string, colName: string): string {\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(colName)}`;\n  }\n\n  /**\n   * Generate SQL for adding an index.\n   *\n   * On engines that support partial indexes (SQLite/PostgreSQL) this mirrors\n   * the canonical CREATE INDEX path in the DDL strategies: a partial index\n   * appends its `WHERE` predicate so a detected predicate add/alter (issue\n   * #1692) recreates the index with the correct partial condition rather than\n   * silently widening it to a full index. On DuckDB / the JSON adapter — which\n   * reject partial indexes — the predicate is dropped so the emitted DDL stays\n   * executable (a partial index degrades to a full index there). The predicate\n   * is trimmed and a redundant leading `WHERE` stripped for robustness.\n   */\n  private generateAddIndexSQL(tableName: string, idx: IndexDefinition): string {\n    const uniqueStr = idx.unique ? 'UNIQUE ' : '';\n    const target = renderIndexTarget(idx, this.engine);\n    let sql = `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;\n    const where = idx.where?.trim().replace(/^WHERE\\s+/i, '');\n    if (this.supportsPartialIndexes() && where) {\n      sql += ` WHERE ${where}`;\n    }\n    return sql;\n  }\n\n  /**\n   * Generate SQL for dropping an index.\n   *\n   * This SQL is consumed by the manifest-driven execution path:\n   *\n   * - `db:migrate` runs the SQL we put in `change.sql` directly, with the\n   *   tracker's `executePostgresStatements` adding CONCURRENTLY when\n   *   `--postgres-safe` is on.\n   *\n   * PostgreSQL ends up with `CONCURRENTLY` when it should.\n   * Keeping this method engine-agnostic also means the diff preview text\n   * stays readable (no engine-specific noise) for engines like SQLite\n   * where CONCURRENTLY isn't a thing.\n   */\n  private generateDropIndexSQL(indexName: string): string {\n    return `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)}`;\n  }\n}\n\n/**\n * Generate a SchemaDiff from manifest and database\n */\nexport async function generateSchemaDiff(\n  db: DatabaseInterface,\n  manifestSchemas: Record<string, SchemaDefinition>,\n  options: DiffOptions = {},\n): Promise<SchemaDiff> {\n  const comparer = new SchemaComparer(db, options);\n  return comparer.compare(manifestSchemas);\n}\n\n/**\n * Check if a diff has any actionable changes (excluding type mismatches)\n */\nexport function hasActionableChanges(diff: SchemaDiff): boolean {\n  if (diff.added_tables.length > 0) return true;\n  if (diff.dropped_tables.length > 0) return true;\n  return diff.changes.some((c) => c.type !== 'type_mismatch');\n}\n\n/**\n * Get SQL statements from a diff for execution\n */\nexport function getSQLFromDiff(diff: SchemaDiff): string[] {\n  const statements: string[] = [];\n\n  // Add table creation (requires full DDL generation - not included here)\n  // This is typically handled by ensureSchema()\n\n  // Add column and index changes\n  for (const change of diff.changes) {\n    if (change.type !== 'type_mismatch') {\n      statements.push(\n        ...(change.sqlStatements ?? (change.sql ? [change.sql] : [])),\n      );\n    }\n  }\n\n  return statements;\n}\n"],"mappings":"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"}
+{"version":3,"file":"differ.js","names":[],"sources":["../../src/migrations/differ.ts"],"sourcesContent":["/**\n * Schema Differ\n *\n * Compares manifest schemas to database schemas and generates\n * a SchemaDiff with the differences.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport { detectEngine, getDDLStrategy } from '../schema/ddl/index.js';\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type {\n  ColumnDefinition,\n  IndexDefinition,\n  SchemaChange,\n  SchemaDefinition,\n  SchemaDiff,\n  SQLDataType,\n} from '../schema/types.js';\nimport { isJsonPathIndex, renderIndexTarget } from '../schema/utils.js';\nimport type { DatabaseInterface, SqlTableSchemaInfo } from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Valid SQLDataType values for validation\n */\nconst VALID_SQL_DATA_TYPES: Set<SQLDataType> = new Set([\n  'TEXT',\n  'INTEGER',\n  'REAL',\n  'BLOB',\n  'BOOLEAN',\n  'JSON',\n  'TIMESTAMP',\n  'UUID',\n]);\n\ninterface GeneratedTypeUpgradeSQL {\n  sql: string;\n  statements?: string[];\n}\n\n/**\n * Check if a string is a valid SQLDataType\n */\nfunction isValidSQLDataType(type: string): type is SQLDataType {\n  return VALID_SQL_DATA_TYPES.has(type as SQLDataType);\n}\n\n/**\n * Options for schema comparison\n */\nexport interface DiffOptions {\n  /** Include dropped tables in diff (default: false for safety) */\n  includeDroppedTables?: boolean;\n  /** Include dropped columns in diff (default: false for safety) */\n  includeDroppedColumns?: boolean;\n  /**\n   * Drop indexes that exist in the database but are absent from the manifest\n   * AND are not functionally equivalent to anything in the manifest. Default:\n   * false. The differ always skips primary-key indexes (`*_pkey`) and the\n   * implicit indexes that PostgreSQL creates from inline UNIQUE constraints\n   * (`*_key`) — those are owned by table-level constraints, not by the\n   * index list, and dropping them here would break the constraint.\n   */\n  includeDroppedIndexes?: boolean;\n  /** Ignore type mismatches (just log warnings) */\n  ignoreTypeMismatches?: boolean;\n  /**\n   * Explicit engine hint forwarded to `detectEngine` when picking the DDL\n   * strategy used for *existing-table* SQL (ALTER/CREATE INDEX/etc.). Use\n   * this when `db.url` is empty or ambiguous (e.g. JSON adapter, in-memory\n   * wrappers where the URL lives on `db.config?.url`). Without it the\n   * comparer falls back to URL-only detection, which can produce SQLite-\n   * flavored SQL on a connection whose caller meant Postgres or DuckDB.\n   */\n  engineHint?: string;\n  /**\n   * Explicit confirmation that every historical writer of legacy PostgreSQL\n   * Date columns used UTC wall times. Without this acknowledgement,\n   * TIMESTAMP/TEXT/JSON to TIMESTAMPTZ drift is reported as manual rather\n   * than reinterpreted automatically.\n   */\n  postgresTimestampMigration?: { legacyTimezone: 'UTC' };\n}\n\n/**\n * Suffix patterns for indexes that the differ refuses to drop.\n * - `_pkey`: PostgreSQL primary key implicit index.\n * - `_key`: PostgreSQL implicit index for inline `UNIQUE (...)` table\n *   constraints. Dropping these by name does not drop the underlying\n *   constraint, and dropping the constraint requires a separate DDL path\n *   (`ALTER TABLE ... DROP CONSTRAINT`) the differ does not emit today.\n */\nconst PROTECTED_INDEX_SUFFIXES = ['_pkey', '_key'];\n\nfunction isProtectedDbIndexName(name: string): boolean {\n  return PROTECTED_INDEX_SUFFIXES.some((suffix) => name.endsWith(suffix));\n}\n\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & {\n    config?: { url?: string };\n  };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\n/**\n * Normalize a partial-index `WHERE` predicate so semantically-identical\n * clauses from different sources compare equal (issue #1692).\n *\n * The manifest stores predicates roughly as written (`_meta_type = 'Article'`),\n * SQLite/DuckDB echo the original CREATE INDEX text verbatim, and PostgreSQL\n * re-renders them with type casts and extra parentheses\n * (`((_meta_type)::text = 'Article'::text)`). Normalization:\n *\n * - strips a leading `WHERE` keyword,\n * - removes PostgreSQL `::type` casts (single-word type names — the only kind\n *   SMRT-generated partial predicates produce, e.g. `_meta_type::text`),\n * - removes parentheses (SMRT only emits simple `col = 'literal'` predicates,\n *   so grouping carries no meaning here),\n * - lowercases everything OUTSIDE single-quoted string literals (SQL keywords\n *   and identifiers are case-insensitive; literals such as STI discriminator\n *   class names are case-sensitive, so they are preserved verbatim),\n * - collapses whitespace and tightens spacing around comparison operators.\n *\n * Returns '' for an absent/empty predicate (i.e. a non-partial index).\n */\nexport function normalizeIndexPredicate(where?: string | null): string {\n  if (!where) return '';\n  const stripped = where.trim().replace(/^WHERE\\s+/i, '');\n  if (!stripped) return '';\n\n  let out = '';\n  let i = 0;\n  while (i < stripped.length) {\n    if (stripped[i] === \"'\") {\n      // Consume a single-quoted string literal verbatim, honoring the SQL\n      // `''` escape for an embedded quote.\n      let literal = \"'\";\n      i++;\n      while (i < stripped.length) {\n        if (stripped[i] === \"'\") {\n          if (stripped[i + 1] === \"'\") {\n            literal += \"''\";\n            i += 2;\n            continue;\n          }\n          literal += \"'\";\n          i++;\n          break;\n        }\n        literal += stripped[i];\n        i++;\n      }\n      out += literal;\n    } else {\n      let run = '';\n      while (i < stripped.length && stripped[i] !== \"'\") {\n        run += stripped[i];\n        i++;\n      }\n      out += normalizeNonLiteralPredicateRun(run);\n    }\n  }\n  return out;\n}\n\n/**\n * Normalize the non-literal portion of a predicate (everything outside a\n * single-quoted string literal). Type casts and parentheses are dropped,\n * keywords/identifiers are lowercased, and whitespace is canonicalized.\n */\nfunction normalizeNonLiteralPredicateRun(run: string): string {\n  return run\n    .replace(/::[A-Za-z_]\\w*/g, '') // drop single-word PostgreSQL type casts\n    .replace(/[()]/g, '') // drop parentheses\n    .toLowerCase()\n    .replace(/\\s+/g, ' ')\n    .replace(/\\s*([=<>!]+)\\s*/g, '$1') // tighten comparison operators\n    .trim();\n}\n\n/**\n * Extract the normalized partial-index predicate from a `CREATE INDEX`\n * statement — the `WHERE` tail that follows the column-list close paren.\n * Works for both SQLite/DuckDB `sqlite_master.sql` text and PostgreSQL\n * `pg_indexes.indexdef`. Returns '' for a non-partial index.\n */\nexport function extractIndexPredicate(createIndexSql: string): string {\n  // The predicate is the tail after the column-list ')': `... (cols) WHERE x`.\n  // Anchoring on `) WHERE` (rather than a bare `WHERE`) avoids matching a\n  // column literally named \"where\" inside the indexed column list.\n  const match = createIndexSql.match(/\\)\\s*WHERE\\s+([\\s\\S]+?)\\s*;?\\s*$/i);\n  if (!match) return '';\n  return normalizeIndexPredicate(match[1]);\n}\n\n/**\n * SchemaComparer class for comparing manifest schemas to database\n */\nexport class SchemaComparer {\n  private db: DatabaseInterface;\n  private options: DiffOptions;\n  private engine: DatabaseEngine;\n  private ddlStrategy: ReturnType<typeof getDDLStrategy>;\n\n  constructor(db: DatabaseInterface, options: DiffOptions = {}) {\n    this.db = db;\n    this.options = {\n      includeDroppedTables: false,\n      includeDroppedColumns: false,\n      includeDroppedIndexes: false,\n      ignoreTypeMismatches: false,\n      ...options,\n    };\n    // Use the shared detectEngine utility for consistent detection.\n    // Handles :memory:, .json, and other edge cases. The JSON adapter is\n    // detected structurally (it exposes `exportTable`) because its url can be\n    // empty; otherwise fall back to URL-based detection, where `engineHint`\n    // lets callers override when `db.url` is empty or points at an adapter\n    // whose engine isn't obvious from the URL alone (some in-memory wrappers).\n    this.engine =\n      typeof (this.db as { exportTable?: unknown }).exportTable === 'function'\n        ? 'json'\n        : detectEngine(resolveDatabaseUrl(this.db), this.options.engineHint);\n    this.ddlStrategy = getDDLStrategy(this.engine);\n  }\n\n  /**\n   * Compare manifest schemas to database and return differences\n   */\n  async compare(\n    manifestSchemas: Record<string, SchemaDefinition>,\n  ): Promise<SchemaDiff> {\n    const diff: SchemaDiff = {\n      added_tables: [],\n      dropped_tables: [],\n      changes: [],\n      has_changes: false,\n    };\n\n    // Get list of existing tables\n    const existingTables = await this.getExistingTables();\n\n    // Check each manifest schema against database\n    for (const [tableName, schema] of Object.entries(manifestSchemas)) {\n      if (!existingTables.has(tableName)) {\n        // Table doesn't exist - add to added_tables\n        diff.added_tables.push(schema);\n        diff.has_changes = true;\n      } else {\n        // Table exists - compare columns and indexes\n        const tableChanges = await this.compareTable(tableName, schema);\n        if (tableChanges.length > 0) {\n          diff.changes.push(...tableChanges);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    // Check for dropped tables (if enabled)\n    if (this.options.includeDroppedTables) {\n      for (const tableName of existingTables) {\n        // Skip system tables\n        if (tableName.startsWith('_smrt_') || tableName.startsWith('sqlite_')) {\n          continue;\n        }\n        if (!manifestSchemas[tableName]) {\n          diff.dropped_tables.push(tableName);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    return diff;\n  }\n\n  /**\n   * Compare a single table's schema to manifest\n   */\n  async compareTable(\n    tableName: string,\n    manifest: SchemaDefinition,\n  ): Promise<SchemaChange[]> {\n    const changes: SchemaChange[] = [];\n\n    // Get current table schema from database\n    const dbSchema = await this.db.getTableSchema?.(tableName);\n    if (!dbSchema) {\n      // Table doesn't exist - this is an add_table case\n      return changes;\n    }\n\n    // Compare columns\n    const columnChanges = this.compareColumns(tableName, manifest, dbSchema);\n    changes.push(...columnChanges);\n\n    // Partial-index predicates are not surfaced by `getTableSchema()` (the\n    // @happyvertical/sql introspection returns only name/columns/unique), so\n    // introspect them separately. Without this, two indexes on the same\n    // column(s) that differ only by their WHERE clause — e.g. distinct STI\n    // child partial indexes — would compare equal and the differ would miss\n    // adds/drops/changes of the predicate (issue #1692).\n    const dbIndexPredicates = await this.getDbIndexPredicates(tableName);\n\n    // Compare indexes\n    const indexChanges = this.compareIndexes(\n      tableName,\n      manifest,\n      dbSchema,\n      dbIndexPredicates,\n    );\n    changes.push(...indexChanges);\n\n    return changes;\n  }\n\n  /**\n   * Compare columns between manifest and database\n   */\n  private compareColumns(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n    const dbColumnNames = new Set(Object.keys(dbSchema.columns));\n\n    // Check for new and modified columns\n    for (const [colName, colDef] of Object.entries(manifest.columns)) {\n      if (!dbColumnNames.has(colName)) {\n        // Column doesn't exist - add it\n        changes.push({\n          type: 'add_column',\n          table: tableName,\n          name: colName,\n          column: colDef,\n          sql: this.generateAddColumnSQL(tableName, colName, colDef),\n        });\n      } else {\n        // Column exists - check for type mismatch\n        const dbCol = dbSchema.columns[colName];\n\n        // Map manifest's abstract type to engine-specific type\n        // e.g., JSON → TEXT for SQLite, JSON → JSONB for PostgreSQL\n        // Validate the manifest type before mapping\n        const manifestType = colDef.type;\n        if (!isValidSQLDataType(manifestType)) {\n          // Invalid manifest type - treat as TEXT (safest fallback)\n          logger.warn(\n            `[SchemaComparer] Invalid manifest type \"${manifestType}\" for ${tableName}.${colName}, treating as TEXT`,\n          );\n        }\n        const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n          ? manifestType\n          : 'TEXT';\n        const expectedEngineType = this.ddlStrategy.mapType(validatedType);\n        const normalizedExpected = this.normalizeType(expectedEngineType);\n        const normalizedActual = this.normalizeType(dbCol.type);\n\n        // R11: native `uuid` and `text` are interchangeable for SMRT-owned\n        // identifiers/references, but not for arbitrary provenance text. Keep\n        // the tolerance directional:\n        //   - manifest UUID + DB text is tolerated for structural ID/ref\n        //     columns so old deployments are not forced into native UUID.\n        //   - manifest TEXT + DB uuid is tolerated only for structural ID/ref\n        //     columns that are intentionally UUID-compatible.\n        // Plain TEXT columns with DB uuid now surface as repairable drift.\n        const isUuidTextEquivalent = this.isUuidTextEquivalentColumn(\n          colName,\n          colDef,\n          normalizedExpected,\n          normalizedActual,\n        );\n\n        // #1335: native `json`/`jsonb` (DB) and `text` (manifest) are\n        // interchangeable for SMRT — the convention is to serialize JSON values\n        // into TEXT columns, and a native-json column already holds exactly that\n        // data. So the differ must NOT flag a json<->text difference in EITHER\n        // direction:\n        //   - manifest TEXT vs DB json   (native-json column, text-convention manifest)\n        //   - manifest JSON vs DB text   (the canary case: an enum/plain field\n        //     mis-inferred as JSON by a downstream scanner, sitting on a real\n        //     `text` column holding bare values like 'active')\n        // Generating an ALTER here is pure churn at best and data-destroying at\n        // worst: `status::jsonb` on a column holding 'active' raises\n        // \"invalid input syntax for type json\" and aborts the whole atomic\n        // migration. Like the uuid/text tolerance, this lives at the equality\n        // gate only (not in `normalizeType`) so `isCompatibleTypeUpgrade` still\n        // treats JSON and TEXT as distinct buckets for OTHER upgrade paths.\n        const isJsonTextEquivalent =\n          (normalizedExpected === 'JSON' && normalizedActual === 'TEXT') ||\n          (normalizedExpected === 'TEXT' && normalizedActual === 'JSON');\n\n        if (\n          normalizedExpected !== normalizedActual &&\n          !isUuidTextEquivalent &&\n          !isJsonTextEquivalent\n        ) {\n          // Check if this is a safe type upgrade that SMRT can handle\n          // Since SMRT owns the data lifecycle, we know the intent from the manifest\n          if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {\n            // Generate type upgrade SQL\n            const generatedSQL = this.generateTypeUpgradeSQL(\n              tableName,\n              colName,\n              colDef,\n              dbCol.type,\n            );\n            changes.push({\n              type: 'type_upgrade',\n              table: tableName,\n              name: colName,\n              column: colDef,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n              sql: generatedSQL.sql,\n              ...(generatedSQL.statements\n                ? { sqlStatements: generatedSQL.statements }\n                : {}),\n            });\n          } else if (!this.options.ignoreTypeMismatches) {\n            changes.push({\n              type: 'type_mismatch',\n              table: tableName,\n              name: colName,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n            });\n          }\n        }\n      }\n    }\n\n    // Check for dropped columns (if enabled)\n    if (this.options.includeDroppedColumns) {\n      const manifestColumnNames = new Set(Object.keys(manifest.columns));\n      for (const colName of dbColumnNames) {\n        if (!manifestColumnNames.has(colName)) {\n          changes.push({\n            type: 'drop_column',\n            table: tableName,\n            name: colName,\n            sql: this.generateDropColumnSQL(tableName, colName),\n          });\n        }\n      }\n    }\n\n    return changes;\n  }\n\n  private isUuidTextEquivalentColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n    normalizedExpected: string,\n    normalizedActual: string,\n  ): boolean {\n    const expectedUuidActualText =\n      normalizedExpected === 'UUID' && normalizedActual === 'TEXT';\n    const expectedTextActualUuid =\n      normalizedExpected === 'TEXT' && normalizedActual === 'UUID';\n\n    if (!expectedUuidActualText && !expectedTextActualUuid) {\n      return false;\n    }\n\n    return this.isStructuralUuidCompatibleColumn(columnName, colDef);\n  }\n\n  private isStructuralUuidCompatibleColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n  ): boolean {\n    return (\n      colDef.primaryKey === true ||\n      Boolean(colDef.foreignKey) ||\n      colDef.referenceKind === 'id' ||\n      colDef.referenceKind === 'foreignKey' ||\n      colDef.referenceKind === 'crossPackageRef' ||\n      colDef.referenceKind === 'tenantId' ||\n      (columnName === 'id' && colDef.type === 'TEXT')\n    );\n  }\n\n  /**\n   * Compare indexes between manifest and database\n   *\n   * Four classes of drift the differ now detects:\n   *\n   * 1. **Missing index** — manifest has an index neither the DB has by name\n   *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the\n   *    signature check protects against creating duplicates when STI child\n   *    classes register indexes with different name prefixes.)\n   *\n   * 2. **Same-name shape drift** — DB has an index with the manifest's name,\n   *    but its columns, uniqueness flag, or partial-index `WHERE` predicate\n   *    differ. This covers the uniqueness flip in issue #1165\n   *    (`tenants_slug_context_meta_type_idx` materialized non-unique while\n   *    the manifest declares it unique) and the predicate drift in issue\n   *    #1692 (a partial index whose `WHERE` clause was added, removed, or\n   *    altered). Emit `drop_index` + `add_index` so the next migrate cycle\n   *    recreates it with the correct shape.\n   *\n   * 3. **Orphan in DB** — DB has an index with no manifest counterpart by\n   *    name and no signature equivalent. Emit `drop_index` *only* when the\n   *    caller opts in via `includeDroppedIndexes`, and even then never for\n   *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by\n   *    table-level constraints and need a separate `DROP CONSTRAINT` path\n   *    that the differ does not emit yet.\n   *\n   * 4. **Partial-index predicate drift / collision** — two indexes on the\n   *    same column(s) and uniqueness that differ only by their `WHERE`\n   *    predicate (e.g. distinct STI child partial indexes) are no longer\n   *    collapsed to one signature, so the signature-equivalence path (b)\n   *    won't claim one for the other.\n   *\n   * @param dbIndexPredicates - Normalized `WHERE` predicate per DB index\n   *   name from {@link getDbIndexPredicates}. `null` means predicate\n   *   introspection was unavailable for this engine/adapter, in which case\n   *   the comparison falls back to predicate-unaware signatures (the prior\n   *   behavior) so existing partial indexes are never flagged as false drift.\n   */\n  private compareIndexes(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n    dbIndexPredicates: Map<string, string> | null = null,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n\n    // Only fold predicates into signatures when we actually read them back\n    // from the live DB. If introspection was unavailable both sides use the\n    // empty predicate, which reproduces the prior column+unique-only behavior\n    // and cannot manufacture false positives on existing partial indexes.\n    const predicateAware = dbIndexPredicates !== null;\n    const dbPredicateFor = (name: string): string =>\n      predicateAware ? (dbIndexPredicates?.get(name) ?? '') : '';\n    const manifestPredicateFor = (idx: IndexDefinition): string =>\n      predicateAware ? normalizeIndexPredicate(idx.where) : '';\n\n    // Index DB indexes by name and by signature for fast lookup.\n    // dbIndexSignatures groups *all* DB index names sharing a signature so\n    // duplicates under different names all get claimed by a single matching\n    // manifest entry — otherwise the orphan sweep would drop the un-claimed\n    // siblings even though they are functionally equivalent to the manifest.\n    const dbIndexesByName = new Map<\n      string,\n      { columns: string[]; unique: boolean }\n    >();\n    const dbIndexSignatures = new Map<string, Set<string>>();\n    for (const idx of dbSchema.indexes) {\n      const unique = idx.unique ?? false;\n      dbIndexesByName.set(idx.name, { columns: idx.columns, unique });\n      const signature = this.getIndexSignature(\n        idx.columns,\n        unique,\n        dbPredicateFor(idx.name),\n      );\n      let bucket = dbIndexSignatures.get(signature);\n      if (!bucket) {\n        bucket = new Set();\n        dbIndexSignatures.set(signature, bucket);\n      }\n      bucket.add(idx.name);\n    }\n\n    // Manifest signatures — used during the orphan sweep to skip DB indexes\n    // that match a manifest entry's signature even if no specific manifest\n    // entry \"claimed\" them by name.\n    const manifestSignatureSet = new Set<string>();\n    for (const idx of manifest.indexes) {\n      manifestSignatureSet.add(\n        this.getIndexSignature(idx, undefined, manifestPredicateFor(idx)),\n      );\n    }\n\n    // Track which DB indexes a manifest entry has claimed, so the orphan\n    // pass below doesn't re-flag indexes that match by signature alone.\n    const claimedDbIndexes = new Set<string>();\n\n    for (const idx of manifest.indexes) {\n      const manifestSignature = this.getIndexSignature(\n        idx,\n        undefined,\n        manifestPredicateFor(idx),\n      );\n\n      // (a) Same name in DB — verify shape matches.\n      const dbByName = dbIndexesByName.get(idx.name);\n      if (dbByName) {\n        claimedDbIndexes.add(idx.name);\n\n        // JSON-path indexes (`@meta({ indexed: true })`) cannot be reliably\n        // compared by DB introspection — SQLite expression indexes surface\n        // as `[null]` columns, so the signature would always mismatch and\n        // every diff run would emit drop+recreate. Trust the name match\n        // here; if the json path itself changes, the index name changes\n        // too (we encode the field name into it), so a name match is a\n        // stronger guarantee than the column list for this index family.\n        if (isJsonPathIndex(idx)) {\n          continue;\n        }\n\n        const dbSignature = this.getIndexSignature(\n          dbByName.columns,\n          dbByName.unique,\n          dbPredicateFor(idx.name),\n        );\n        if (dbSignature === manifestSignature) {\n          continue; // Same name, same shape — nothing to do.\n        }\n\n        // Same name, drifted shape. Most often this is a uniqueness flip\n        // (issue #1165: 3-column index materialized non-unique). Recreate.\n        //\n        // Rollback caveat: the auto-generated DOWN script for the\n        // `add_index` half drops the (newly correct) index, and the\n        // `drop_index` half has no DOWN. Rolling back a recreate leaves\n        // the table without the index entirely instead of restoring the\n        // wrong-shape original. Capturing the original shape would\n        // require richer DB introspection than the differ currently has,\n        // so this asymmetry is accepted — the failure mode after an\n        // un-rolled-back recreate is \"missing index\" rather than\n        // \"permanently broken UPSERT,\" which is recoverable.\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n        changes.push({\n          type: 'add_index',\n          table: tableName,\n          name: idx.name,\n          index: idx,\n          sql: this.generateAddIndexSQL(tableName, idx),\n        });\n        continue;\n      }\n\n      // (b) Different name in DB but functionally equivalent — keep as-is.\n      // Claim *every* DB name sharing this signature so duplicate-shape\n      // indexes (e.g., a stale `<name>_idx` plus the implicit `<name>_key`\n      // from the same constraint) all survive the orphan sweep.\n      const equivalentIndexNames = dbIndexSignatures.get(manifestSignature);\n      if (equivalentIndexNames && equivalentIndexNames.size > 0) {\n        for (const name of equivalentIndexNames) {\n          claimedDbIndexes.add(name);\n        }\n        continue;\n      }\n\n      // (c) Genuinely missing — add it.\n      changes.push({\n        type: 'add_index',\n        table: tableName,\n        name: idx.name,\n        index: idx,\n        sql: this.generateAddIndexSQL(tableName, idx),\n      });\n    }\n\n    // Orphan-index sweep (opt-in via includeDroppedIndexes).\n    if (this.options.includeDroppedIndexes) {\n      for (const idx of dbSchema.indexes) {\n        if (claimedDbIndexes.has(idx.name)) continue;\n        if (isProtectedDbIndexName(idx.name)) continue;\n\n        // Belt-and-suspenders: even if a DB index wasn't formally claimed\n        // by a manifest entry (e.g., shape-drift recreate consumed the\n        // claim slot), don't drop it if its signature still matches\n        // something the manifest declares. That would contradict the\n        // option doc (\"not functionally equivalent to anything in the\n        // manifest\") and risk dropping a still-needed index.\n        const idxSignature = this.getIndexSignature(\n          idx.columns,\n          idx.unique ?? false,\n          dbPredicateFor(idx.name),\n        );\n        if (manifestSignatureSet.has(idxSignature)) continue;\n\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n      }\n    }\n\n    return changes;\n  }\n\n  /**\n   * Generate a signature for an index based on its columns, uniqueness, and\n   * (normalized) partial-index predicate. Used for functional equivalence\n   * checking (Issue #741) and predicate-drift detection (Issue #1692).\n   *\n   * Note: Column order is preserved because it is semantically significant for\n   * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they\n   * have different query performance characteristics.\n   *\n   * The trailing predicate component distinguishes partial indexes that share\n   * columns and uniqueness but differ by their `WHERE` clause (e.g. distinct\n   * STI child partial indexes). Callers pass the already-normalized predicate\n   * so both the manifest (desired) and introspected (DB) sides compare equal\n   * for semantically-identical clauses. An empty string means \"no predicate\"\n   * (a non-partial index) and is also used on both sides when predicate\n   * introspection is unavailable, preserving the prior behavior.\n   *\n   * For JSON-path indexes (`@meta({ indexed: true })`) the signature is\n   * derived from the JSON path instead of an empty column list, so the\n   * differ can distinguish two jsonPath indexes against different paths.\n   *\n   * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)\n   * @param uniqueArg - Unique flag (used when first arg is a column array)\n   * @param predicateArg - Normalized partial-index predicate (default '')\n   * @returns Signature string\n   */\n  private getIndexSignature(\n    idxOrColumns: IndexDefinition | string[],\n    uniqueArg?: boolean,\n    predicateArg = '',\n  ): string {\n    if (Array.isArray(idxOrColumns)) {\n      return `${idxOrColumns.join(',')}:${Boolean(uniqueArg)}:${predicateArg}`;\n    }\n    const idx = idxOrColumns;\n    if (isJsonPathIndex(idx) && idx.jsonPath) {\n      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}:${predicateArg}`;\n    }\n    return `${(idx.columns ?? []).join(',')}:${Boolean(idx.unique)}:${predicateArg}`;\n  }\n\n  /**\n   * Whether the active engine supports partial indexes (`CREATE INDEX … WHERE`).\n   *\n   * SQLite and PostgreSQL do. DuckDB rejects them outright, and the JSON\n   * adapter is DuckDB-backed, so on those engines a \"partial\" index can only\n   * ever exist as a full index. Treating the predicate as significant there\n   * would (a) flag existing full indexes as false drift and (b) emit\n   * `CREATE INDEX … WHERE` DDL the engine rejects, breaking the migration.\n   * Gating on this keeps both the comparison and the generated DDL aligned\n   * with what the engine actually accepts (a partial index degrades to a\n   * full index), matching the pre-#1692 behavior on those engines.\n   */\n  private supportsPartialIndexes(): boolean {\n    return this.engine === 'sqlite' || this.engine === 'postgres';\n  }\n\n  /**\n   * Introspect partial-index predicates for a table, keyed by index name.\n   *\n   * `getTableSchema()` (the @happyvertical/sql introspection) returns only\n   * name/columns/unique, so the `WHERE` predicate is read directly here:\n   *\n   * - PostgreSQL: `pg_indexes.indexdef` carries the full CREATE INDEX text.\n   * - SQLite: the `sqlite_master.sql` column carries the original CREATE INDEX\n   *   text.\n   *\n   * Engines that don't support partial indexes (DuckDB / the DuckDB-backed\n   * JSON adapter) short-circuit to `null` so the comparison stays\n   * predicate-unaware there — see {@link supportsPartialIndexes}.\n   *\n   * Non-partial indexes are omitted from the map (callers treat a missing\n   * entry as the empty predicate). Returns `null` when the catalog query\n   * fails — e.g. an adapter exposing neither catalog — so the index\n   * comparison can fall back to predicate-unaware behavior rather than\n   * flagging every existing partial index as false drift.\n   */\n  private async getDbIndexPredicates(\n    tableName: string,\n  ): Promise<Map<string, string> | null> {\n    if (!this.supportsPartialIndexes()) {\n      return null;\n    }\n    const predicates = new Map<string, string>();\n    try {\n      if (this.engine === 'postgres') {\n        const result = await this.db.query(\n          `SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' AND tablename = ${this.quoteLiteral(\n            tableName,\n          )}`,\n        );\n        for (const row of result.rows as {\n          indexname?: string;\n          indexdef?: string;\n        }[]) {\n          if (!row.indexname || !row.indexdef) continue;\n          const predicate = extractIndexPredicate(row.indexdef);\n          if (predicate) predicates.set(row.indexname, predicate);\n        }\n        return predicates;\n      }\n\n      // SQLite exposes the `sqlite_master` catalog whose `sql` column preserves\n      // the original CREATE INDEX text. Implicit indexes carry a NULL `sql` and\n      // are skipped. (DuckDB / JSON already short-circuited above.)\n      const result = await this.db.query(\n        `SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ${this.quoteLiteral(\n          tableName,\n        )} AND name NOT LIKE 'sqlite_%'`,\n      );\n      for (const row of result.rows as {\n        name?: string;\n        sql?: string | null;\n      }[]) {\n        if (!row.name || !row.sql) continue;\n        const predicate = extractIndexPredicate(row.sql);\n        if (predicate) predicates.set(row.name, predicate);\n      }\n      return predicates;\n    } catch (err) {\n      logger.debug(\n        `[SchemaComparer] Partial-index predicate introspection unavailable for ${tableName}; falling back to predicate-unaware index comparison`,\n        { error: err instanceof Error ? err.message : String(err) },\n      );\n      return null;\n    }\n  }\n\n  /**\n   * Get list of existing tables from database\n   */\n  private async getExistingTables(): Promise<Set<string>> {\n    let query: string;\n    if (this.engine === 'postgres') {\n      query = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`;\n    } else {\n      // SQLite and DuckDB both expose the SQLite-compatible `sqlite_master`\n      // catalog — DuckDB ships it as a built-in compatibility view, so a single\n      // introspection query covers both engines. Verified against a live DuckDB\n      // v1.4.3 (json mode): `SELECT name FROM sqlite_master WHERE type='table'`\n      // returns user tables with the expected `name` column (#1579).\n      query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;\n    }\n\n    const result = await this.db.query(query);\n    const rows = result.rows as { name?: string; table_name?: string }[];\n    return new Set(\n      rows.map((r) => r.name || r.table_name || '').filter(Boolean),\n    );\n  }\n\n  /**\n   * Normalize SQL types for comparison\n   */\n  private normalizeType(type: string): string {\n    const upper = type\n      .toUpperCase()\n      .trim()\n      .replace(/\\(\\s*\\d+\\s*\\)/g, '');\n\n    // Integer types\n    if (/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT)$/i.test(upper)) {\n      return 'INTEGER';\n    }\n\n    // Text types\n    if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR)/i.test(upper)) {\n      return 'TEXT';\n    }\n\n    // UUID normalizes to its own bucket — deliberately NOT folded into TEXT.\n    // The text<->uuid drift tolerance (R11) is applied at the equality gate\n    // in `compare()` only, so that `isCompatibleTypeUpgrade` (which also\n    // calls normalizeType) still treats `uuid` as distinct from text and\n    // won't mis-classify e.g. `uuid`->`timestamp` as a compatible\n    // \"TEXT->TIMESTAMP\" upgrade.\n    if (/^UUID$/i.test(upper)) {\n      return 'UUID';\n    }\n\n    // Decimal types\n    if (/^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(upper)) {\n      return 'REAL';\n    }\n\n    // Boolean types\n    if (/^(BOOLEAN|BOOL)/i.test(upper)) {\n      return 'BOOLEAN';\n    }\n\n    // PostgreSQL distinguishes instants from timezone-naive wall times. Keep\n    // those in separate comparison buckets so legacy TIMESTAMP columns are\n    // migrated to the TIMESTAMPTZ representation used for JavaScript Date.\n    if (/^(TIMESTAMPTZ|TIMESTAMP\\s+WITH\\s+TIME\\s+ZONE)$/i.test(upper)) {\n      return 'TIMESTAMPTZ';\n    }\n\n    // Date/time types without timezone semantics\n    if (\n      /^(DATETIME|TIMESTAMP(?:\\s+WITHOUT\\s+TIME\\s+ZONE)?|DATE|TIME)$/i.test(\n        upper,\n      )\n    ) {\n      return 'TIMESTAMP';\n    }\n\n    // Blob types\n    if (/^(BLOB|BINARY|BYTEA)/i.test(upper)) {\n      return 'BLOB';\n    }\n\n    // JSON types\n    if (/^(JSON|JSONB)/i.test(upper)) {\n      return 'JSON';\n    }\n\n    return upper;\n  }\n\n  /**\n   * Check if a type change is a safe upgrade that can be auto-migrated.\n   *\n   * SMRT controls the data lifecycle for these columns, so we know:\n   * - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)\n   * - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings\n   *   before newer manifests normalized the column type.\n   * - PostgreSQL TIMESTAMP→TIMESTAMPTZ: Legacy SMRT Date values were written\n   *   as UTC ISO wall times, so interpreting the naive value as UTC preserves\n   *   the originally supplied instant.\n   * - INTEGER→REAL: Safe widening of integer to floating point\n   * - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for\n   *   legacy integer columns that were previously stored as text/real.\n   *\n   * @param manifestType - The abstract type from the manifest (e.g., 'JSON')\n   * @param dbType - The actual type in the database (e.g., 'TEXT')\n   * @returns true if the change from dbType to manifestType is a safe upgrade\n   */\n  private isCompatibleTypeUpgrade(\n    manifestType: string,\n    dbType: string,\n  ): boolean {\n    const manifest = this.normalizeType(manifestType);\n    const db = this.normalizeType(dbType);\n\n    if (\n      this.engine === 'postgres' &&\n      manifest === 'TIMESTAMP' &&\n      ['TIMESTAMP', 'TEXT', 'JSON'].includes(db) &&\n      this.ddlStrategy.mapType('TIMESTAMP') === 'TIMESTAMPTZ'\n    ) {\n      return this.options.postgresTimestampMigration?.legacyTimezone === 'UTC';\n    }\n\n    // TEXT → JSON is safe: SMRT serializes arrays/objects as JSON text\n    // When the manifest says JSON, the data is already valid JSON in TEXT column\n    if (manifest === 'JSON' && db === 'TEXT') {\n      return true;\n    }\n\n    // JSON → TEXT is also safe (downgrade, but data is preserved as-is)\n    if (manifest === 'TEXT' && db === 'JSON') {\n      return true;\n    }\n\n    // UUID → TEXT is safe for plain text/provenance fields that were\n    // mistakenly materialized as native uuid: the stored UUID value can be\n    // rendered losslessly as text.\n    if (manifest === 'TEXT' && db === 'UUID') {\n      return true;\n    }\n\n    // INTEGER → REAL is safe (widening)\n    if (manifest === 'REAL' && db === 'INTEGER') {\n      return true;\n    }\n\n    // PostgreSQL can safely repair legacy integer columns when the generated\n    // migration validates that every existing value is already an integer.\n    if (\n      this.engine === 'postgres' &&\n      manifest === 'INTEGER' &&\n      (db === 'TEXT' || db === 'REAL')\n    ) {\n      return true;\n    }\n\n    // TEXT/JSON → TIMESTAMP is a legacy-drift repair. Invalid values fail\n    // explicitly during migration rather than being silently coerced.\n    if (\n      manifest === 'TIMESTAMP' &&\n      (db === 'TEXT' || db === 'JSON') &&\n      this.engine !== 'postgres'\n    ) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Generate SQL for a type upgrade migration.\n   *\n   * Engine-specific SQL:\n   * - SQLite: TEXT and JSON are equivalent, no-op or comment\n   * - DuckDB: ALTER COLUMN TYPE (native type conversion)\n   * - PostgreSQL: ALTER COLUMN TYPE with USING clause\n   */\n  private generateTypeUpgradeSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n    dbType: string,\n  ): GeneratedTypeUpgradeSQL {\n    const quotedTable = this.quoteIdentifier(tableName);\n    const quotedCol = this.quoteIdentifier(colName);\n    const manifestType = colDef.type;\n\n    // Validate manifestType before mapping\n    const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n      ? manifestType\n      : 'TEXT';\n    const targetType = this.ddlStrategy.mapType(validatedType);\n\n    switch (this.engine) {\n      case 'sqlite':\n        // SQLite has dynamic typing - TEXT and JSON are functionally equivalent\n        // For SQLite, we just return a comment since no actual change is needed\n        if (\n          this.normalizeType(manifestType) === 'JSON' &&\n          this.normalizeType(dbType) === 'TEXT'\n        ) {\n          return {\n            sql: `-- SQLite: ${quotedCol} already stores JSON as TEXT (no change needed)`,\n          };\n        }\n        // For other type upgrades, SQLite requires recreating the table\n        return {\n          sql: `-- SQLite: Type upgrade for ${quotedCol} requires table recreation`,\n        };\n\n      case 'postgres': {\n        // PostgreSQL defaults must be dropped/reset around some type changes\n        // so drift repairs can succeed even when an existing default cannot\n        // be cast automatically to the target type.\n        const manifestNormalized = this.normalizeType(manifestType);\n        const dbNormalized = this.normalizeType(dbType);\n        const preflightSQL =\n          manifestNormalized === 'INTEGER' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'REAL')\n            ? this.generatePostgresIntegerPreflightSQL(\n                quotedTable,\n                quotedCol,\n                tableName,\n                colName,\n                dbNormalized,\n              )\n            : manifestNormalized === 'TIMESTAMP' &&\n                ['TIMESTAMP', 'TEXT', 'JSON'].includes(dbNormalized) &&\n                this.normalizeType(targetType) === 'TIMESTAMPTZ'\n              ? this.generatePostgresTimestampPreflightSQL(tableName, colName)\n              : null;\n        const clauses: string[] = [];\n\n        if (colDef.defaultValue !== undefined) {\n          clauses.push(`ALTER COLUMN ${quotedCol} DROP DEFAULT`);\n        }\n\n        let typeClause = `ALTER COLUMN ${quotedCol} TYPE ${targetType}`;\n        if (manifestNormalized === 'JSON' && dbNormalized === 'TEXT') {\n          // #1335: a bare `${col}::jsonb` cast raises \"invalid input syntax for\n          // type json\" on any row whose text is not already valid JSON (e.g. a\n          // legacy enum column holding 'active'). `to_jsonb(col)` instead wraps\n          // ANY text value as a JSON string and never errors, so a genuine\n          // TEXT->JSON widening survives non-JSON legacy data. (Note: with the\n          // json<->text equality tolerance added in this fix, the normal\n          // compare path no longer reaches here; this keeps the SQL safe for\n          // callers that construct a type_upgrade directly.)\n          typeClause += ` USING to_jsonb(${quotedCol})`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'JSON') {\n          // #1335: a native-json column cast back to text is value-preserving\n          // (`::text` renders the stored JSON as its text form), so this arm is\n          // safe. (Note: like the TEXT->JSON arm above, the json<->text equality\n          // tolerance means the normal compare path no longer reaches here; this\n          // keeps the SQL safe for callers that construct a type_upgrade\n          // directly.)\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'UUID') {\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'TEXT'\n        ) {\n          typeClause += ` USING trim(${quotedCol}::text)::integer`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'REAL'\n        ) {\n          typeClause += ` USING ${quotedCol}::integer`;\n        } else if (\n          manifestNormalized === 'TIMESTAMP' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'JSON')\n        ) {\n          typeClause += ` USING NULLIF(NULLIF(trim(both '\"' from ${quotedCol}::text), ''), 'null')::timestamptz`;\n        } else if (\n          manifestNormalized === 'TIMESTAMP' &&\n          dbNormalized === 'TIMESTAMP' &&\n          this.normalizeType(targetType) === 'TIMESTAMPTZ'\n        ) {\n          // SMRT's PostgreSQL adapter serialized Date values to UTC ISO strings.\n          // A legacy TIMESTAMP column discarded the trailing offset but kept\n          // that UTC wall time. Reattach UTC explicitly so migration is\n          // deterministic regardless of the database/session timezone.\n          typeClause += ` USING ${quotedCol} AT TIME ZONE 'UTC'`;\n        }\n\n        clauses.push(typeClause);\n\n        if (colDef.defaultValue !== undefined) {\n          const formattedDefault = this.ddlStrategy.formatDefaultValue(\n            colDef.defaultValue,\n            validatedType,\n          );\n          const defaultSql =\n            manifestNormalized === 'JSON'\n              ? `${formattedDefault}::${targetType.toLowerCase()}`\n              : formattedDefault;\n          clauses.push(`ALTER COLUMN ${quotedCol} SET DEFAULT ${defaultSql}`);\n        }\n\n        const alterSql = `ALTER TABLE ${quotedTable} ${clauses.join(', ')}`;\n\n        return preflightSQL\n          ? { sql: alterSql, statements: [preflightSQL, alterSql] }\n          : { sql: alterSql };\n      }\n\n      case 'duckdb':\n        // DuckDB supports ALTER COLUMN TYPE for type conversions\n        return {\n          sql: `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${targetType}`,\n        };\n\n      default: {\n        // Escape special characters in type names for safe comment generation\n        const safeDbType = dbType.replace(/[^\\w]/g, '_');\n        const safeManifestType = manifestType.replace(/[^\\w]/g, '_');\n        return {\n          sql: `-- Type upgrade for ${quotedCol}: ${safeDbType} → ${safeManifestType}`,\n        };\n      }\n    }\n  }\n\n  /**\n   * Quote a SQL identifier\n   */\n  private quoteIdentifier(name: string): string {\n    return `\"${name.replace(/\"/g, '\"\"')}\"`;\n  }\n\n  /**\n   * Generate a PostgreSQL preflight guard for narrowing legacy columns to\n   * INTEGER. PostgreSQL's REAL→INTEGER cast rounds fractional values, so the\n   * generated migration must fail before the ALTER can silently change data.\n   */\n  private generatePostgresIntegerPreflightSQL(\n    quotedTable: string,\n    quotedCol: string,\n    tableName: string,\n    colName: string,\n    dbNormalized: string,\n  ): string {\n    const invalidCondition =\n      dbNormalized === 'REAL'\n        ? `${quotedCol} IS NOT NULL AND ${quotedCol} <> trunc(${quotedCol})`\n        : `${quotedCol} IS NOT NULL AND trim(${quotedCol}::text) !~ '^[+-]?[0-9]+$'`;\n    const message = `Cannot convert ${tableName}.${colName} to INTEGER: found non-integer values`;\n\n    return `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${quotedTable} WHERE ${invalidCondition}) THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;\n  }\n\n  /**\n   * Require a UTC migration session before reattaching the offset discarded by\n   * legacy PostgreSQL TIMESTAMP columns. This is a guardrail, not provenance:\n   * operators must also confirm historical default/raw writers used UTC.\n   */\n  private generatePostgresTimestampPreflightSQL(\n    tableName: string,\n    colName: string,\n  ): string {\n    const message =\n      `Cannot convert ${tableName}.${colName} to TIMESTAMPTZ outside a UTC ` +\n      'PostgreSQL session; confirm historical writers used UTC and SET TIME ZONE UTC';\n    return `DO $$ BEGIN IF upper(current_setting('TimeZone')) NOT IN ('UTC', 'ETC/UTC', 'GMT') THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;\n  }\n\n  private quoteLiteral(value: string): string {\n    return `'${value.replace(/'/g, \"''\")}'`;\n  }\n\n  /**\n   * Generate SQL for adding a column\n   */\n  private generateAddColumnSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n  ): string {\n    // Build the ADD COLUMN definition inline (main) rather than delegating to\n    // the DDL strategy's generateColumnDefinition: that builder is for CREATE\n    // TABLE and would emit `PRIMARY KEY` (invalid in ALTER ... ADD COLUMN) and\n    // suppress single-column UNIQUE on engines that require inline unique at\n    // table-create time (DuckDB) — but an ADD COLUMN has no inline-constraint\n    // pass, so the UNIQUE must be emitted here. mapType still maps abstract\n    // types per dialect (UUID→native uuid / TEXT — R11); invalid types fall\n    // back to TEXT, matching the compareColumns guard.\n    const validatedType: SQLDataType = isValidSQLDataType(colDef.type)\n      ? colDef.type\n      : 'TEXT';\n    if (!isValidSQLDataType(colDef.type)) {\n      logger.warn(\n        `[SchemaComparer] Invalid manifest type \"${colDef.type}\" for ${tableName}.${colName}, treating as TEXT`,\n      );\n    }\n\n    const parts: string[] = [\n      this.quoteIdentifier(colName),\n      this.ddlStrategy.mapType(validatedType),\n    ];\n\n    if (colDef.notNull) {\n      parts.push('NOT NULL');\n    }\n    if (colDef.unique) {\n      parts.push('UNIQUE');\n    }\n    if (colDef.defaultValue !== undefined) {\n      const defaultVal = this.ddlStrategy.formatDefaultValue(\n        colDef.defaultValue,\n        validatedType,\n      );\n      parts.push(`DEFAULT ${defaultVal}`);\n    }\n    if (colDef.check) {\n      parts.push(`CHECK (${colDef.check})`);\n    }\n\n    const columnDefinition = parts.join(' ');\n\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${columnDefinition}`;\n  }\n\n  /**\n   * Generate SQL for dropping a column\n   */\n  private generateDropColumnSQL(tableName: string, colName: string): string {\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(colName)}`;\n  }\n\n  /**\n   * Generate SQL for adding an index.\n   *\n   * On engines that support partial indexes (SQLite/PostgreSQL) this mirrors\n   * the canonical CREATE INDEX path in the DDL strategies: a partial index\n   * appends its `WHERE` predicate so a detected predicate add/alter (issue\n   * #1692) recreates the index with the correct partial condition rather than\n   * silently widening it to a full index. On DuckDB / the JSON adapter — which\n   * reject partial indexes — the predicate is dropped so the emitted DDL stays\n   * executable (a partial index degrades to a full index there). The predicate\n   * is trimmed and a redundant leading `WHERE` stripped for robustness.\n   */\n  private generateAddIndexSQL(tableName: string, idx: IndexDefinition): string {\n    const uniqueStr = idx.unique ? 'UNIQUE ' : '';\n    const target = renderIndexTarget(idx, this.engine);\n    let sql = `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;\n    const where = idx.where?.trim().replace(/^WHERE\\s+/i, '');\n    if (this.supportsPartialIndexes() && where) {\n      sql += ` WHERE ${where}`;\n    }\n    return sql;\n  }\n\n  /**\n   * Generate SQL for dropping an index.\n   *\n   * This SQL is consumed by the manifest-driven execution path:\n   *\n   * - `db:migrate` runs the SQL we put in `change.sql` directly, with the\n   *   tracker's `executePostgresStatements` adding CONCURRENTLY when\n   *   `--postgres-safe` is on.\n   *\n   * PostgreSQL ends up with `CONCURRENTLY` when it should.\n   * Keeping this method engine-agnostic also means the diff preview text\n   * stays readable (no engine-specific noise) for engines like SQLite\n   * where CONCURRENTLY isn't a thing.\n   */\n  private generateDropIndexSQL(indexName: string): string {\n    return `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)}`;\n  }\n}\n\n/**\n * Generate a SchemaDiff from manifest and database\n */\nexport async function generateSchemaDiff(\n  db: DatabaseInterface,\n  manifestSchemas: Record<string, SchemaDefinition>,\n  options: DiffOptions = {},\n): Promise<SchemaDiff> {\n  const comparer = new SchemaComparer(db, options);\n  return comparer.compare(manifestSchemas);\n}\n\n/**\n * Check if a diff has any actionable changes (excluding type mismatches)\n */\nexport function hasActionableChanges(diff: SchemaDiff): boolean {\n  if (diff.added_tables.length > 0) return true;\n  if (diff.dropped_tables.length > 0) return true;\n  return diff.changes.some((c) => c.type !== 'type_mismatch');\n}\n\n/**\n * Get SQL statements from a diff for execution\n */\nexport function getSQLFromDiff(diff: SchemaDiff): string[] {\n  const statements: string[] = [];\n\n  // Add table creation (requires full DDL generation - not included here)\n  // This is typically handled by ensureSchema()\n\n  // Add column and index changes\n  for (const change of diff.changes) {\n    if (change.type !== 'type_mismatch') {\n      statements.push(\n        ...(change.sqlStatements ?? (change.sql ? [change.sql] : [])),\n      );\n    }\n  }\n\n  return statements;\n}\n"],"mappings":"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"}