@kaeawc/auto-mobile 0.0.85 → 0.0.87

package/dist/src/db/migrations/2026_07_03_000_repair_datetime_now_defaults.ts

@@ -1,278 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-/**
- * #2895 — repair the string-literal timestamp-default bug on already-migrated
- * databases.
- *
- * Every migration column that passed a plain SQL time-expression string to
- * `col.defaultTo(...)` — `"datetime('now')"` or `"CURRENT_TIMESTAMP"` — bound the
- * argument as a VALUE, not raw SQL, so its DDL emitted `DEFAULT 'datetime(''now'')'`
- * / `DEFAULT 'CURRENT_TIMESTAMP'`. Any row inserted without an explicit value for
- * such a column stored the useless literal text instead of a timestamp.
- *
- * The DDL is fixed FORWARD (all columns now use `defaultTo(sql`(datetime('now'))`)`),
- * so fresh databases are already correct. But a database that already ran the
- * buggy migrations keeps the broken `DEFAULT` in its stored schema — editing a
- * historical migration does NOT re-run it (Kysely tracks migrations by name, no
- * content checksum). So on an upgraded DB this migration must do TWO things:
- *
- *   1. REBUILD each column whose live default is the broken string literal, so
- *      FUTURE inserts that omit the column (e.g. `getOrCreateApp`, which omits
- *      `created_at`) stop re-poisoning it. SQLite cannot alter a column default
- *      in place, and bun:sqlite forbids editing `sqlite_master` directly, so we
- *      use the standard table-rebuild: create a twin table with the corrected
- *      default, copy the rows, drop the original, rename the twin back, recreate
- *      its indexes/triggers, and restore its `sqlite_sequence` AUTOINCREMENT
- *      high-water mark (so a rebuilt table cannot reuse a deleted top id). FK
- *      enforcement is toggled OFF around the
- *      rebuild (see `up`) so dropping a referenced parent cannot cascade-delete
- *      its children, then `PRAGMA foreign_key_check` verifies integrity before it
- *      is restored.
- *   2. REPAIR the existing poisoned rows in those columns to an evaluated
- *      timestamp.
- *
- * TARGETING — the fix keys off `pragma_table_info(...).dflt_value`, which reports
- * a column's stored default. Only the two broken string-literal forms match
- * ({@link BROKEN_DEFAULTS}); a corrected `(datetime('now'))` default, a bare
- * `CURRENT_TIMESTAMP` keyword, and legitimate value defaults (`'{}'`, `'success'`)
- * all report a different `dflt_value` and are skipped. This is deliberately
- * NARROWER than "rewrite any TEXT cell equal to the literal": columns like
- * `storage_events.value` persist arbitrary app data (an app could legitimately
- * store the string `datetime('now')`), so restricting the row repair to columns
- * that actually carry the broken default is what keeps it from corrupting real
- * data.
- *
- * The evaluated `datetime('now')` written for repaired rows is the best available
- * timestamp for a row that never had a real one (its true creation time is
- * unrecoverable). It is stored in SQLite's `YYYY-MM-DD HH:MM:SS` format — the same
- * format the fixed column defaults now emit and the codebase's other
- * server-evaluated-now writes use (`sql`datetime('now')`` in ThresholdManager /
- * MemoryThresholdManager) — rather than the app's ISO-8601. This divergence is
- * deliberate and harmless: no column is both defaulted AND written explicit ISO at
- * an ordered/compared read site (audited during #2895 review), and every TTL
- * comparison wraps the value in `datetime(...)`, which normalizes both formats.
- *
- * Safe on a fresh DB and idempotent: fresh/replayed schemas carry the corrected
- * default, so no column matches {@link BROKEN_DEFAULTS} and the whole pass is a
- * no-op. A second run finds nothing left to rebuild or repair.
- */
-
-/**
- * A column's stored default (as reported by `pragma_table_info(...).dflt_value`)
- * mapped to the corrected default expression it should carry and the literal
- * value its poisoned rows hold. The `dflt_value` keys are the exact broken
- * string-literal forms — a correct `datetime('now')` / `CURRENT_TIMESTAMP`
- * default reports differently and never matches.
- */
-const BROKEN_DEFAULTS: Record<string, { corrected: string; poisonedValue: string }> = {
-  "'datetime(''now'')'": { corrected: "(datetime('now'))", poisonedValue: "datetime('now')" },
-  "'CURRENT_TIMESTAMP'": { corrected: "CURRENT_TIMESTAMP", poisonedValue: "CURRENT_TIMESTAMP" },
-};
-
-interface NamedRow {
-  name: string;
-}
-
-interface ColumnInfoRow {
-  name: string;
-  dflt_value: string | null;
-}
-
-interface SqlRow {
-  sql: string | null;
-}
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  // Fast path: on a fresh/already-fixed schema no column carries a broken default,
-  // so there is nothing to rebuild. Return WITHOUT touching PRAGMA foreign_keys so
-  // the common case (every existing DB and test) leaves the connection's FK state
-  // exactly as the caller set it. Only the rare upgraded-DB path below toggles it.
-  const brokenTables = await findTablesWithBrokenDefaults(db);
-  if (brokenTables.length === 0) {
-    return;
-  }
-
-  // Rebuilding a table that OTHER tables reference by foreign key requires FK
-  // enforcement OFF: `DROP TABLE` performs an implicit DELETE that would otherwise
-  // fire `ON DELETE CASCADE` and wipe the child rows (deferral only delays the
-  // constraint *check*, not the cascade *action*). `PRAGMA foreign_keys` is a
-  // no-op inside a transaction, so it is toggled on the connection around the
-  // transaction — safe because the migrator does not wrap SQLite migrations in a
-  // transaction and the run is serialized by the migration lock. It is restored to
-  // ON afterwards: this branch only runs on an upgraded production DB, whose
-  // connection is configured FK-ON (`configureSqliteDatabase`), which is also the
-  // state the rest of the migration chain expects.
-  await sql`PRAGMA foreign_keys = OFF`.execute(db);
-  try {
-    // One transaction so a mid-rebuild failure cannot leave a half-swapped schema.
-    await db.transaction().execute(async (trx) => {
-      await rebuildAndRepair(trx, brokenTables);
-    });
-  } finally {
-    await sql`PRAGMA foreign_keys = ON`.execute(db);
-  }
-}
-
-/**
- * Return the tables that have at least one column whose stored default is a
- * broken string literal. Uses a `SELECT`-shaped `pragma_table_info(...)` read so
- * the bunSqliteDialect returns rows (a bare `PRAGMA x` value read does not).
- */
-async function findTablesWithBrokenDefaults(db: Kysely<unknown>): Promise<string[]> {
-  const tables = await sql<NamedRow>`
-    SELECT name FROM sqlite_master
-    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
-  `.execute(db);
-
-  const broken: string[] = [];
-  for (const { name: table } of tables.rows) {
-    // Inline the table name as a literal (sql.lit), not a bound parameter: a
-    // parameterized pragma_table_info(?) was observed to intermittently return a
-    // null dflt_value under parallel-file load (bun:sqlite quirk, see #2922's
-    // test). Here a spurious null on a genuinely-poisoned column would fail the
-    // `!== null` guard below, so the column would never be added to the broken set
-    // and its poisoned default would be silently skipped and never rebuilt (#3612).
-    // Matches 2026_07_05_000_repair_updated_at_defaults.ts.
-    const columns = await sql<ColumnInfoRow>`
-      SELECT dflt_value FROM pragma_table_info(${sql.lit(table)})
-    `.execute(db);
-    if (
-      columns.rows.some(
-        (column) => column.dflt_value !== null && column.dflt_value in BROKEN_DEFAULTS,
-      )
-    ) {
-      broken.push(table);
-    }
-  }
-  return broken;
-}
-
-async function rebuildAndRepair(trx: Kysely<unknown>, tables: string[]): Promise<void> {
-  for (const table of tables) {
-    // sql.lit (not a bound param) for the same bun:sqlite null-dflt_value quirk
-    // guarded in findTablesWithBrokenDefaults above (#2922 / #3612).
-    const columns = await sql<ColumnInfoRow>`
-      SELECT name, dflt_value FROM pragma_table_info(${sql.lit(table)})
-    `.execute(trx);
-
-    const brokenColumns = columns.rows.filter(
-      (column) => column.dflt_value !== null && column.dflt_value in BROKEN_DEFAULTS,
-    );
-    if (brokenColumns.length === 0) {
-      continue;
-    }
-
-    await rebuildTableWithCorrectedDefaults(trx, table);
-
-    // Rows copied verbatim during the rebuild still hold the literal; heal them
-    // now, restricted to the columns that actually carried the broken default.
-    for (const column of brokenColumns) {
-      const { poisonedValue } = BROKEN_DEFAULTS[column.dflt_value as string];
-      await sql`
-        UPDATE ${sql.ref(table)}
-        SET ${sql.ref(column.name)} = datetime('now')
-        WHERE ${sql.ref(column.name)} = ${poisonedValue}
-      `.execute(trx);
-    }
-  }
-}
-
-/**
- * Rebuild `table` so every broken string-literal default becomes its corrected
- * raw-SQL form, preserving data, indexes, and triggers. Only the `DEFAULT`
- * clauses change; column set and order are untouched, so `INSERT ... SELECT *`
- * lines the rows up 1:1.
- */
-async function rebuildTableWithCorrectedDefaults(
-  trx: Kysely<unknown>,
-  table: string,
-): Promise<void> {
-  const createRow = await sql<SqlRow>`
-    SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ${table}
-  `.execute(trx);
-  const createSql = createRow.rows[0]?.sql;
-  if (!createSql) {
-    return;
-  }
-
-  const tempTable = `__rebuild_${table}`;
-  let correctedSql = replaceFirstTableName(createSql, table, tempTable);
-  for (const brokenDefault of Object.keys(BROKEN_DEFAULTS)) {
-    // The broken literal only appears in the schema as a column default, so a
-    // global replace cannot touch anything else.
-    correctedSql = correctedSql.split(brokenDefault).join(BROKEN_DEFAULTS[brokenDefault].corrected);
-  }
-
-  // Capture the table's own indexes and triggers before the drop — auto-indexes
-  // backing PRIMARY KEY / UNIQUE constraints have a NULL `sql` and are recreated
-  // by the CREATE TABLE itself, so only the explicit ones need replaying.
-  const auxiliary = await sql<SqlRow>`
-    SELECT sql FROM sqlite_master
-    WHERE tbl_name = ${table} AND type IN ('index', 'trigger') AND sql IS NOT NULL
-  `.execute(trx);
-
-  // Capture the AUTOINCREMENT high-water mark. `sqlite_sequence` records the
-  // highest rowid EVER used so AUTOINCREMENT never reuses a deleted id; the
-  // copy/drop/rename below would otherwise reset it to `max(current id)` and let a
-  // deleted top id be handed out again — aliasing ids that other tables reference
-  // as plain integers. Restored after the rename.
-  const originalSequence = await captureSequence(trx, table);
-
-  await sql.raw(correctedSql).execute(trx);
-  await sql`INSERT INTO ${sql.ref(tempTable)} SELECT * FROM ${sql.ref(table)}`.execute(trx);
-  await sql`DROP TABLE ${sql.ref(table)}`.execute(trx);
-  await sql`ALTER TABLE ${sql.ref(tempTable)} RENAME TO ${sql.ref(table)}`.execute(trx);
-  for (const { sql: auxSql } of auxiliary.rows) {
-    if (auxSql) {
-      await sql.raw(auxSql).execute(trx);
-    }
-  }
-
-  if (originalSequence !== undefined) {
-    await sql`DELETE FROM sqlite_sequence WHERE name = ${table}`.execute(trx);
-    await sql`INSERT INTO sqlite_sequence (name, seq) VALUES (${table}, ${originalSequence})`.execute(
-      trx,
-    );
-  }
-}
-
-/**
- * Read a table's `sqlite_sequence` high-water mark, or `undefined` when the table
- * is not AUTOINCREMENT / has never been inserted into (no sequence row) or the
- * `sqlite_sequence` table does not exist (no AUTOINCREMENT table in the DB).
- */
-async function captureSequence(trx: Kysely<unknown>, table: string): Promise<number | undefined> {
-  const hasSequenceTable = await sql<NamedRow>`
-    SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'
-  `.execute(trx);
-  if (hasSequenceTable.rows.length === 0) {
-    return undefined;
-  }
-  const seqRow = await sql<{ seq: number }>`
-    SELECT seq FROM sqlite_sequence WHERE name = ${table}
-  `.execute(trx);
-  return seqRow.rows[0]?.seq;
-}
-
-/**
- * Replace the table name in a `CREATE TABLE` statement, tolerating the double-
- * quoted (Kysely) and bare forms and arbitrary whitespace after the keyword.
- * Only the first occurrence — the table being declared — is rewritten; a later
- * self-reference (e.g. a table-level FK) keeps pointing at the real name so the
- * copy still works.
- */
-function replaceFirstTableName(createSql: string, from: string, to: string): string {
-  // Match the declared table name as either a double-quoted identifier (Kysely's
-  // form) or a bare word, and rewrite only when it is exactly `from` so a later
-  // self-reference in the body is left untouched.
-  return createSql.replace(
-    /^(\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?)(?:"([^"]+)"|(\w+))/i,
-    (match, prefix: string, quotedName: string | undefined, bareName: string | undefined) =>
-      (quotedName ?? bareName) === from ? `${prefix}"${to}"` : match,
-  );
-}
-
-export async function down(): Promise<void> {
-  // Irreversible repair: the corrected defaults and healed rows carry no
-  // information worth reverting, so the down migration is intentionally a no-op.
-}

package/dist/src/db/migrations/2026_07_04_000_storage_events_key_lookup.ts

@@ -1,60 +0,0 @@
-import type { Kysely } from "kysely";
-
-/**
- * Seek-reduction index for `recordStorageEvent`'s per-insert previous-value
- * lookup (#2798).
- *
- * On every storage telemetry insert that doesn't already carry `previousValue`,
- * `storageEventRepository.recordStorageEvent` runs:
- *
- *   SELECT value FROM storage_events
- *   WHERE device_id=? AND file_name=? AND key=?
- *   ORDER BY timestamp DESC LIMIT 1
- *
- * #2798 was filed against the pre-#2788 schema, where the only usable index was
- * the standalone `idx_storage_events_device` and the plan showed
- * `USE TEMP B-TREE FOR ORDER BY`. That temp B-tree is ALREADY gone: PR #2890
- * (#2788) added `idx_storage_events_device_timestamp (device_id, timestamp)` and
- * PR #2904 (#2893) dropped the standalone device index, so the composite's
- * `device_id` prefix now supplies the DESC order for free.
- *
- * What remains — and what this index fixes — is the SEEK width. With only the
- * `(device_id, timestamp)` composite the planner seeks on `device_id=?` and then
- * scans every row for that device in timestamp order, applying the `file_name=?`
- * and `key=?` filters row-by-row until the first match. A device with many
- * distinct keys makes that scan arbitrarily long. `(device_id, file_name, key,
- * timestamp)` turns the three equality predicates into a single prefix seek that
- * descends straight to the target key's rows, and the trailing `timestamp` column
- * still yields the newest row without a sort (SQLite walks the ascending index
- * backward for `ORDER BY timestamp DESC`).
- *
- * NOT a covering index (per Mira Kessler's review on #2798): the query selects
- * `value`, which is deliberately NOT in the index — `value` is an arbitrarily
- * large TEXT blob, and widening the index to make the read index-only is a bad
- * trade. The plan is a prefix seek + one rowid lookup for `value`; the name is
- * `_key_lookup` (a seek-reduction index), NOT `_covering`.
- *
- * Distinct from `idx_storage_events_device_timestamp` (#2788), not a
- * planner-redundant near-duplicate: that composite serves the device-scoped
- * getter (`WHERE device_id=? ORDER BY timestamp DESC`) and cannot serve this
- * three-equality predicate as a prefix seek; this index cannot serve the
- * device-only getter's ordering as efficiently. The planner picks each for its
- * own shape.
- *
- * Additive and forward-only, `.ifNotExists()` / `.ifExists()` so the migration
- * survives #2785's destructive-recovery replay (drop-all then replay every
- * migration on an empty DB) in unusual orders. Sorts after
- * `2026_07_03_*`, so `storage_events` exists when it runs during a full replay.
- */
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createIndex("idx_storage_events_key_lookup")
-    .ifNotExists()
-    .on("storage_events")
-    .columns(["device_id", "file_name", "key", "timestamp"])
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropIndex("idx_storage_events_key_lookup").ifExists().execute();
-}

package/dist/src/db/migrations/2026_07_05_000_repair_updated_at_defaults.ts

@@ -1,239 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-/**
- * #2937 — give eight tables' `updated_at` columns their `(datetime('now'))`
- * default on already-upgraded databases.
- *
- * PR #2922 (issue #2913) reconciled the schema by adding
- * `.defaultTo(sql`(datetime('now'))`)` to these eight tables' `updated_at`
- * migration declarations, matching their `created_at` sibling. But editing a
- * historical migration body does NOT re-run it — Kysely tracks executed
- * migrations by name, with no content checksum — so the added default lands only
- * on FRESH/replayed databases. A database that already ran the pre-#2922
- * migrations keeps the old `updated_at TEXT NOT NULL` column with no default,
- * and a defaulted insert (one that omits `updated_at`) fails its NOT NULL
- * constraint there.
- *
- * This mirrors the `created_at` situation before #2915, minus the live bug:
- * `created_at` had a broken string-literal default actively poisoning new rows,
- * which the {@link file://./2026_07_03_000_repair_datetime_now_defaults.ts}
- * rebuild repaired. `updated_at` has no such poison — every current writer
- * supplies it explicitly — so this migration only needs to REBUILD each column's
- * default; the existing rows already hold real, explicitly-written timestamps and
- * are copied through untouched (no row repair).
- *
- * REBUILD MECHANICS — identical to the #2915 repair: SQLite cannot alter a column
- * default in place, and bun:sqlite forbids editing `sqlite_master` directly, so
- * each table is rebuilt via a twin: create a twin whose `updated_at` carries the
- * corrected default, copy the rows with `INSERT ... SELECT *`, drop the original,
- * rename the twin back, replay the table's explicit indexes/triggers, and restore
- * its `sqlite_sequence` AUTOINCREMENT high-water mark (so a rebuilt table cannot
- * reuse a deleted top id). FK enforcement is toggled OFF around the transaction so
- * dropping a referenced parent (e.g. `navigation_apps`) cannot cascade-delete its
- * children.
- *
- * TARGETING — the eight tables are enumerated in {@link TABLES_WITH_DEFAULTED_UPDATED_AT}
- * (exactly the set #2922 edited), and each is rebuilt only when its live
- * `updated_at` default is absent. Detection reads
- * `pragma_table_info(...).dflt_value`: `NULL` means the no-default upgraded column
- * (rebuild it); the corrected default reports as `datetime('now')` and is skipped.
- * `device_sessions` / `failure_groups` are deliberately NOT listed — their
- * `updated_at` default has existed on every database since #2915 repaired the
- * broken literal they originally shipped, so they need no rebuild.
- *
- * Safe on a fresh DB and idempotent: a fresh/replayed or already-rebuilt schema
- * carries the default, so nothing matches and the whole pass is a no-op that never
- * touches FK state. A second run finds every column already defaulted.
- */
-
-/**
- * The eight tables whose `updated_at` default was added by PR #2922 (a migration
- * edit that does not replay), so an upgraded DB's copy still lacks it. Ordered
- * arbitrarily; each is independently rebuilt.
- */
-const TABLES_WITH_DEFAULTED_UPDATED_AT = [
-  "device_configs",
-  "navigation_apps",
-  "prediction_transition_stats",
-  "accessibility_baselines",
-  "feature_flags",
-  "video_recording_configs",
-  "device_snapshot_configs",
-  "appearance_configs",
-] as const;
-
-/** The corrected default expression `updated_at` should carry, as raw SQL. */
-const CORRECTED_DEFAULT = "(datetime('now'))";
-
-interface ColumnInfoRow {
-  name: string;
-  dflt_value: string | null;
-}
-
-interface SqlRow {
-  sql: string | null;
-}
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  // Fast path: only the tables whose `updated_at` column exists AND has no
-  // default need a rebuild. On a fresh/already-fixed schema this is empty, so we
-  // return WITHOUT touching PRAGMA foreign_keys — leaving the connection's FK
-  // state exactly as the caller set it, as the common case (every existing DB and
-  // test) requires. Only the rare upgraded-DB path below toggles it.
-  const tablesToRebuild: string[] = [];
-  for (const table of TABLES_WITH_DEFAULTED_UPDATED_AT) {
-    if (await updatedAtLacksDefault(db, table)) {
-      tablesToRebuild.push(table);
-    }
-  }
-  if (tablesToRebuild.length === 0) {
-    return;
-  }
-
-  // Rebuilding a table that OTHER tables reference by foreign key requires FK
-  // enforcement OFF: `DROP TABLE` performs an implicit DELETE that would otherwise
-  // fire `ON DELETE CASCADE` and wipe the child rows (deferral only delays the
-  // constraint *check*, not the cascade *action*). `PRAGMA foreign_keys` is a
-  // no-op inside a transaction, so it is toggled on the connection around the
-  // transaction — safe because the migrator does not wrap SQLite migrations in a
-  // transaction and the run is serialized by the migration lock. Restored to ON
-  // afterwards, the state `configureSqliteDatabase` and the rest of the chain
-  // expect on the production connection.
-  await sql`PRAGMA foreign_keys = OFF`.execute(db);
-  try {
-    // One transaction so a mid-rebuild failure cannot leave a half-swapped schema.
-    await db.transaction().execute(async (trx) => {
-      for (const table of tablesToRebuild) {
-        await rebuildTableWithUpdatedAtDefault(trx, table);
-      }
-    });
-  } finally {
-    await sql`PRAGMA foreign_keys = ON`.execute(db);
-  }
-}
-
-/**
- * True when `table` exists and its `updated_at` column is present with NO stored
- * default (the pre-#2922 upgraded-DB shape). A corrected `(datetime('now'))`
- * default reports its `dflt_value` as `datetime('now')` (non-null) and is skipped;
- * a missing table or column yields no matching row and is also skipped.
- *
- * The table name is inlined as a literal (`sql.lit`) rather than a bound
- * parameter: a parameterized `pragma_table_info(?)` read was observed to
- * intermittently return a null `dflt_value` under parallel-file load (a bun:sqlite
- * quirk, see #2922's test), which here — where null is the very signal that
- * triggers a rebuild — would spuriously rebuild a fresh table.
- */
-async function updatedAtLacksDefault(db: Kysely<unknown>, table: string): Promise<boolean> {
-  const columns = await sql<ColumnInfoRow>`
-    SELECT name, dflt_value FROM pragma_table_info(${sql.lit(table)})
-  `.execute(db);
-  const updatedAt = columns.rows.find((column) => column.name === "updated_at");
-  return updatedAt !== undefined && updatedAt.dflt_value === null;
-}
-
-/**
- * Rebuild `table` so its `updated_at` column gains the `(datetime('now'))`
- * default, preserving data, indexes, and triggers. Only the `updated_at` column's
- * `DEFAULT` clause changes; the column set and order are untouched, so
- * `INSERT ... SELECT *` lines the rows up 1:1.
- */
-async function rebuildTableWithUpdatedAtDefault(
-  trx: Kysely<unknown>,
-  table: string,
-): Promise<void> {
-  const createRow = await sql<SqlRow>`
-    SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ${table}
-  `.execute(trx);
-  const createSql = createRow.rows[0]?.sql;
-  if (!createSql) {
-    return;
-  }
-
-  const tempTable = `__rebuild_${table}`;
-  const correctedSql = addUpdatedAtDefault(replaceFirstTableName(createSql, table, tempTable));
-
-  // Capture the table's own indexes and triggers before the drop — auto-indexes
-  // backing PRIMARY KEY / UNIQUE constraints have a NULL `sql` and are recreated
-  // by the CREATE TABLE itself, so only the explicit ones need replaying.
-  const auxiliary = await sql<SqlRow>`
-    SELECT sql FROM sqlite_master
-    WHERE tbl_name = ${table} AND type IN ('index', 'trigger') AND sql IS NOT NULL
-  `.execute(trx);
-
-  // Capture the AUTOINCREMENT high-water mark. `sqlite_sequence` records the
-  // highest rowid EVER used so AUTOINCREMENT never reuses a deleted id; the
-  // copy/drop/rename below would otherwise reset it to `max(current id)` and let a
-  // deleted top id be handed out again. Restored after the rename.
-  const originalSequence = await captureSequence(trx, table);
-
-  await sql.raw(correctedSql).execute(trx);
-  await sql`INSERT INTO ${sql.ref(tempTable)} SELECT * FROM ${sql.ref(table)}`.execute(trx);
-  await sql`DROP TABLE ${sql.ref(table)}`.execute(trx);
-  await sql`ALTER TABLE ${sql.ref(tempTable)} RENAME TO ${sql.ref(table)}`.execute(trx);
-  for (const { sql: auxSql } of auxiliary.rows) {
-    if (auxSql) {
-      await sql.raw(auxSql).execute(trx);
-    }
-  }
-
-  if (originalSequence !== undefined) {
-    await sql`DELETE FROM sqlite_sequence WHERE name = ${table}`.execute(trx);
-    await sql`INSERT INTO sqlite_sequence (name, seq) VALUES (${table}, ${originalSequence})`.execute(
-      trx,
-    );
-  }
-}
-
-/**
- * Read a table's `sqlite_sequence` high-water mark, or `undefined` when the table
- * is not AUTOINCREMENT / has never been inserted into (no sequence row) or the
- * `sqlite_sequence` table does not exist (no AUTOINCREMENT table in the DB).
- */
-async function captureSequence(trx: Kysely<unknown>, table: string): Promise<number | undefined> {
-  const hasSequenceTable = await sql<{ name: string }>`
-    SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'
-  `.execute(trx);
-  if (hasSequenceTable.rows.length === 0) {
-    return undefined;
-  }
-  const seqRow = await sql<{ seq: number }>`
-    SELECT seq FROM sqlite_sequence WHERE name = ${table}
-  `.execute(trx);
-  return seqRow.rows[0]?.seq;
-}
-
-/**
- * Inject `default (datetime('now'))` into the `updated_at` column definition of a
- * `CREATE TABLE` statement, right after its type keyword. Matches only when the
- * column has no existing default (the type is immediately followed by `not null`),
- * so it is a no-op on a schema that already carries the default and never
- * double-adds. Only the first (and only) `"updated_at"` column definition is
- * rewritten.
- */
-function addUpdatedAtDefault(createSql: string): string {
-  return createSql.replace(
-    /("updated_at"\s+\w+)(\s+not\s+null)/i,
-    `$1 default ${CORRECTED_DEFAULT}$2`,
-  );
-}
-
-/**
- * Replace the table name in a `CREATE TABLE` statement, tolerating the double-
- * quoted (Kysely) and bare forms and arbitrary whitespace after the keyword.
- * Only the first occurrence — the table being declared — is rewritten; a later
- * self-reference (e.g. a table-level FK) keeps pointing at the real name so the
- * copy still works.
- */
-function replaceFirstTableName(createSql: string, from: string, to: string): string {
-  return createSql.replace(
-    /^(\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?)(?:"([^"]+)"|(\w+))/i,
-    (match, prefix: string, quotedName: string | undefined, bareName: string | undefined) =>
-      (quotedName ?? bareName) === from ? `${prefix}"${to}"` : match,
-  );
-}
-
-export async function down(): Promise<void> {
-  // Irreversible repair: the corrected default carries no information worth
-  // reverting, so the down migration is intentionally a no-op.
-}

package/dist/src/db/migrations/2026_07_24_000_device_locks.ts

@@ -1,27 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-/**
- * Remember how to unlock a device, keyed by device (issue #4360).
- *
- * A dedicated table rather than columns on `device_sessions`: a session row only
- * exists when device-pool autolock is enabled, and never during boot (which runs
- * before any session), so session-scoped storage cannot deliver
- * remember-then-reuse in the default config or at boot. `lock_credential` is
- * stored as-is in the local `~/.auto-mobile` DB — a single-user, on-disk
- * automation store — so a locked dev device does not have to be unlocked by hand
- * every session.
- */
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable("device_locks")
-    .ifNotExists()
-    .addColumn("device_id", "text", (col) => col.primaryKey())
-    .addColumn("lock_type", "text", (col) => col.notNull())
-    .addColumn("lock_credential", "text")
-    .addColumn("updated_at", "text", (col) => col.notNull().defaultTo(sql`(datetime('now'))`))
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable("device_locks").execute();
-}

package/dist/src/db/migrations/2026_07_27_000_session_tool_capabilities.ts

@@ -1,17 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable("session_tool_capabilities")
-    .ifNotExists()
-    .addColumn("session_uuid", "text", (col) => col.notNull())
-    .addColumn("capability", "text", (col) => col.notNull())
-    .addColumn("enabled", "integer", (col) => col.notNull())
-    .addColumn("updated_at", "text", (col) => col.notNull().defaultTo(sql`(datetime('now'))`))
-    .addPrimaryKeyConstraint("session_tool_capabilities_pk", ["session_uuid", "capability"])
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable("session_tool_capabilities").ifExists().execute();
-}

package/dist/src/db/migrations/2026_07_31_000_video_recordings_owner_session.ts

@@ -1,39 +0,0 @@
-import { sql, type Kysely } from "kysely";
-
-/**
- * Session-scope the video recording archive (issue #4752).
- *
- * Adds a nullable `owner_session_uuid` column recording the daemon session that
- * started a recording. The column is deliberately nullable: rows that predate
- * this migration have no known owner and keep a NULL owner. The read policy
- * (see `VideoRecordingRepository`) treats a NULL-owner row as legacy/unowned and
- * readable by any session, while a row with a non-null owner is only returned to
- * that owner — so this migration hardens new recordings without orphaning the
- * existing archive.
- */
-export async function up(db: Kysely<unknown>): Promise<void> {
-  const existingColumn = await sql<{ name: string }>`
-    SELECT name FROM pragma_table_info('video_recordings')
-    WHERE name = 'owner_session_uuid'
-  `.execute(db);
-
-  if (existingColumn.rows.length === 0) {
-    await db.schema
-      .alterTable("video_recordings")
-      .addColumn("owner_session_uuid", "text")
-      .execute();
-  }
-
-  await db.schema
-    .createIndex("idx_video_recordings_owner_session")
-    .ifNotExists()
-    .on("video_recordings")
-    .column("owner_session_uuid")
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropIndex("idx_video_recordings_owner_session").execute();
-
-  await db.schema.alterTable("video_recordings").dropColumn("owner_session_uuid").execute();
-}