velocious 1.0.695 → 1.0.697

package/build/src/database/migrations-ledger.d.ts

@@ -20,13 +20,46 @@ export default class MigrationsLedger {
      * @returns {Promise<boolean>} - Whether the ledger table exists.
      */
     static tableExists(db: import("./drivers/base.js").default): Promise<boolean>;
+    /**
+     * Whether the error means a concurrent session already created the ledger table.
+     *
+     * Several processes bootstrap the same database at the same time (for example every
+     * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard
+     * is NOT atomic: two sessions can both evaluate the check as false and then both
+     * create, so the loser is rejected. Walks the wrapped-error cause chain because
+     * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the
+     * stable numeric error number instead of the localized message text.
+     * @param {unknown} error - Error thrown while creating the ledger table.
+     * @returns {boolean} - True if the table was created by a concurrent session.
+     */
+    static isConcurrentCreationError(error: unknown): boolean;
+    /**
+     * Whether the error is a transient deadlock that should be retried.
+     *
+     * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that
+     * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,
+     * so retrying it is safe. Matched by numeric error number, never by message text.
+     * @param {unknown} error - Error thrown while inspecting or creating the ledger table.
+     * @returns {boolean} - True if the error is a retryable deadlock.
+     */
+    static isDeadlockError(error: unknown): boolean;
     /**
      * Creates the ledger table if it does not exist. This is the single definition of
      * the `schema_migrations` table shape.
+     *
+     * Safe under concurrency: a session that loses the create race (or deadlocks on the
+     * catalog read) converges on the existing table instead of failing its caller. That
+     * matters because this runs on every boot of a database configured for migrations
+     * (see `Migrator#createMigrationsTableForDatabase` and
+     * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard
+     * or deployment over a table that provably already exists.
      * @param {import("./drivers/base.js").default} db - Database that should contain the ledger table.
+     * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.
      * @returns {Promise<void>}
      */
-    static ensureTable(db: import("./drivers/base.js").default): Promise<void>;
+    static ensureTable(db: import("./drivers/base.js").default, { maxAttempts }?: {
+        maxAttempts?: number;
+    }): Promise<void>;
     /**
      * Every applied migration version recorded in the ledger.
      * @param {import("./drivers/base.js").default} db - Database whose applied versions are loaded.

package/build/src/database/migrations-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrations-ledger.d.ts","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC;;;OAGG;IACH,MAAM,CAAC,SAAS,IAFH,MAAM,CAIlB;IAED;;;;OAIG;IACH,OAAa,WAAW,CAAC,EAAE,EAHhB,OAAO,mBAAmB,EAAE,OAGZ,GAFd,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,OAAa,WAAW,CAAC,EAAE,EAHhB,OAAO,mBAAmB,EAAE,OAGZ,GAFd,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,EAAE,EAHpB,OAAO,mBAAmB,EAAE,OAGR,GAFlB,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;IAED;;;;;OAKG;IACH,OAAa,UAAU,CAAC,EAAE,EAJf,OAAO,mBAAmB,EAAE,OAIb,EAAE,OAAO,EAHxB,MAGwB,GAFtB,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;;;;OAMG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,OAAa,WAAW,CAAC,EAAE,EAJhB,OAAO,mBAAmB,EAAE,OAIZ,EAAE,QAAQ,EAH1B,MAAM,EAGoB,GAFxB,OAAO,CAAC,MAAM,EAAE,CAAC,CAmB7B;IAED;;;;;;;OAOG;IACH,OAAa,oBAAoB,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAC,EAH3C;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAA;KAGlD,GAFzC,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;CACF"}
+{"version":3,"file":"migrations-ledger.d.ts","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC;;;OAGG;IACH,MAAM,CAAC,SAAS,IAFH,MAAM,CAIlB;IAED;;;;OAIG;IACH,OAAa,WAAW,CAAC,EAAE,EAHhB,OAAO,mBAAmB,EAAE,OAGZ,GAFd,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,yBAAyB,CAAC,KAAK,EAH3B,OAG2B,GAFzB,OAAO,CAcnB;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAHjB,OAGiB,GAFf,OAAO,CAcnB;IAED;;;;;;;;;;;;;OAaG;IACH,OAAa,WAAW,CAAC,EAAE,EAJhB,OAAO,mBAAmB,EAAE,OAIZ,EAAE,EAAC,WAAe,EAAC,AAH3C,CACA,EADQ;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAGmB,GAFtC,OAAO,CAAC,IAAI,CAAC,CAwCzB;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,EAAE,EAHpB,OAAO,mBAAmB,EAAE,OAGR,GAFlB,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;IAED;;;;;OAKG;IACH,OAAa,UAAU,CAAC,EAAE,EAJf,OAAO,mBAAmB,EAAE,OAIb,EAAE,OAAO,EAHxB,MAGwB,GAFtB,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;;;;OAMG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,OAAa,WAAW,CAAC,EAAE,EAJhB,OAAO,mBAAmB,EAAE,OAIZ,EAAE,QAAQ,EAH1B,MAAM,EAGoB,GAFxB,OAAO,CAAC,MAAM,EAAE,CAAC,CAmB7B;IAED;;;;;;;OAOG;IACH,OAAa,oBAAoB,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAC,EAH3C;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAA;KAGlD,GAFzC,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;CACF"}

package/build/src/database/migrations-ledger.js

@@ -2,6 +2,10 @@
 import { digg } from "diggerize";
 import TableData from "./table-data/index.js";
 const TABLE_NAME = "schema_migrations";
+/** SQL Server "There is already an object named ..." — raised when two sessions race to create the same table. */
+const MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER = 2714;
+/** SQL Server deadlock victim — raised when concurrent sessions deadlock on the same catalog reads. */
+const MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER = 1205;
 /**
  * Single owner of the `schema_migrations` ledger shape and the only place that reads
  * or writes applied migration versions for a database connection. The migrator uses
@@ -29,21 +33,90 @@ export default class MigrationsLedger {
         const table = await db.getTableByName(TABLE_NAME, { throwError: false });
         return Boolean(table);
     }
+    /**
+     * Whether the error means a concurrent session already created the ledger table.
+     *
+     * Several processes bootstrap the same database at the same time (for example every
+     * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard
+     * is NOT atomic: two sessions can both evaluate the check as false and then both
+     * create, so the loser is rejected. Walks the wrapped-error cause chain because
+     * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the
+     * stable numeric error number instead of the localized message text.
+     * @param {unknown} error - Error thrown while creating the ledger table.
+     * @returns {boolean} - True if the table was created by a concurrent session.
+     */
+    static isConcurrentCreationError(error) {
+        let current = error;
+        while (current instanceof Error) {
+            const errorNumber = /** @type {{number?: unknown}} */ (current).number;
+            if (typeof errorNumber === "number" && errorNumber === MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER)
+                return true;
+            current = current.cause;
+        }
+        return false;
+    }
+    /**
+     * Whether the error is a transient deadlock that should be retried.
+     *
+     * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that
+     * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,
+     * so retrying it is safe. Matched by numeric error number, never by message text.
+     * @param {unknown} error - Error thrown while inspecting or creating the ledger table.
+     * @returns {boolean} - True if the error is a retryable deadlock.
+     */
+    static isDeadlockError(error) {
+        let current = error;
+        while (current instanceof Error) {
+            const errorNumber = /** @type {{number?: unknown}} */ (current).number;
+            if (typeof errorNumber === "number" && errorNumber === MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER)
+                return true;
+            current = current.cause;
+        }
+        return false;
+    }
     /**
      * Creates the ledger table if it does not exist. This is the single definition of
      * the `schema_migrations` table shape.
+     *
+     * Safe under concurrency: a session that loses the create race (or deadlocks on the
+     * catalog read) converges on the existing table instead of failing its caller. That
+     * matters because this runs on every boot of a database configured for migrations
+     * (see `Migrator#createMigrationsTableForDatabase` and
+     * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard
+     * or deployment over a table that provably already exists.
      * @param {import("./drivers/base.js").default} db - Database that should contain the ledger table.
+     * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.
      * @returns {Promise<void>}
      */
-    static async ensureTable(db) {
-        if (await MigrationsLedger.tableExists(db))
-            return;
-        const tableData = new TableData(TABLE_NAME, { ifNotExists: true });
-        tableData.string("version", { null: false, primaryKey: true });
-        for (const sql of await db.createTableSql(tableData)) {
-            await db.query(sql);
+    static async ensureTable(db, { maxAttempts = 3 } = {}) {
+        let attempt = 0;
+        while (true) {
+            attempt++;
+            try {
+                if (await MigrationsLedger.tableExists(db))
+                    return;
+                const tableData = new TableData(TABLE_NAME, { ifNotExists: true });
+                tableData.string("version", { null: false, primaryKey: true });
+                for (const sql of await db.createTableSql(tableData)) {
+                    await db.query(sql);
+                }
+                db.clearSchemaCache();
+                return;
+            }
+            catch (error) {
+                if (MigrationsLedger.isConcurrentCreationError(error)) {
+                    // Another session created the ledger between our check and our create. The
+                    // table exists with exactly this shape, so the goal state is already reached.
+                    db.clearSchemaCache();
+                    return;
+                }
+                if (MigrationsLedger.isDeadlockError(error) && attempt < maxAttempts) {
+                    db.clearSchemaCache();
+                    continue;
+                }
+                throw error;
+            }
         }
-        db.clearSchemaCache();
     }
     /**
      * Every applied migration version recorded in the ledger.
@@ -123,4 +196,4 @@ export default class MigrationsLedger {
         return await MigrationsLedger.markApplied(targetDb, sourceVersions);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrations-ledger.js","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport TableData from \"./table-data/index.js\"\n\nconst TABLE_NAME = \"schema_migrations\"\n\n/**\n * Single owner of the `schema_migrations` ledger shape and the only place that reads\n * or writes applied migration versions for a database connection. The migrator uses\n * it to record versions as it runs migrations; provisioning / schema-clone paths use\n * `markApplied` / `baselineFromDatabase` to record versions as applied WITHOUT\n * re-running them (the Rails `schema:load` / Flyway `baseline` idea). That keeps the\n * ledger honest when a database's schema was advanced out of band — e.g. by cloning\n * table structure between databases — so the migrator does not later re-run a\n * migration whose schema object already exists.\n */\nexport default class MigrationsLedger {\n  /**\n   * The ledger table name.\n   * @returns {string} - Ledger table name.\n   */\n  static tableName() {\n    return TABLE_NAME\n  }\n\n  /**\n   * Whether the ledger table exists on the given database.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose migration ledger is inspected.\n   * @returns {Promise<boolean>} - Whether the ledger table exists.\n   */\n  static async tableExists(db) {\n    const table = await db.getTableByName(TABLE_NAME, {throwError: false})\n\n    return Boolean(table)\n  }\n\n  /**\n   * Creates the ledger table if it does not exist. This is the single definition of\n   * the `schema_migrations` table shape.\n   * @param {import(\"./drivers/base.js\").default} db - Database that should contain the ledger table.\n   * @returns {Promise<void>}\n   */\n  static async ensureTable(db) {\n    if (await MigrationsLedger.tableExists(db)) return\n\n    const tableData = new TableData(TABLE_NAME, {ifNotExists: true})\n\n    tableData.string(\"version\", {null: false, primaryKey: true})\n\n    for (const sql of await db.createTableSql(tableData)) {\n      await db.query(sql)\n    }\n\n    db.clearSchemaCache()\n  }\n\n  /**\n   * Every applied migration version recorded in the ledger.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose applied versions are loaded.\n   * @returns {Promise<string[]>} - Applied migration versions.\n   */\n  static async appliedVersions(db) {\n    const rows = await db.select(TABLE_NAME)\n\n    return rows.map((row) => `${digg(row, \"version\")}`)\n  }\n\n  /**\n   * Whether the given version is recorded as applied.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger is queried.\n   * @param {string} version - Migration version to look up.\n   * @returns {Promise<boolean>} - Whether the migration version is applied.\n   */\n  static async hasVersion(db, version) {\n    const rows = await db.newQuery()\n      .from(TABLE_NAME)\n      .where({version})\n      .results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Records a single version as applied. The targeted existence check keeps the\n   * migrator's per-migration hot path cheap (no full-table load per migration).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger receives the version.\n   * @param {string} version - Migration version to record as applied.\n   * @returns {Promise<void>}\n   */\n  static async recordVersion(db, version) {\n    if (await MigrationsLedger.hasVersion(db, version)) return\n\n    await db.insert({tableName: TABLE_NAME, data: {version}})\n  }\n\n  /**\n   * Removes a version from the ledger (used when migrating down).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger loses the version.\n   * @param {string} version - Migration version to mark as unapplied.\n   * @returns {Promise<void>}\n   */\n  static async removeVersion(db, version) {\n    await db.delete({tableName: TABLE_NAME, conditions: {version}})\n  }\n\n  /**\n   * Baselines a database's ledger: records each version as applied without running\n   * its migration. Idempotent — already-recorded versions are skipped. Ensures the\n   * ledger table exists first, then loads the existing set once for the whole batch.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger should be baselined.\n   * @param {string[]} versions - Migration versions to record without running them.\n   * @returns {Promise<string[]>} The versions that were newly recorded.\n   */\n  static async markApplied(db, versions) {\n    await MigrationsLedger.ensureTable(db)\n\n    const existing = new Set(await MigrationsLedger.appliedVersions(db))\n    const recorded = []\n\n    for (const version of versions) {\n      const normalizedVersion = `${version}`\n\n      if (existing.has(normalizedVersion)) continue\n\n      await db.insert({tableName: TABLE_NAME, data: {version: normalizedVersion}})\n      existing.add(normalizedVersion)\n      recorded.push(normalizedVersion)\n    }\n\n    return recorded\n  }\n\n  /**\n   * Baselines `targetDb` to match the applied versions of `sourceDb`. Use when a\n   * provisioning path advanced `targetDb`'s schema to match `sourceDb` out of band\n   * (e.g. cloning table structure between databases): the migrations are, by\n   * construction, already applied on the target, so record them without re-running.\n   * @param {{sourceDb: import(\"./drivers/base.js\").default, targetDb: import(\"./drivers/base.js\").default}} args - Source ledger and target database to baseline.\n   * @returns {Promise<string[]>} The versions that were newly recorded on the target.\n   */\n  static async baselineFromDatabase({sourceDb, targetDb}) {\n    const sourceVersions = await MigrationsLedger.appliedVersions(sourceDb)\n\n    return await MigrationsLedger.markApplied(targetDb, sourceVersions)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrations-ledger.js","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport TableData from \"./table-data/index.js\"\n\nconst TABLE_NAME = \"schema_migrations\"\n/** SQL Server \"There is already an object named ...\" — raised when two sessions race to create the same table. */\nconst MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER = 2714\n/** SQL Server deadlock victim — raised when concurrent sessions deadlock on the same catalog reads. */\nconst MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER = 1205\n\n\n/**\n * Single owner of the `schema_migrations` ledger shape and the only place that reads\n * or writes applied migration versions for a database connection. The migrator uses\n * it to record versions as it runs migrations; provisioning / schema-clone paths use\n * `markApplied` / `baselineFromDatabase` to record versions as applied WITHOUT\n * re-running them (the Rails `schema:load` / Flyway `baseline` idea). That keeps the\n * ledger honest when a database's schema was advanced out of band — e.g. by cloning\n * table structure between databases — so the migrator does not later re-run a\n * migration whose schema object already exists.\n */\nexport default class MigrationsLedger {\n  /**\n   * The ledger table name.\n   * @returns {string} - Ledger table name.\n   */\n  static tableName() {\n    return TABLE_NAME\n  }\n\n  /**\n   * Whether the ledger table exists on the given database.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose migration ledger is inspected.\n   * @returns {Promise<boolean>} - Whether the ledger table exists.\n   */\n  static async tableExists(db) {\n    const table = await db.getTableByName(TABLE_NAME, {throwError: false})\n\n    return Boolean(table)\n  }\n\n  /**\n   * Whether the error means a concurrent session already created the ledger table.\n   *\n   * Several processes bootstrap the same database at the same time (for example every\n   * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard\n   * is NOT atomic: two sessions can both evaluate the check as false and then both\n   * create, so the loser is rejected. Walks the wrapped-error cause chain because\n   * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the\n   * stable numeric error number instead of the localized message text.\n   * @param {unknown} error - Error thrown while creating the ledger table.\n   * @returns {boolean} - True if the table was created by a concurrent session.\n   */\n  static isConcurrentCreationError(error) {\n    let current = error\n\n    while (current instanceof Error) {\n      const errorNumber = /** @type {{number?: unknown}} */ (current).number\n\n      if (typeof errorNumber === \"number\" && errorNumber === MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER) return true\n\n      current = current.cause\n    }\n\n    return false\n  }\n\n  /**\n   * Whether the error is a transient deadlock that should be retried.\n   *\n   * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that\n   * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,\n   * so retrying it is safe. Matched by numeric error number, never by message text.\n   * @param {unknown} error - Error thrown while inspecting or creating the ledger table.\n   * @returns {boolean} - True if the error is a retryable deadlock.\n   */\n  static isDeadlockError(error) {\n    let current = error\n\n    while (current instanceof Error) {\n      const errorNumber = /** @type {{number?: unknown}} */ (current).number\n\n      if (typeof errorNumber === \"number\" && errorNumber === MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER) return true\n\n      current = current.cause\n    }\n\n    return false\n  }\n\n  /**\n   * Creates the ledger table if it does not exist. This is the single definition of\n   * the `schema_migrations` table shape.\n   *\n   * Safe under concurrency: a session that loses the create race (or deadlocks on the\n   * catalog read) converges on the existing table instead of failing its caller. That\n   * matters because this runs on every boot of a database configured for migrations\n   * (see `Migrator#createMigrationsTableForDatabase` and\n   * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard\n   * or deployment over a table that provably already exists.\n   * @param {import(\"./drivers/base.js\").default} db - Database that should contain the ledger table.\n   * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.\n   * @returns {Promise<void>}\n   */\n  static async ensureTable(db, {maxAttempts = 3} = {}) {\n    let attempt = 0\n\n    while (true) {\n      attempt++\n\n      try {\n        if (await MigrationsLedger.tableExists(db)) return\n\n        const tableData = new TableData(TABLE_NAME, {ifNotExists: true})\n\n        tableData.string(\"version\", {null: false, primaryKey: true})\n\n        for (const sql of await db.createTableSql(tableData)) {\n          await db.query(sql)\n        }\n\n        db.clearSchemaCache()\n\n        return\n      } catch (error) {\n        if (MigrationsLedger.isConcurrentCreationError(error)) {\n          // Another session created the ledger between our check and our create. The\n          // table exists with exactly this shape, so the goal state is already reached.\n          db.clearSchemaCache()\n\n          return\n        }\n\n        if (MigrationsLedger.isDeadlockError(error) && attempt < maxAttempts) {\n          db.clearSchemaCache()\n\n          continue\n        }\n\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Every applied migration version recorded in the ledger.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose applied versions are loaded.\n   * @returns {Promise<string[]>} - Applied migration versions.\n   */\n  static async appliedVersions(db) {\n    const rows = await db.select(TABLE_NAME)\n\n    return rows.map((row) => `${digg(row, \"version\")}`)\n  }\n\n  /**\n   * Whether the given version is recorded as applied.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger is queried.\n   * @param {string} version - Migration version to look up.\n   * @returns {Promise<boolean>} - Whether the migration version is applied.\n   */\n  static async hasVersion(db, version) {\n    const rows = await db.newQuery()\n      .from(TABLE_NAME)\n      .where({version})\n      .results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Records a single version as applied. The targeted existence check keeps the\n   * migrator's per-migration hot path cheap (no full-table load per migration).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger receives the version.\n   * @param {string} version - Migration version to record as applied.\n   * @returns {Promise<void>}\n   */\n  static async recordVersion(db, version) {\n    if (await MigrationsLedger.hasVersion(db, version)) return\n\n    await db.insert({tableName: TABLE_NAME, data: {version}})\n  }\n\n  /**\n   * Removes a version from the ledger (used when migrating down).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger loses the version.\n   * @param {string} version - Migration version to mark as unapplied.\n   * @returns {Promise<void>}\n   */\n  static async removeVersion(db, version) {\n    await db.delete({tableName: TABLE_NAME, conditions: {version}})\n  }\n\n  /**\n   * Baselines a database's ledger: records each version as applied without running\n   * its migration. Idempotent — already-recorded versions are skipped. Ensures the\n   * ledger table exists first, then loads the existing set once for the whole batch.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger should be baselined.\n   * @param {string[]} versions - Migration versions to record without running them.\n   * @returns {Promise<string[]>} The versions that were newly recorded.\n   */\n  static async markApplied(db, versions) {\n    await MigrationsLedger.ensureTable(db)\n\n    const existing = new Set(await MigrationsLedger.appliedVersions(db))\n    const recorded = []\n\n    for (const version of versions) {\n      const normalizedVersion = `${version}`\n\n      if (existing.has(normalizedVersion)) continue\n\n      await db.insert({tableName: TABLE_NAME, data: {version: normalizedVersion}})\n      existing.add(normalizedVersion)\n      recorded.push(normalizedVersion)\n    }\n\n    return recorded\n  }\n\n  /**\n   * Baselines `targetDb` to match the applied versions of `sourceDb`. Use when a\n   * provisioning path advanced `targetDb`'s schema to match `sourceDb` out of band\n   * (e.g. cloning table structure between databases): the migrations are, by\n   * construction, already applied on the target, so record them without re-running.\n   * @param {{sourceDb: import(\"./drivers/base.js\").default, targetDb: import(\"./drivers/base.js\").default}} args - Source ledger and target database to baseline.\n   * @returns {Promise<string[]>} The versions that were newly recorded on the target.\n   */\n  static async baselineFromDatabase({sourceDb, targetDb}) {\n    const sourceVersions = await MigrationsLedger.appliedVersions(sourceDb)\n\n    return await MigrationsLedger.markApplied(targetDb, sourceVersions)\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.695",
+  "version": "1.0.697",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/background-jobs/adapter.js

@@ -148,7 +148,7 @@ export default class BackgroundJobsAdapter {
    * Records pooled-child acceptance evidence (received/started timestamps plus
    * runner identity) for a handed-off job, fenced by its active handoff lease.
    * Only the fields supplied are written.
-   * @param {{jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number}} _args - Acceptance report.
+   * @param {{jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number, runnerHostname?: string}} _args - Acceptance report.
    * @returns {Promise<boolean>} - Whether the fenced report was accepted.
    */
   async markChildAccepted(_args) { throw new Error("BackgroundJobsAdapter#markChildAccepted is not implemented") }

package/src/background-jobs/client.js

@@ -26,7 +26,7 @@ const BACKGROUND_JOB_NULLABLE_NUMBER_FIELDS = [
   "scheduledAtMs",
   "timeoutMs"
 ]
-const BACKGROUND_JOB_NULLABLE_STRING_FIELDS = ["childInstanceId", "concurrencyKey", "handoffId", "lastError", "scheduleKey", "workerId"]
+const BACKGROUND_JOB_NULLABLE_STRING_FIELDS = ["childInstanceId", "concurrencyKey", "handoffId", "lastError", "runnerHostname", "scheduleKey", "workerId"]
 
 /**
  * Checks a required nullable number from a normalized wire row.

package/src/background-jobs/job-record.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import DatabaseRecord from "../database/record/index.js"
+import { evaluateBackgroundJobOwnerLiveness } from "./owner-liveness.js"
 
 export default class BackgroundJobRecord extends DatabaseRecord {
   static tableName() {
@@ -10,4 +11,26 @@ export default class BackgroundJobRecord extends DatabaseRecord {
   static primaryKey() {
     return "id"
   }
+
+  /**
+   * Evaluates whether the process that accepted this job is still alive.
+   *
+   * Local ownership is answered from the recorded runner hostname and OS pid.
+   * Jobs accepted on another host, or jobs recorded before runner hostnames
+   * existed, answer `unknown`: remote liveness needs a heartbeat or instance
+   * registry, which this helper deliberately does not invent.
+   * @param {object} [args] - Options.
+   * @param {string} [args.hostname] - Hostname to compare against, defaults to this process's hostname.
+   * @param {(pid: number) => boolean} [args.probe] - Process probe, injectable for tests.
+   * @returns {import("./owner-liveness.js").BackgroundJobOwnerLivenessResult} - Liveness verdict.
+   */
+  ownerIsAlive({hostname, probe} = {}) {
+    return evaluateBackgroundJobOwnerLiveness({
+      childInstanceId: /** @type {string | null} */ (this.readAttribute("childInstanceId")),
+      childPid: /** @type {number | null} */ (this.readAttribute("childPid")),
+      currentHostname: hostname,
+      probe,
+      runnerHostname: /** @type {string | null} */ (this.readAttribute("runnerHostname"))
+    })
+  }
 }

package/src/background-jobs/local-adapter.js

@@ -163,7 +163,7 @@ export default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {
 
   /**
    * Records pooled-child acceptance evidence for a local handoff.
-   * @param {{jobId: string, handoffId?: string, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number}} args - Acceptance report.
+   * @param {{jobId: string, handoffId?: string, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number, runnerHostname?: string}} args - Acceptance report.
    * @returns {Promise<boolean>} - Whether accepted.
    */
   async markChildAccepted(args) { return await this.store.markChildAccepted(args) }

package/src/background-jobs/local-store.js

@@ -63,7 +63,8 @@ const EXPECTED_JOB_COLUMNS = [
   "child_received_at_ms",
   "child_started_at_ms",
   "child_instance_id",
-  "child_pid"
+  "child_pid",
+  "runner_hostname"
 ]
 const EXPECTED_CONCURRENCY_COLUMNS = ["concurrency_key", "max_concurrency", "active_count"]
 const EXPECTED_SCHEDULE_KEY_COLUMNS = ["schedule_key", "job_id"]
@@ -333,6 +334,7 @@ export default class LocalBackgroundJobsStore {
     table.bigint("child_started_at_ms", {null: true})
     table.string("child_instance_id", {null: true})
     table.integer("child_pid", {null: true})
+    table.string("runner_hostname", {null: true})
     table.addIndex(new TableIndex(["status", "scheduled_at_ms", "created_at_ms", "id"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[0]}))
     table.addIndex(new TableIndex(["queue", "status", "created_at_ms"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[1]}))
     table.addIndex(new TableIndex(["args_digest"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[2]}))
@@ -1098,9 +1100,10 @@ export default class LocalBackgroundJobsStore {
    * @param {number} [args.startedAtMs] - Epoch ms the job's perform started in the child.
    * @param {string} [args.childInstanceId] - Stable pooled child identity.
    * @param {number} [args.childPid] - Pooled child OS pid.
+   * @param {string} [args.runnerHostname] - Hostname of the machine running the pooled child.
    * @returns {Promise<boolean>} - Whether the lease won.
    */
-  async markChildAccepted({jobId, handoffId, receivedAtMs, startedAtMs, childInstanceId, childPid}) {
+  async markChildAccepted({jobId, handoffId, receivedAtMs, startedAtMs, childInstanceId, childPid, runnerHostname}) {
     await this.ensureReady()
 
     return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
@@ -1113,6 +1116,7 @@ export default class LocalBackgroundJobsStore {
       if (typeof startedAtMs === "number") data.child_started_at_ms = startedAtMs
       if (typeof childInstanceId === "string") data.child_instance_id = childInstanceId
       if (typeof childPid === "number") data.child_pid = childPid
+      if (typeof runnerHostname === "string") data.runner_hostname = runnerHostname
       if (Object.keys(data).length === 0) return false
 
       const affectedRows = await this._updateAffectedRows(db, {
@@ -1279,15 +1283,15 @@ export default class LocalBackgroundJobsStore {
    * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Cleared acceptance columns.
    */
   _clearedChildAcceptanceData() {
-    return {child_instance_id: null, child_pid: null, child_received_at_ms: null, child_started_at_ms: null}
+    return {child_instance_id: null, child_pid: null, child_received_at_ms: null, child_started_at_ms: null, runner_hostname: null}
   }
 
   /**
    * Returns the row-shape counterpart of the cleared acceptance columns.
-   * @returns {Pick<import("./types.js").BackgroundJobRow, "childInstanceId" | "childPid" | "childReceivedAtMs" | "childStartedAtMs">} - Cleared acceptance fields.
+   * @returns {Pick<import("./types.js").BackgroundJobRow, "childInstanceId" | "childPid" | "childReceivedAtMs" | "childStartedAtMs" | "runnerHostname">} - Cleared acceptance fields.
    */
   _clearedChildAcceptanceRow() {
-    return {childInstanceId: null, childPid: null, childReceivedAtMs: null, childStartedAtMs: null}
+    return {childInstanceId: null, childPid: null, childReceivedAtMs: null, childStartedAtMs: null, runnerHostname: null}
   }
 
   /**
@@ -1583,6 +1587,7 @@ export default class LocalBackgroundJobsStore {
       args: parsedArgs,
       attempts: this._numberOrNull(row.attempts),
       childInstanceId: row.child_instance_id === null || row.child_instance_id === undefined ? null : String(row.child_instance_id),
+      runnerHostname: row.runner_hostname === null || row.runner_hostname === undefined ? null : String(row.runner_hostname),
       childPid: this._numberOrNull(row.child_pid),
       childReceivedAtMs: this._numberOrNull(row.child_received_at_ms),
       childStartedAtMs: this._numberOrNull(row.child_started_at_ms),

package/src/background-jobs/main.js

@@ -1272,6 +1272,7 @@ export default class BackgroundJobsMain {
         handoffId: message.handoffId,
         jobId: message.jobId,
         receivedAtMs: message.receivedAtMs,
+        runnerHostname: message.runnerHostname,
         startedAtMs: message.startedAtMs,
         workerId: message.workerId
       })
@@ -1862,14 +1863,18 @@ export default class BackgroundJobsMain {
     const payload = {
       context: {
         attempts: job.attempts,
+        childInstanceId: job.childInstanceId,
+        childPid: job.childPid,
         jobArgs: job.args,
         jobId: job.id,
         jobName: job.jobName,
         maxRetries: job.maxRetries,
+        runnerHostname: job.runnerHostname,
         stage: "background-job-orphaned",
         status: job.status,
         terminal: job.status === "failed" || job.status === "orphaned",
-        willRetry: job.status === "queued"
+        willRetry: job.status === "queued",
+        workerId: job.workerId
       },
       error: normalizedError
     }

package/src/background-jobs/owner-liveness.js

@@ -0,0 +1,92 @@
+// @ts-check
+
+import os from "node:os"
+
+/**
+ * Liveness verdict for the process recorded on a background job.
+ * @typedef {"alive" | "dead" | "unknown"} BackgroundJobOwnerLivenessStatus
+ */
+
+/**
+ * Verdict describing whether the process that accepted a background job can
+ * still be running.
+ * @typedef {object} BackgroundJobOwnerLivenessResult
+ * @property {string | null} childInstanceId - Recorded pooled-child identity, when available.
+ * @property {number | null} childPid - Recorded OS pid, when available.
+ * @property {string} reason - Machine-readable reason for the verdict.
+ * @property {string | null} runnerHostname - Recorded runner hostname, when available.
+ * @property {BackgroundJobOwnerLivenessStatus} status - Liveness verdict.
+ */
+
+/**
+ * Probes a local pid without signalling the target process. `EPERM` means the
+ * process exists but belongs to another user, so it counts as alive; `ESRCH`
+ * means it is gone. Any other error is unexpected and is rethrown rather than
+ * silently reported as "dead".
+ * @param {number} pid - Process id to probe.
+ * @returns {boolean} - Whether a process with that pid exists.
+ */
+export function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false
+
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    const code = /** @type {{code?: string}} */ (error).code
+
+    if (code === "EPERM") return true
+    if (code === "ESRCH") return false
+
+    throw error
+  }
+}
+
+/**
+ * Evaluates whether the process recorded on a background job is still alive.
+ *
+ * Only the local host can be answered from a PID: when the job was accepted on
+ * another machine the result is `unknown`, because liveness there needs a
+ * heartbeat or instance registry rather than a local probe. A pid alone can be
+ * recycled by the OS after a process exits, so treat `alive` as "a process with
+ * that pid exists now", not proof that it is the same process; pair it with
+ * `childStartedAtMs` when that distinction matters.
+ * @param {object} [args] - Options.
+ * @param {string | null} [args.childInstanceId] - Recorded pooled-child identity.
+ * @param {number | null} [args.childPid] - Recorded OS pid.
+ * @param {string} [args.currentHostname] - Hostname of this process, defaults to `os.hostname()`.
+ * @param {(pid: number) => boolean} [args.probe] - Process probe, injectable for tests.
+ * @param {string | null} [args.runnerHostname] - Hostname recorded with the job.
+ * @returns {BackgroundJobOwnerLivenessResult} - Liveness verdict with its reason.
+ */
+export function evaluateBackgroundJobOwnerLiveness({
+  childInstanceId = null,
+  childPid = null,
+  currentHostname = os.hostname(),
+  probe = isProcessAlive,
+  runnerHostname = null
+} = {}) {
+  const owner = {
+    childInstanceId: typeof childInstanceId === "string" ? childInstanceId : null,
+    childPid: typeof childPid === "number" ? childPid : null,
+    runnerHostname: typeof runnerHostname === "string" ? runnerHostname : null
+  }
+
+  if (!owner.runnerHostname) {
+    return {...owner, reason: "runner_hostname_unrecorded", status: "unknown"}
+  }
+
+  if (owner.runnerHostname !== currentHostname) {
+    return {...owner, reason: "remote_runner_host", status: "unknown"}
+  }
+
+  if (!Number.isInteger(owner.childPid) || owner.childPid === null || owner.childPid <= 0) {
+    return {...owner, reason: "child_pid_unrecorded", status: "unknown"}
+  }
+
+  const probedPid = /** @type {number} */ (owner.childPid)
+
+  return probe(probedPid)
+    ? {...owner, reason: "local_pid_alive", status: "alive"}
+    : {...owner, reason: "local_pid_missing", status: "dead"}
+}

package/src/background-jobs/pooled-runner-child.js

@@ -2,6 +2,7 @@
 
 import { randomUUID } from "node:crypto"
 import { readFileSync } from "node:fs"
+import os from "node:os"
 import v8 from "node:v8"
 import timeout from "awaitery/build/timeout.js"
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js"
@@ -16,6 +17,8 @@ const BASE_PROCESS_TITLE = "velocious background-jobs-runner"
 const SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS = 100
 /** Stable identity of this pooled child process for the life of the process. */
 const childInstanceId = randomUUID()
+/** Hostname (the container id under Docker) of the machine running this pooled child. */
+const runnerHostname = os.hostname()
 /** Sampling cadence for the memory observation sampler. */
 const MEMORY_OBSERVATION_INTERVAL_MS = 10000
 /** Bound on in-flight job ids carried in a memory observation. */
@@ -167,6 +170,7 @@ function sendChildAcceptance(type, payload, observedAtMs) {
     handedOffAtMs: payload.handedOffAtMs,
     handoffId: payload.handoffId,
     jobId: payload.id,
+    runnerHostname,
     type,
     workerId: payload.workerId,
     ...(type === "job-received" ? {receivedAtMs: observedAtMs} : {startedAtMs: observedAtMs})
@@ -399,4 +403,4 @@ process.on("message", (message) => handleMessage(message))
 process.once("disconnect", () => void shutdownRunner({exitCode: 0, reason: "ipc_disconnect"}))
 process.once("SIGTERM", () => void shutdownRunner({exitCode: 1, reason: "signal_sigterm", signal: "SIGTERM"}))
 process.once("SIGINT", () => void shutdownRunner({exitCode: 1, reason: "signal_sigint", signal: "SIGINT"}))
-if (process.send) process.send({childInstanceId, childPid: process.pid, type: "ready"})
+if (process.send) process.send({childInstanceId, childPid: process.pid, runnerHostname, type: "ready"})

package/src/background-jobs/status-reporter.js

@@ -103,9 +103,10 @@ export default class BackgroundJobsStatusReporter {
    * @param {number} [args.startedAtMs] - Epoch ms the job's perform started in the child.
    * @param {string} [args.childInstanceId] - Stable pooled child identity.
    * @param {number} [args.childPid] - Pooled child OS pid.
+   * @param {string} [args.runnerHostname] - Hostname of the machine running the pooled child.
    * @returns {Promise<void>} - Resolves when reported.
    */
-  async reportChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid}) {
+  async reportChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid, runnerHostname}) {
     const config = this.configuration.getBackgroundJobsConfig()
     const host = this.host || config.host
     const port = typeof this.port === "number" ? this.port : config.port
@@ -131,7 +132,8 @@ export default class BackgroundJobsStatusReporter {
             receivedAtMs,
             startedAtMs,
             childInstanceId,
-            childPid
+            childPid,
+            runnerHostname
           })
         },
         onMessage: ({message, resolve, reject}) => {
@@ -161,16 +163,17 @@ export default class BackgroundJobsStatusReporter {
    * @param {number} [args.startedAtMs] - Epoch ms the job's perform started in the child.
    * @param {string} [args.childInstanceId] - Stable pooled child identity.
    * @param {number} [args.childPid] - Pooled child OS pid.
+   * @param {string} [args.runnerHostname] - Hostname of the machine running the pooled child.
    * @param {number} args.maxDurationMs - Max duration for retries.
    * @returns {Promise<void>} - Resolves when reported or the budget elapses.
    */
-  async reportChildAcceptedWithRetry({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid, maxDurationMs}) {
+  async reportChildAcceptedWithRetry({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid, runnerHostname, maxDurationMs}) {
     let attempt = 0
     const startTime = Date.now()
 
     while (true) {
       try {
-        await this.reportChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid})
+        await this.reportChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid, runnerHostname})
         return
       } catch (error) {
         attempt += 1

package/src/background-jobs/store.js

@@ -1437,9 +1437,10 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
    * @param {number} [args.startedAtMs] - Epoch ms the job's perform started in the child.
    * @param {string} [args.childInstanceId] - Stable pooled child identity.
    * @param {number} [args.childPid] - Pooled child OS pid.
+   * @param {string} [args.runnerHostname] - Hostname of the machine running the pooled child.
    * @returns {Promise<boolean>} - Whether the fenced report was accepted.
    */
-  async markChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid}) {
+  async markChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid, runnerHostname}) {
     await this.ensureReady()
 
     return await this._serializedConnectionMutation(async (db) => {
@@ -1453,6 +1454,7 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
       if (typeof startedAtMs === "number") data.child_started_at_ms = startedAtMs
       if (typeof childInstanceId === "string") data.child_instance_id = childInstanceId
       if (typeof childPid === "number") data.child_pid = childPid
+      if (typeof runnerHostname === "string") data.runner_hostname = runnerHostname
       if (Object.keys(data).length === 0) return false
 
       const affectedRows = await this._updateAffectedRows(db, {
@@ -1470,15 +1472,15 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
    * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Cleared acceptance columns.
    */
   _clearedChildAcceptanceData() {
-    return {child_instance_id: null, child_pid: null, child_received_at_ms: null, child_started_at_ms: null}
+    return {child_instance_id: null, child_pid: null, child_received_at_ms: null, child_started_at_ms: null, runner_hostname: null}
   }
 
   /**
    * Returns the row-shape counterpart of the cleared acceptance columns.
-   * @returns {Pick<import("./types.js").BackgroundJobRow, "childInstanceId" | "childPid" | "childReceivedAtMs" | "childStartedAtMs">} - Cleared acceptance fields.
+   * @returns {Pick<import("./types.js").BackgroundJobRow, "childInstanceId" | "childPid" | "childReceivedAtMs" | "childStartedAtMs" | "runnerHostname">} - Cleared acceptance fields.
    */
   _clearedChildAcceptanceRow() {
-    return {childInstanceId: null, childPid: null, childReceivedAtMs: null, childStartedAtMs: null}
+    return {childInstanceId: null, childPid: null, childReceivedAtMs: null, childStartedAtMs: null, runnerHostname: null}
   }
 
   /**
@@ -2275,6 +2277,7 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
     table.bigint("child_started_at_ms", {null: true})
     table.string("child_instance_id", {null: true})
     table.integer("child_pid", {null: true})
+    table.string("runner_hostname", {null: true})
 
     await db.createTable(table)
   }
@@ -2411,6 +2414,10 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
         tableData.integer("child_pid", {null: true})
         added = true
       }
+      if (!(await table.getColumnByName("runner_hostname"))) {
+        tableData.string("runner_hostname", {null: true})
+        added = true
+      }
 
       if (added) {
         for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)
@@ -3219,7 +3226,8 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
       childReceivedAtMs: this._normalizeNumber(row.child_received_at_ms),
       childStartedAtMs: this._normalizeNumber(row.child_started_at_ms),
       childInstanceId: row.child_instance_id ? String(row.child_instance_id) : null,
-      childPid: this._normalizeNumber(row.child_pid)
+      childPid: this._normalizeNumber(row.child_pid),
+      runnerHostname: row.runner_hostname ? String(row.runner_hostname) : null
     }
   }