velocious 1.0.532 → 1.0.534

package/README.md

@@ -1102,6 +1102,8 @@ export default class CreateEvents extends Migration {
 }
 ```
 
+Migrations that must be rerunnable can guard changes with `tableExists(...)`, `columnExists(table, column)` and `indexExists(table, index)` — a missing table yields `false` rather than throwing. See [docs/database-migrations.md](docs/database-migrations.md#guarding-schema-changes-in-rerunnable-migrations).
+
 ## Run migrations from the command line
 
 ```bash
@@ -2007,9 +2009,9 @@ VELOCIOUS_BACKGROUND_JOBS_JOB_TIMEOUT_MS=5400000
 
 `VELOCIOUS_BACKGROUND_JOBS_WORKER_SHUTDOWN_TIMEOUT_MS` (default: `indefinite`) bounds how long a `background-jobs-worker` waits for in-flight jobs on `SIGTERM`/`SIGINT` before terminating any forked or spawned child runners still running, so they are not orphaned across a deploy. The default waits for jobs to finish and never interrupts a running job; set a positive number of milliseconds for a finite cap (keep it shorter than your process supervisor's graceful-stop window so the worker reaps its own runners first). See [docs/background-jobs.md](docs/background-jobs.md#worker-shutdown-and-process-job-draining).
 
-`maxConcurrentInlineJobs` (default: `4`) caps how many `executionMode: "inline"` jobs a single `background-jobs-worker` process runs in parallel. Concurrency is at the JS event-loop level: every job in flight shares the worker's process and DB connection pool, so the cap should fit the pool, not the CPU count. Forking remains the right tool when you need memory isolation across long-running jobs or want to use more cores. The older `forked: false` option still maps to inline mode.
+`maxConcurrentInlineJobs` (default: `4`) caps how many `executionMode: "inline"` jobs a single `background-jobs-worker` process runs in parallel. Concurrency is at the JS event-loop level: every job in flight shares the worker's process and DB connection pool, so the cap should fit the pool, not the CPU count. Forking remains the right tool when you need memory isolation across long-running jobs or want to use more cores; select it with `executionMode: "forked"`.
 
-New jobs default to `executionMode: "pooled"`: a worker runs them in warm, reusable Node child runners. `pooledRunnerCount` (default: `4`) bounds this independent per-worker pool, and `pooledRunnerConcurrency` (default: `1`) sets how many jobs each child runs at once on its own event loop, so total pooled capacity is `pooledRunnerCount × pooledRunnerConcurrency` — raise concurrency for I/O-bound jobs to get high throughput from a bounded, isolated set of processes. `pooledRunnerCount`, `pooledRunnerConcurrency`, and `pooledRunnerMaxJobs` must be finite positive integers; the RSS and lifetime limits must be finite positive numbers. A child is recycled after an acknowledged job when it reaches `pooledRunnerMaxJobs` (default: `100`), `pooledRunnerMaxRssBytes` (default: `536870912`, or 512 MiB), or `pooledRunnerMaxLifetimeMs` (default: `3600000`, or one hour). Pooled rows remain readable by older mains during rolling upgrades and run there with legacy one-shot fork behavior. `forked: true` remains an explicit alias for `"forked"`; `forked: false` remains inline. See [execution modes and pooled runners](docs/background-jobs.md#execution-modes-and-pooled-runners).
+New jobs default to `executionMode: "pooled"`: a worker runs them in warm, reusable Node child runners. `pooledRunnerCount` (default: `4`) bounds this independent per-worker pool, and `pooledRunnerConcurrency` (default: `1`) sets how many jobs each child runs at once on its own event loop, so total pooled capacity is `pooledRunnerCount × pooledRunnerConcurrency` — raise concurrency for I/O-bound jobs to get high throughput from a bounded, isolated set of processes. `pooledRunnerCount`, `pooledRunnerConcurrency`, and `pooledRunnerMaxJobs` must be finite positive integers; the RSS and lifetime limits must be finite positive numbers. A child is recycled after an acknowledged job when it reaches `pooledRunnerMaxJobs` (default: `100`), `pooledRunnerMaxRssBytes` (default: `536870912`, or 512 MiB), or `pooledRunnerMaxLifetimeMs` (default: `3600000`, or one hour). `execution_mode` is the single source of truth for a job's runtime — pooled rows persist as `execution_mode = "pooled"` directly. See [execution modes and pooled runners](docs/background-jobs.md#execution-modes-and-pooled-runners).
 
 `maxConcurrentForkedJobs` (default: `4`) caps how many out-of-process `executionMode: "forked"` or `executionMode: "spawned"` jobs one worker may keep in flight. Forked jobs use `child_process.fork()` with an attached IPC channel. After the main process acknowledges their durable status report, forked and spawned one-shot runners exit without waiting for graceful Beacon/database teardown; the OS closes their process-owned resources. A missing or rejected status acknowledgement makes the runner exit as failed instead of reporting clean success. Spawned jobs use the legacy `background-jobs-runner` CLI process via `child_process.spawn()` and are only for callers that intentionally want that spawned behavior.
 
@@ -2075,7 +2077,7 @@ await MyJob.performLaterWithOptions({
 
 Until `scheduledAtMs` is reached, the job remains queued but is not eligible for dispatch. The event-driven dispatcher arms its timer for the earliest future job and wakes at that timestamp. Omitting `scheduledAtMs` keeps the immediate-enqueue behavior.
 
-The older `options: {forked: false}` form is still accepted as an alias for inline execution, and `options: {forked: true}` maps to forked execution. To use the previous spawned CLI runner behavior explicitly, pass `options: {executionMode: "spawned"}`.
+Select a non-default runtime explicitly with `options: {executionMode: "inline" | "forked" | "spawned"}`.
 
 Inline jobs share the worker process and run concurrently up to `maxConcurrentInlineJobs`, so a single slow inline job no longer blocks the queue. A single worker can also override the configured cap explicitly:
 

package/build/background-jobs/main.js

@@ -1142,8 +1142,7 @@ export default class BackgroundJobsMain {
             workerId: worker.workerId,
             handedOffAtMs: handoff.handedOffAtMs,
             options: {
-              executionMode: job.executionMode,
-              forked: job.forked
+              executionMode: job.executionMode
             }
           }
         })

package/build/background-jobs/store.js

@@ -11,6 +11,16 @@ const MIGRATIONS_TABLE = "velocious_internal_migrations"
 const MIGRATION_SCOPE = "background_jobs"
 const MIGRATION_VERSION = "20250215000000"
 const EXECUTION_MODE_BACKFILL_MIGRATION_VERSION = "20260607131010"
+// Drops the redundant legacy `forked` boolean column and rewrites pooled rows to
+// persist `execution_mode = "pooled"` directly (retiring the pooled-as-forked
+// handoff-marker workaround), leaving `execution_mode` as the single source of
+// truth for a job's runtime.
+const DROP_FORKED_COLUMN_MIGRATION_VERSION = "20260719000000"
+// Legacy marker prefix used by rows written before this migration: pooled jobs
+// used to persist as `execution_mode = "forked"` plus a `velocious-pooled:*`
+// handoff id. Retained only to detect and convert those rows in the migration.
+const LEGACY_POOLED_HANDOFF_ID_PREFIX = "velocious-pooled:"
+const LEGACY_POOLED_QUEUED_HANDOFF_ID = `${LEGACY_POOLED_HANDOFF_ID_PREFIX}queued`
 const JOBS_TABLE = "background_jobs"
 const CONCURRENCY_TABLE = "background_job_concurrency"
 const DEFAULT_MAX_RETRIES = 10
@@ -25,18 +35,6 @@ const EXECUTION_MODES = ["inline", "forked", "pooled", "spawned"]
  * process — the same isolation as forked without paying a fresh process per job.
  * @type {import("./types.js").BackgroundJobExecutionMode} */
 const DEFAULT_EXECUTION_MODE = "pooled"
-/**
- * Execution mode a legacy `forked = true` row (persisted before the
- * `execution_mode` column existed) backfills to. It must stay `"forked"` so an
- * upgrade never silently reinterprets already-persisted forked jobs as pooled —
- * distinct from {@link DEFAULT_EXECUTION_MODE}, which only governs new enqueues.
- * @type {import("./types.js").BackgroundJobExecutionMode} */
-const LEGACY_FORKED_EXECUTION_MODE = "forked"
-// Pooled jobs persist with the legacy-safe `forked` mode so a pre-pool main can
-// deserialize and run them during a rolling upgrade. Old versions ignore the
-// nullable handoff id on queued rows, making it a backward-compatible marker.
-const POOLED_HANDOFF_ID_PREFIX = "velocious-pooled:"
-const POOLED_QUEUED_HANDOFF_ID = `${POOLED_HANDOFF_ID_PREFIX}queued`
 const DEFAULT_QUEUE = "default"
 // Queue-derived durable concurrency keys are namespaced so they can't collide
 // with explicit caller-supplied concurrencyKeys.
@@ -102,6 +100,27 @@ export default class BackgroundJobsStore {
     }
   }
 
+  /**
+   * Ensures the background-jobs schema (tables + columns) exists on the configured
+   * database, without initializing the runtime model. Lets `db:migrate` create the
+   * framework's own schema deterministically alongside app migrations — and capture
+   * it in the dumped structure SQL — instead of it only appearing once a store boots.
+   * Idempotent: reuses the same `_ensureSchema` the runtime store uses, which skips
+   * work already applied (tracked in `velocious_internal_migrations`).
+   * @param {import("../database/drivers/base.js").default} [db] - Reuse an already
+   *   checked-out connection (e.g. the one `db:migrate` holds) rather than opening a
+   *   nested checkout that would deadlock a single-connection pool.
+   * @returns {Promise<void>} - Resolves when the schema is present.
+   */
+  async ensureSchema(db) {
+    // When a connection is handed in (the db:migrate path), the caller already owns
+    // the active configuration + connection context; calling setCurrent() here would
+    // clobber it (e.g. the browser test runner juggles multiple configurations).
+    if (!db) this.configuration.setCurrent()
+
+    await this._ensureSchema(db)
+  }
+
   /**
    * Runs enqueue.
    * @param {object} args - Options.
@@ -154,8 +173,7 @@ export default class BackgroundJobsStore {
           id: jobId,
           job_name: jobName,
           args_json: argsJson,
-          forked: executionMode !== "inline",
-          execution_mode: executionMode === "pooled" ? LEGACY_FORKED_EXECUTION_MODE : executionMode,
+          execution_mode: executionMode,
           queue,
           max_retries: maxRetries,
           attempts: 0,
@@ -164,7 +182,7 @@ export default class BackgroundJobsStore {
           created_at_ms: now,
           concurrency_key: concurrency?.concurrencyKey || null,
           max_concurrency: concurrency?.maxConcurrency || null,
-          handoff_id: executionMode === "pooled" ? POOLED_QUEUED_HANDOFF_ID : null
+          handoff_id: null
         }
       })
     })
@@ -175,7 +193,6 @@ export default class BackgroundJobsStore {
   /**
    * Runs next available job.
    * @param {object} [args] - Options.
-   * @param {boolean} [args.forked] - Compatibility filter for non-inline vs inline jobs.
    * @param {import("./types.js").BackgroundJobExecutionMode | import("./types.js").BackgroundJobExecutionMode[]} [args.executionMode] - Execution mode or modes to match.
    * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Next job.
    */
@@ -186,7 +203,6 @@ export default class BackgroundJobsStore {
       return await this._nextQueuedJob({
         db,
         scheduledAtOperator: "<=",
-        forked: args.forked,
         executionMode: args.executionMode
       })
     })
@@ -213,11 +229,10 @@ export default class BackgroundJobsStore {
    * @param {object} args - Options.
    * @param {import("../database/drivers/base.js").default} args.db - Database connection.
    * @param {"<=" | ">"} args.scheduledAtOperator - Scheduled timestamp operator.
-   * @param {boolean} [args.forked] - Compatibility filter for non-inline vs inline jobs.
    * @param {import("./types.js").BackgroundJobExecutionMode | import("./types.js").BackgroundJobExecutionMode[]} [args.executionMode] - Execution mode or modes to match.
    * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Next matching queued job.
    */
-  async _nextQueuedJob({db, scheduledAtOperator, forked, executionMode}) {
+  async _nextQueuedJob({db, scheduledAtOperator, executionMode}) {
     const now = Date.now()
     let query = db
       .newQuery()
@@ -236,9 +251,6 @@ export default class BackgroundJobsStore {
       )
     }
 
-    if (typeof forked === "boolean") {
-      query = query.where({forked})
-    }
     if (executionMode) query = this._whereExecutionMode({db, executionMode, query})
 
     if (scheduledAtOperator === "<=") {
@@ -420,9 +432,7 @@ export default class BackgroundJobsStore {
       const queuedJob = await this._getJobRowById(db, jobId)
       if (!queuedJob || queuedJob.status !== "queued") return null
       if (queuedJob.concurrencyKey && !(await this._reserveConcurrency(db, queuedJob.concurrencyKey))) return null
-      const handoffId = queuedJob.executionMode === "pooled"
-        ? `${POOLED_HANDOFF_ID_PREFIX}${randomUUID()}`
-        : randomUUID()
+      const handoffId = randomUUID()
 
       const affectedRows = await this._updateAffectedRows(db, {
         tableName: JOBS_TABLE,
@@ -496,7 +506,7 @@ export default class BackgroundJobsStore {
           status: "queued",
           scheduled_at_ms: Date.now(),
           handed_off_at_ms: null,
-          handoff_id: job.executionMode === "pooled" ? POOLED_QUEUED_HANDOFF_ID : null,
+          handoff_id: null,
           worker_id: null
         },
         conditions: {handoff_id: handoffId, id: jobId, status: "handed_off"}
@@ -757,35 +767,59 @@ export default class BackgroundJobsStore {
     throw VelociousError.safe("background job scheduledAtMs must be a non-negative safe integer")
   }
 
-  async _ensureSchema() {
-    await this._withDb(async (db) => {
-      await this._ensureMigrationsTable(db)
-
-      const alreadyApplied = await this._hasMigration(db)
-
-      // Even when the migration row is present, the jobs table itself can have
-      // been dropped underneath us by a transaction rollback in another caller
-      // (DDL is transactional on SQLite/MSSQL). Verify the table physically
-      // exists and recreate it when missing rather than trusting the migration
-      // row alone, otherwise later callers fail with "no such table".
-      if (alreadyApplied && await db.tableExists(JOBS_TABLE)) {
-        await this._ensureJobsTableColumns(db)
-        await this._ensureConcurrencyTable(db)
-        await this._reconcileQueueConcurrency(db)
-        await this._reconcileConcurrency(db)
-        return
-      }
+  /**
+   * Ensures the background-jobs schema exists, reusing a caller-held connection when
+   * one is given rather than checking out its own.
+   * @param {import("../database/drivers/base.js").default} [existingDb] - Reuse an
+   *   already-checked-out connection (e.g. the one `db:migrate` holds) instead of
+   *   checking out a nested one — the nested checkout would deadlock a database
+   *   whose pool is capped at a single connection already held by the caller.
+   * @returns {Promise<void>} - Resolves when the schema is present.
+   */
+  async _ensureSchema(existingDb) {
+    if (existingDb) {
+      await this._applySchema(existingDb)
 
-      await this._applyMigrations(db)
+      return
+    }
+
+    await this._withDb((db) => this._applySchema(db))
+  }
+
+  /**
+   * Creates or upgrades the background-jobs tables, columns and concurrency rows on
+   * the given connection.
+   * @param {import("../database/drivers/base.js").default} db - Database connection.
+   * @returns {Promise<void>} - Resolves when the schema is present.
+   */
+  async _applySchema(db) {
+    await this._ensureMigrationsTable(db)
+
+    const alreadyApplied = await this._hasMigration(db)
+
+    // Even when the migration row is present, the jobs table itself can have
+    // been dropped underneath us by a transaction rollback in another caller
+    // (DDL is transactional on SQLite/MSSQL). Verify the table physically
+    // exists and recreate it when missing rather than trusting the migration
+    // row alone, otherwise later callers fail with "no such table".
+    if (alreadyApplied && await db.tableExists(JOBS_TABLE)) {
       await this._ensureJobsTableColumns(db)
       await this._ensureConcurrencyTable(db)
       await this._reconcileQueueConcurrency(db)
       await this._reconcileConcurrency(db)
 
-      if (alreadyApplied) return
+      return
+    }
 
-      await this._recordMigration(db, MIGRATION_VERSION)
-    })
+    await this._applyMigrations(db)
+    await this._ensureJobsTableColumns(db)
+    await this._ensureConcurrencyTable(db)
+    await this._reconcileQueueConcurrency(db)
+    await this._reconcileConcurrency(db)
+
+    if (alreadyApplied) return
+
+    await this._recordMigration(db, MIGRATION_VERSION)
   }
 
   /**
@@ -842,7 +876,6 @@ export default class BackgroundJobsStore {
     table.string("id", {primaryKey: true})
     table.string("job_name", {null: false, index: true})
     table.text("args_json", {null: false})
-    table.boolean("forked", {null: false})
     table.string("execution_mode", {null: false})
     table.string("queue", {null: true, index: true})
     table.integer("max_retries", {null: false})
@@ -916,6 +949,7 @@ export default class BackgroundJobsStore {
     }
 
     await this._backfillExecutionModesOnce(db)
+    await this._dropForkedColumnOnce(db)
 
     const lockName = `${MIGRATION_SCOPE}:concurrency_columns`
     const acquired = await db.acquireAdvisoryLock(lockName)
@@ -1001,12 +1035,20 @@ export default class BackgroundJobsStore {
     try {
       if (await this._hasMigration(db, migrationVersion)) return
 
+      // A table created after the `forked` column was dropped has nothing to
+      // backfill from; record the migration so it is not re-attempted.
+      db.clearSchemaCache()
+      if (!(await (await db.getTableByNameOrFail(JOBS_TABLE)).getColumnByName("forked"))) {
+        await this._recordMigration(db, migrationVersion)
+        return
+      }
+
       const tableNameSql = db.quoteTable(JOBS_TABLE)
       const forkedColumnSql = db.quoteColumn("forked")
       const executionModeColumnSql = db.quoteColumn("execution_mode")
 
       await db.query(
-        `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(LEGACY_FORKED_EXECUTION_MODE)} ` +
+        `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote("forked")} ` +
         `WHERE ${forkedColumnSql} = ${db.quote(true)} AND ${executionModeColumnSql} IS NULL`
       )
       await db.query(
@@ -1020,6 +1062,60 @@ export default class BackgroundJobsStore {
     }
   }
 
+  /**
+   * Rewrites pre-existing pooled rows (persisted as `execution_mode = "forked"`
+   * plus a `velocious-pooled:*` handoff marker) to `execution_mode = "pooled"`,
+   * clears the queued marker, then drops the now-redundant `forked` column so
+   * `execution_mode` is the single source of truth. Runs once, guarded by the
+   * migration ledger and a per-key advisory lock; a fresh table (created without
+   * the column) short-circuits.
+   * @param {import("../database/drivers/base.js").default} db - Database connection.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async _dropForkedColumnOnce(db) {
+    const migrationVersion = DROP_FORKED_COLUMN_MIGRATION_VERSION
+    const migrationKey = this._migrationKey(migrationVersion)
+
+    if (await this._hasMigration(db, migrationVersion)) return
+
+    await db.acquireAdvisoryLock(migrationKey)
+
+    try {
+      if (await this._hasMigration(db, migrationVersion)) return
+
+      db.clearSchemaCache()
+
+      if (await (await db.getTableByNameOrFail(JOBS_TABLE)).getColumnByName("forked")) {
+        const tableNameSql = db.quoteTable(JOBS_TABLE)
+        const executionModeColumnSql = db.quoteColumn("execution_mode")
+        const handoffIdColumnSql = db.quoteColumn("handoff_id")
+
+        // Pooled rows used to persist as execution_mode "forked" + a pooled handoff
+        // marker; recover their real mode before the marker is cleared.
+        await db.query(
+          `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote("pooled")} ` +
+          `WHERE ${executionModeColumnSql} = ${db.quote("forked")} ` +
+          `AND ${handoffIdColumnSql} LIKE ${db.quote(`${LEGACY_POOLED_HANDOFF_ID_PREFIX}%`)}`
+        )
+        // The queued-pooled marker was a sentinel, not a real lease; clear it.
+        await db.query(
+          `UPDATE ${tableNameSql} SET ${handoffIdColumnSql} = NULL ` +
+          `WHERE ${handoffIdColumnSql} = ${db.quote(LEGACY_POOLED_QUEUED_HANDOFF_ID)}`
+        )
+
+        const dropForked = new TableData(JOBS_TABLE)
+        dropForked.addColumn("forked", {dropColumn: true})
+        for (const sql of await db.alterTableSQLs(dropForked)) await db.query(sql)
+
+        db.clearSchemaCache()
+      }
+
+      await this._recordMigration(db, migrationVersion)
+    } finally {
+      await db.releaseAdvisoryLock(migrationKey)
+    }
+  }
+
   /**
    * Runs record migration.
    * @param {import("../database/drivers/base.js").default} db - Database connection.
@@ -1097,7 +1193,6 @@ export default class BackgroundJobsStore {
       scheduledAt,
       shouldRetry
     })
-    if (shouldRetry && job.executionMode === "pooled") update.handoff_id = POOLED_QUEUED_HANDOFF_ID
 
     const affectedRows = await this._updateAffectedRows(db, {
       tableName: JOBS_TABLE,
@@ -1206,18 +1301,17 @@ export default class BackgroundJobsStore {
    * @returns {import("./types.js").BackgroundJobRow} - Normalized job row.
    */
   _normalizeJobRow(row) {
-    const persistedExecutionMode = row.execution_mode ? String(row.execution_mode) : null
     const handoffId = row.handoff_id ? String(row.handoff_id) : null
-    const executionMode = persistedExecutionMode
-      ? this._normalizePersistedExecutionMode({executionMode: persistedExecutionMode, handoffId})
-      : this._normalizeExecutionMode({forked: this._normalizeBoolean(row.forked)})
+    // `execution_mode` is the single source of truth for a job's runtime and is
+    // written on every enqueue; the drop-forked migration backfills any pre-existing
+    // rows before the legacy `forked` column is removed.
+    const executionMode = row.execution_mode ? this._normalizeExecutionModeName(String(row.execution_mode)) : DEFAULT_EXECUTION_MODE
 
     return {
       id: String(row.id),
       jobName: String(row.job_name),
       args: this._parseArgs(row.args_json),
       executionMode,
-      forked: executionMode !== "inline",
       queue: row.queue ? String(row.queue) : DEFAULT_QUEUE,
       status: row.status ? String(row.status) : "queued",
       attempts: this._normalizeNumber(row.attempts),
@@ -1501,19 +1595,6 @@ export default class BackgroundJobsStore {
     return numeric
   }
 
-  /**
-   * Runs normalize boolean.
-   * @param {?} value - Input value.
-   * @returns {boolean} - Normalized boolean.
-   */
-  _normalizeBoolean(value) {
-    if (value === null || value === undefined) return false
-    if (typeof value === "boolean") return value
-    if (typeof value === "number") return value !== 0
-
-    return value === "true"
-  }
-
   /**
    * Runs normalize execution mode.
    * @param {import("./types.js").BackgroundJobOptions} [options] - Job options.
@@ -1525,11 +1606,14 @@ export default class BackgroundJobsStore {
     if (executionMode) {
       return this._normalizeExecutionModeName(executionMode)
     }
-    // The legacy `forked` flag stays authoritative when supplied: `false` is
-    // inline and `true` is forked (never the pooled default). Only an enqueue
-    // that names neither option falls through to the pooled default.
-    if (options?.forked === false) return "inline"
-    if (options?.forked === true) return LEGACY_FORKED_EXECUTION_MODE
+
+    // The `forked` option alias was removed. Reject it loudly instead of silently
+    // defaulting to pooled, which would turn an explicitly inline (`forked: false`)
+    // or one-shot forked (`forked: true`) job into a pooled child-runner job — a
+    // silent semantic change for any not-yet-migrated caller.
+    if (options && "forked" in options) {
+      throw new Error("The background job `forked` option was removed; pass `executionMode` (\"inline\", \"forked\", \"pooled\", or \"spawned\") instead")
+    }
 
     return DEFAULT_EXECUTION_MODE
   }
@@ -1548,20 +1632,8 @@ export default class BackgroundJobsStore {
   }
 
   /**
-   * Normalizes a legacy-safe persisted execution mode.
-   * @param {object} args - Options.
-   * @param {string} args.executionMode - Persisted legacy execution mode.
-   * @param {string | null} args.handoffId - Persisted handoff id or pooled marker.
-   * @returns {import("./types.js").BackgroundJobExecutionMode} - Runtime execution mode.
-   */
-  _normalizePersistedExecutionMode({executionMode, handoffId}) {
-    if (executionMode === LEGACY_FORKED_EXECUTION_MODE && handoffId?.startsWith(POOLED_HANDOFF_ID_PREFIX)) return "pooled"
-
-    return this._normalizeExecutionModeName(executionMode)
-  }
-
-  /**
-   * Filters persisted legacy-safe execution modes.
+   * Filters queued jobs by one or more execution modes against the
+   * `execution_mode` column (the single source of truth).
    * @param {object} args - Options.
    * @param {import("../database/drivers/base.js").default} args.db - Database connection.
    * @param {import("./types.js").BackgroundJobExecutionMode | import("./types.js").BackgroundJobExecutionMode[]} args.executionMode - Runtime modes.
@@ -1570,20 +1642,8 @@ export default class BackgroundJobsStore {
    */
   _whereExecutionMode({db, executionMode, query}) {
     const executionModes = Array.isArray(executionMode) ? executionMode : [executionMode]
-    /** @type {string[]} */
-    const conditions = []
     const executionModeColumn = db.quoteColumn("execution_mode")
-    const handoffIdColumn = db.quoteColumn("handoff_id")
-
-    for (const mode of executionModes) {
-      if (mode === "pooled") {
-        conditions.push(`(${executionModeColumn} = ${db.quote(LEGACY_FORKED_EXECUTION_MODE)} AND ${handoffIdColumn} = ${db.quote(POOLED_QUEUED_HANDOFF_ID)})`)
-      } else if (mode === LEGACY_FORKED_EXECUTION_MODE) {
-        conditions.push(`(${executionModeColumn} = ${db.quote(mode)} AND (${handoffIdColumn} IS NULL OR ${handoffIdColumn} <> ${db.quote(POOLED_QUEUED_HANDOFF_ID)}))`)
-      } else {
-        conditions.push(`${executionModeColumn} = ${db.quote(mode)}`)
-      }
-    }
+    const conditions = executionModes.map((mode) => `${executionModeColumn} = ${db.quote(mode)}`)
 
     return query.where(`(${conditions.join(" OR ")})`)
   }

package/build/background-jobs/types.js

@@ -10,8 +10,7 @@
  */
 /**
  * @typedef {object} BackgroundJobOptions
- * @property {BackgroundJobExecutionMode} [executionMode] - How the job should run. Defaults to `"pooled"` (a warm, reused local runner process). `"forked"` runs the job in a fresh `child_process.fork()` child, `"spawned"` in a detached CLI runner, and `"inline"` inside the worker process.
- * @property {boolean} [forked] - Compatibility alias: `false` maps to `"inline"` and `true` maps to `"forked"`. Omitting both `forked` and `executionMode` uses the default `"pooled"` mode.
+ * @property {BackgroundJobExecutionMode} [executionMode] - How the job should run. Defaults to `"pooled"` (a warm, reused local runner process). `"forked"` runs the job in a fresh `child_process.fork()` child, `"spawned"` in a detached CLI runner, and `"inline"` inside the worker process. Omit to use the default `"pooled"` mode.
  * @property {number} [maxRetries] - Max retries for a failed job before it is marked failed.
  * @property {string} [queue] - Queue name. Defaults to `"default"`. When the queue has a configured cap in `backgroundJobs.queues`, that cap is enforced cluster-wide.
  * @property {string} [concurrencyKey] - Opaque non-empty key used to share a concurrency cap. Overrides any queue-derived cap.
@@ -35,7 +34,6 @@
  * @property {string} jobName - Job class name.
  * @property {Array<?>} args - Serialized job arguments.
  * @property {BackgroundJobExecutionMode} executionMode - How the job should run.
- * @property {boolean} forked - Compatibility flag; true for non-inline execution.
  * @property {string} queue - Queue name (defaults to `"default"`).
  * @property {string} status - Current job status.
  * @property {number | null} attempts - Failure attempts count.

package/build/background-jobs/web/controller.js

@@ -196,7 +196,6 @@ export default class VelociousBackgroundJobsWebController extends Controller {
       createdAtMs: job.createdAtMs,
       executionMode: job.executionMode,
       failedAtMs: job.failedAtMs,
-      forked: job.forked,
       handedOffAtMs: job.handedOffAtMs,
       id: job.id,
       jobName: job.jobName,

package/build/background-jobs/worker.js

@@ -480,14 +480,9 @@ export default class BackgroundJobsWorker {
    * @returns {import("./types.js").BackgroundJobExecutionMode} - Execution mode.
    */
   _executionModeForPayload(payload) {
-    const options = payload.options || {}
-    const executionMode = options.executionMode
+    const executionMode = payload.options?.executionMode
 
-    if (executionMode) return this._normalizeExecutionMode(executionMode)
-
-    if (options.forked === false) return "inline"
-    if (options.forked === true) return "forked"
-    return "pooled"
+    return executionMode ? this._normalizeExecutionMode(executionMode) : "pooled"
   }
 
   /**

package/build/database/migration/index.js

@@ -468,6 +468,26 @@ export default class VelociousDatabaseMigration {
     return Boolean(false)
   }
 
+  /**
+   * Checks whether an index with the given name exists on a table.
+   * @param {string} tableName - Table name.
+   * @param {string} indexName - Index name to look for.
+   * @returns {Promise<boolean>} - Whether the index exists on the table.
+   */
+  async indexExists(tableName, indexName) {
+    const table = await this.getDriver().getTableByName(tableName, {throwError: false})
+
+    if (table) {
+      for (const index of await table.getIndexes()) {
+        if (index.getName() == indexName) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }
+
   /**
    * Sets up the database schema for a gap-less positional list. Adds the
    * position column (INT NOT NULL) if absent and creates a UNIQUE index on

package/build/database/migrator.js

@@ -204,6 +204,11 @@ export default class VelociousDatabaseMigrator {
 
     if (!environmentHandler || Object.keys(filteredDbs).length == 0) return
 
+    // Ensure velocious' own framework schema (background jobs) before the structure
+    // dump, and unconditionally — the dump is gated to enabled environments but the
+    // framework schema must exist after every migrate so `db:migrate` (and thus
+    // schema:load of the dumped SQL) produces a complete DB in every environment.
+    await environmentHandler.ensureFrameworkSchema({dbs: filteredDbs})
     await environmentHandler.afterMigrations({dbs: filteredDbs})
   }
 

package/build/environment-handlers/base.js

@@ -508,6 +508,20 @@ export default class VelociousEnvironmentHandlerBase {
     return
   }
 
+  /**
+   * Ensures velocious' own framework-owned schema (e.g. the background-jobs
+   * tables) exists after app migrations run, so `db:migrate` produces a complete
+   * schema deterministically instead of it only appearing once a runtime store
+   * boots. Runs before the structure dump. No-op by default; the node handler
+   * overrides it.
+   * @param {object} args - Options object.
+   * @param {Record<string, import("../database/drivers/base.js").default>} args.dbs - Dbs being migrated.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async ensureFrameworkSchema(args) { // eslint-disable-line no-unused-vars
+    return
+  }
+
   /**
    * Runs require command.
    * @abstract

package/build/environment-handlers/node.js

@@ -1005,6 +1005,29 @@ export default class VelociousEnvironmentHandlerNode extends Base{
     return basePath
   }
 
+  /**
+   * Ensures velocious' background-jobs schema exists on its configured database
+   * as part of `db:migrate`, so the framework's own tables (background_jobs +
+   * background_job_concurrency, execution_mode etc.) are created deterministically
+   * alongside app migrations and captured in the dumped structure SQL — rather than
+   * only appearing once a runtime store boots. Reuses the store's idempotent
+   * `_ensureSchema`, so it's safe to re-run against DBs that already have it.
+   * @param {object} args - Options object.
+   * @param {Record<string, import("../database/drivers/base.js").default>} args.dbs - Dbs being migrated.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async ensureFrameworkSchema({dbs}) {
+    const {default: BackgroundJobsStore} = await import("../background-jobs/store.js")
+    const store = new BackgroundJobsStore({configuration: this.getConfiguration()})
+    const databaseIdentifier = store.getDatabaseIdentifier() ?? "default"
+
+    // Reuse the connection db:migrate already holds for this database; opening a
+    // nested checkout would deadlock a database whose pool is capped at one
+    // connection. When the background-jobs database isn't among the migrated set,
+    // this passes undefined and the store checks out its own (that pool is free).
+    await store.ensureSchema(dbs[databaseIdentifier])
+  }
+
   /**
    * Runs after migrations.
    * @param {object} args - Options object.

package/build/src/background-jobs/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/main.js"],"names":[],"mappings":"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"}