velocious 1.0.682 → 1.0.684

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

@@ -1,5 +1,6 @@
 // @ts-check
 import { randomUUID } from "node:crypto";
+import v8 from "node:v8";
 import timeout from "awaitery/build/timeout.js";
 import runJobPayload, { BackgroundJobPerformedFailure } from "./job-runner.js";
 import { boundedPooledRunnerInflightJobIds, isPooledChildShutdownReason, isPooledChildShutdownSignal } from "./pooled-runner-shutdown.js";
@@ -12,6 +13,10 @@ 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();
+/** Sampling cadence for the memory observation sampler. */
+const MEMORY_OBSERVATION_INTERVAL_MS = 10000;
+/** Bound on in-flight job ids carried in a memory observation. */
+const MEMORY_OBSERVATION_JOB_ID_LIMIT = 32;
 setRunnerProcessTitle();
 /** @type {Promise<void> | undefined} */
 let shutdownPromise;
@@ -138,6 +143,87 @@ function sendChildAcceptance(type, payload, observedAtMs) {
         // The IPC channel is already gone; the disconnect handler owns shutdown.
     }
 }
+/**
+ * Collects a bounded diagnostic snapshot of this child's memory state. The
+ * pooled child's stdio is ignored by the worker fork, so IPC is the only channel
+ * to the worker's log surface — this snapshot (sent periodically and on demand)
+ * is how a memory problem names itself in production. The V8 heap-stat
+ * breakdown (not a full heap snapshot, which would be far too expensive while a
+ * child runs 25 concurrent jobs) distinguishes a V8 heap-growth leak from
+ * external/array-buffer (native resource) growth, and the in-flight job ids
+ * tie the observation to the work that was running.
+ * @returns {{activeJobIds: string[], activeJobIdsTruncatedCount: number, childInstanceId: string, childPid: number, childUptimeMs: number, heapStatistics: ReturnType<typeof v8.getHeapStatistics>, jobCount: number, memoryUsage: ReturnType<typeof process.memoryUsage>, observedAtMs: number, rssBytes: number, type: "pooled-child-memory", uptimeMs: number}} - Bounded memory observation for this child.
+ */
+function collectMemoryObservation() {
+    const jobIds = [...runningJobIds];
+    const activeJobIds = jobIds.slice(0, MEMORY_OBSERVATION_JOB_ID_LIMIT);
+    const memoryUsage = process.memoryUsage();
+    return {
+        activeJobIds,
+        activeJobIdsTruncatedCount: Math.max(0, jobIds.length - activeJobIds.length),
+        childInstanceId,
+        childPid: process.pid,
+        childUptimeMs: Math.floor(process.uptime() * 1000),
+        heapStatistics: v8.getHeapStatistics(),
+        jobCount: jobIds.length,
+        memoryUsage,
+        observedAtMs: Date.now(),
+        rssBytes: memoryUsage.rss,
+        type: "pooled-child-memory",
+        uptimeMs: Math.floor(process.uptime() * 1000)
+    };
+}
+/**
+ * Sends a memory observation to the worker. Sampling is cheap (process + V8
+ * heap stats) and only runs while jobs are in flight; a closed IPC channel is
+ * terminal for this child (the disconnect handler owns shutdown), so a failed
+ * send is swallowed.
+ * @returns {void}
+ */
+function sendMemoryObservation() {
+    if (!process.send || runningJobIds.size === 0)
+        return;
+    try {
+        process.send(collectMemoryObservation());
+    }
+    catch {
+        // The IPC channel is already gone; the disconnect handler owns shutdown.
+    }
+}
+/** @type {ReturnType<typeof setInterval> | undefined} */
+let memoryObservationTimer;
+/**
+ * Checks whether an IPC value requests this child to send a memory observation.
+ * @param {ReturnType<typeof JSON.parse>} message - IPC message.
+ * @returns {message is {type: "memory-observation-request"}} - Whether the message requests one.
+ */
+function isMemoryObservationRequestMessage(message) {
+    return message !== null
+        && typeof message === "object"
+        && message.type === "memory-observation-request";
+}
+/**
+ * Starts the periodic memory observation sampler if it is not already running.
+ * @returns {void}
+ */
+function startMemoryObservationSampling() {
+    if (memoryObservationTimer || !process.send)
+        return;
+    memoryObservationTimer = setInterval(() => {
+        sendMemoryObservation();
+    }, MEMORY_OBSERVATION_INTERVAL_MS);
+    memoryObservationTimer.unref();
+}
+/**
+ * Stops the periodic memory observation sampler.
+ * @returns {void}
+ */
+function stopMemoryObservationSampling() {
+    if (!memoryObservationTimer)
+        return;
+    clearInterval(memoryObservationTimer);
+    memoryObservationTimer = undefined;
+}
 /**
  * Checks whether an IPC value is a runnable pooled job message.
  * @param {ReturnType<typeof JSON.parse>} message - IPC message.
@@ -227,6 +313,9 @@ async function runJob(payload, sharedTransactionBroker) {
     finally {
         runningJobIds.delete(payload.id);
         updateProcessTitle();
+        if (runningJobIds.size === 0) {
+            stopMemoryObservationSampling();
+        }
     }
 }
 /**
@@ -244,11 +333,16 @@ function handleMessage(message) {
         });
         return;
     }
+    if (isMemoryObservationRequestMessage(message)) {
+        sendMemoryObservation();
+        return;
+    }
     if (!isJobMessage(message) || runningJobIds.has(message.payload.id))
         return;
     runningJobIds.add(message.payload.id);
     updateProcessTitle();
     sendChildAcceptance("job-received", message.payload, Date.now());
+    startMemoryObservationSampling();
     void runJob(message.payload, message.sharedTransactionBroker || { expected: false });
 }
 process.on("message", (message) => handleMessage(message));
@@ -257,4 +351,4 @@ process.once("SIGTERM", () => void shutdownRunner({ exitCode: 1, reason: "signal
 process.once("SIGINT", () => void shutdownRunner({ exitCode: 1, reason: "signal_sigint", signal: "SIGINT" }));
 if (process.send)
     process.send({ childInstanceId, childPid: process.pid, type: "ready" });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooled-runner-child.js","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-child.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { randomUUID } from \"node:crypto\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport runJobPayload, { BackgroundJobPerformedFailure } from \"./job-runner.js\"\nimport { boundedPooledRunnerInflightJobIds, isPooledChildShutdownReason, isPooledChildShutdownSignal } from \"./pooled-runner-shutdown.js\"\nimport { closeRunnerConnections, closeRunnerFrameworkConnections, currentConfigurationOrNull } from \"./runner-graceful-shutdown.js\"\nimport setRunnerProcessTitle from \"./runner-process-title.js\"\nimport PooledRunnerBrokerIdentity from \"./pooled-runner-broker-identity.js\"\nimport { runWithSharedTransactionBrokerConfig } from \"../testing/shared-transaction-proxy-driver.js\"\n\nconst BASE_PROCESS_TITLE = \"velocious background-jobs-runner\"\n/** A shutdown observation may delay resource teardown only for this bounded IPC send. */\nconst SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS = 100\n/** Stable identity of this pooled child process for the life of the process. */\nconst childInstanceId = randomUUID()\n\nsetRunnerProcessTitle()\n\n/** @type {Promise<void> | undefined} */\nlet shutdownPromise\n\n/**\n * Closes the runner's connections — releasing any advisory lock a killed-mid-pass\n * job still holds — before exiting, instead of leaving a half-open session that\n * keeps the lock until the DB server's `wait_timeout`.\n * @param {object} args - Shutdown observation.\n * @param {number} args.exitCode - Process exit code.\n * @param {import(\"./types.js\").PooledChildShutdownReason} args.reason - Exact shutdown reason observed by the child.\n * @param {number | null} [args.shutdownRequestedAtMs] - Parent request timestamp when supplied over IPC.\n * @param {import(\"node:child_process\").ChildProcess[\"signalCode\"]} [args.signal] - Requested or observed signal.\n * @returns {Promise<void>}\n */\nfunction shutdownRunner({exitCode, reason, shutdownRequestedAtMs = null, signal = null}) {\n  if (shutdownPromise) return shutdownPromise\n\n  shutdownPromise = (async () => {\n    await sendShutdownObservation({reason, shutdownRequestedAtMs, signal})\n    await closeRunnerConnections(currentConfigurationOrNull())\n    process.exit(exitCode)\n  })()\n\n  return shutdownPromise\n}\n\n/**\n * Ids of jobs currently running in this child. A pooled child runs up to\n * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that\n * bound); the set dedupes a redelivered job id and lets each job settle\n * independently.\n * @type {Set<string>}\n */\nconst runningJobIds = new Set()\nconst brokerIdentity = new PooledRunnerBrokerIdentity({\n  closeConnections: async () => await closeRunnerFrameworkConnections(currentConfigurationOrNull())\n})\n\n/**\n * Sets an aggregate process title from the current in-flight count. A child runs\n * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and\n * restore around a single job) cannot represent the process — interleaved\n * completions would leave a stale label. Recomputing from `runningJobIds.size` is\n * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.\n * @returns {void}\n */\nfunction updateProcessTitle() {\n  const count = runningJobIds.size\n\n  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? \"job\" : \"jobs\"}` : BASE_PROCESS_TITLE\n}\n\n/**\n * Sends one bounded lifecycle observation before application/framework teardown.\n * A closed IPC channel is expected for `ipc_disconnect`; other send failures are\n * surfaced on stderr but never hold connection cleanup past the fixed bound.\n * @param {object} args - Shutdown observation.\n * @param {import(\"./types.js\").PooledChildShutdownReason} args.reason - Shutdown reason.\n * @param {number | null} args.shutdownRequestedAtMs - Parent request timestamp.\n * @param {import(\"node:child_process\").ChildProcess[\"signalCode\"]} args.signal - Requested or observed signal.\n * @returns {Promise<void>} - Resolves after IPC accepts the observation or the bound expires.\n */\nasync function sendShutdownObservation({reason, shutdownRequestedAtMs, signal}) {\n  if (!process.send || !process.connected) return\n\n  const boundedInflight = boundedPooledRunnerInflightJobIds(runningJobIds)\n  /** @type {import(\"./types.js\").PooledChildShutdownObservation & {type: \"shutdown-observation\"}} */\n  const message = {\n    childInstanceId,\n    ...boundedInflight,\n    reason,\n    shutdownObservedAtMs: Date.now(),\n    shutdownRequestedAtMs,\n    signal,\n    type: \"shutdown-observation\"\n  }\n\n  try {\n    await timeout({timeout: SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS}, async () => {\n      await new Promise((resolve, reject) => {\n        try {\n          process.send?.(message, (error) => {\n            if (error) {\n              reject(error)\n            } else {\n              resolve(undefined)\n            }\n          })\n        } catch (error) {\n          reject(error)\n        }\n      })\n    })\n  } catch (error) {\n    console.error(\"Pooled background job runner could not send its shutdown observation:\", error)\n  }\n}\n\n/**\n * Reports one acceptance observation (job received / perform started) to the\n * worker over IPC. The message carries the job's exact handoff lease so the\n * worker can persist it fenced without any other lookup. Send failures are\n * swallowed: a dead IPC channel is terminal for this child (the disconnect\n * handler owns shutdown), and losing acceptance evidence must never fail the\n * job itself.\n * @param {\"job-received\" | \"job-started\"} type - Observation kind.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload carrying the handoff lease.\n * @param {number} observedAtMs - Epoch ms of the observation.\n * @returns {void}\n */\nfunction sendChildAcceptance(type, payload, observedAtMs) {\n  if (!process.send) return\n\n  const message = {\n    childInstanceId,\n    childPid: process.pid,\n    handedOffAtMs: payload.handedOffAtMs,\n    handoffId: payload.handoffId,\n    jobId: payload.id,\n    type,\n    workerId: payload.workerId,\n    ...(type === \"job-received\" ? {receivedAtMs: observedAtMs} : {startedAtMs: observedAtMs})\n  }\n\n  try {\n    process.send(message)\n  } catch {\n    // The IPC channel is already gone; the disconnect handler owns shutdown.\n  }\n}\n\n/**\n * Checks whether an IPC value is a runnable pooled job message.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"job\", payload: import(\"./types.js\").BackgroundJobPayload & {id: string}, sharedTransactionBroker?: import(\"../testing/shared-transaction-proxy-driver.js\").SharedTransactionBrokerJobConfig}} - Whether this is a valid job message.\n */\nfunction isJobMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>, sharedTransactionBroker?: ReturnType<typeof JSON.parse>}} */ (message)\n\n  return record.type === \"job\" && !!record.payload && typeof record.payload === \"object\" && typeof record.payload.id === \"string\"\n}\n\n/**\n * Checks whether an IPC value requests a typed pooled-child shutdown.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"shutdown-request\", reason: import(\"./types.js\").PooledChildShutdownReason, shutdownRequestedAtMs: number, signal: import(\"node:child_process\").ChildProcess[\"signalCode\"]}} - Whether this is a valid parent shutdown request.\n */\nfunction isShutdownRequestMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, reason?: ReturnType<typeof JSON.parse>, shutdownRequestedAtMs?: ReturnType<typeof JSON.parse>, signal?: ReturnType<typeof JSON.parse>}} */ (message)\n\n  return record.type === \"shutdown-request\"\n    && isPooledChildShutdownReason(record.reason)\n    && typeof record.shutdownRequestedAtMs === \"number\"\n    && Number.isFinite(record.shutdownRequestedAtMs)\n    && isPooledChildShutdownSignal(record.signal)\n}\n\n/**\n * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.\n * @param {object} args - Outcome.\n * @param {string} args.jobId - Job id.\n * @param {boolean} args.acknowledged - Whether the terminal report was acknowledged.\n * @param {\"completed\" | \"failed\" | \"rescheduled\"} [args.status] - Acknowledged outcome.\n * @param {Error} [args.error] - Reporting error when acknowledgement was not obtained.\n * @returns {Promise<void>} - Resolves after IPC accepts the message.\n */\nfunction sendOutcome({jobId, acknowledged, status, error}) {\n  return new Promise((resolve) => {\n    if (!process.send) {\n      resolve(undefined)\n      return\n    }\n\n    process.send({\n      type: \"job-outcome\",\n      jobId,\n      acknowledged,\n      status,\n      rssBytes: process.memoryUsage().rss,\n      error: error?.message\n    }, () => resolve(undefined))\n  })\n}\n\n/**\n * Runs one job concurrently with any siblings and reports its own terminal\n * outcome. A single job's unexpected failure reports that job for reclamation\n * (`acknowledged: false`) but does NOT take down the child — its concurrent\n * siblings keep running. Only a process-level fault (which escapes every\n * per-job try/catch) ends the child, which the worker sees as an exit and\n * reclaims for the whole in-flight set.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload.\n * @param {import(\"../testing/shared-transaction-proxy-driver.js\").SharedTransactionBrokerJobConfig} sharedTransactionBroker - Per-job broker configuration.\n * @returns {Promise<void>} - Resolves after reporting.\n */\nasync function runJob(payload, sharedTransactionBroker) {\n  try {\n    const status = await runWithSharedTransactionBrokerConfig(sharedTransactionBroker, async () => {\n      return await brokerIdentity.run(sharedTransactionBroker, async () => {\n        return await runJobPayload(payload, {\n          closeConnections: false,\n          manageProcessTitle: false,\n          onPerformStart: () => sendChildAcceptance(\"job-started\", payload, Date.now()),\n          processType: \"background-jobs-pooled-runner\"\n        })\n      })\n    })\n    await sendOutcome({jobId: payload.id, acknowledged: true, status})\n  } catch (error) {\n    if (error instanceof BackgroundJobPerformedFailure) {\n      await sendOutcome({jobId: payload.id, acknowledged: true, status: \"failed\"})\n    } else {\n      const reportError = error instanceof Error ? error : new Error(String(error))\n      console.error(\"Pooled background job runner failed before terminal acknowledgement:\", reportError)\n      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})\n    }\n  } finally {\n    runningJobIds.delete(payload.id)\n    updateProcessTitle()\n  }\n}\n\n/**\n * Handles a job message, starting it alongside any concurrent siblings.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {void}\n */\nfunction handleMessage(message) {\n  if (isShutdownRequestMessage(message)) {\n    void shutdownRunner({\n      exitCode: message.reason === \"parent_retire_drained\" ? 0 : 1,\n      reason: message.reason,\n      shutdownRequestedAtMs: message.shutdownRequestedAtMs,\n      signal: message.signal\n    })\n    return\n  }\n\n  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return\n\n  runningJobIds.add(message.payload.id)\n  updateProcessTitle()\n  sendChildAcceptance(\"job-received\", message.payload, Date.now())\n  void runJob(message.payload, message.sharedTransactionBroker || {expected: false})\n}\n\nprocess.on(\"message\", (message) => handleMessage(message))\nprocess.once(\"disconnect\", () => void shutdownRunner({exitCode: 0, reason: \"ipc_disconnect\"}))\nprocess.once(\"SIGTERM\", () => void shutdownRunner({exitCode: 1, reason: \"signal_sigterm\", signal: \"SIGTERM\"}))\nprocess.once(\"SIGINT\", () => void shutdownRunner({exitCode: 1, reason: \"signal_sigint\", signal: \"SIGINT\"}))\nif (process.send) process.send({childInstanceId, childPid: process.pid, type: \"ready\"})\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooled-runner-child.js","sourceRoot":"","sources":["../../../src/background-jobs/pooled-runner-child.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,MAAM,SAAS,CAAA;AACxB,OAAO,OAAO,MAAM,2BAA2B,CAAA;AAC/C,OAAO,aAAa,EAAE,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAA;AAC9E,OAAO,EAAE,iCAAiC,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AACzI,OAAO,EAAE,sBAAsB,EAAE,+BAA+B,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AACnI,OAAO,qBAAqB,MAAM,2BAA2B,CAAA;AAC7D,OAAO,0BAA0B,MAAM,oCAAoC,CAAA;AAC3E,OAAO,EAAE,oCAAoC,EAAE,MAAM,+CAA+C,CAAA;AAEpG,MAAM,kBAAkB,GAAG,kCAAkC,CAAA;AAC7D,yFAAyF;AACzF,MAAM,oCAAoC,GAAG,GAAG,CAAA;AAChD,gFAAgF;AAChF,MAAM,eAAe,GAAG,UAAU,EAAE,CAAA;AACpC,2DAA2D;AAC3D,MAAM,8BAA8B,GAAG,KAAK,CAAA;AAC5C,kEAAkE;AAClE,MAAM,+BAA+B,GAAG,EAAE,CAAA;AAE1C,qBAAqB,EAAE,CAAA;AAEvB,wCAAwC;AACxC,IAAI,eAAe,CAAA;AAEnB;;;;;;;;;;GAUG;AACH,SAAS,cAAc,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAE,qBAAqB,GAAG,IAAI,EAAE,MAAM,GAAG,IAAI,EAAC;IACrF,IAAI,eAAe;QAAE,OAAO,eAAe,CAAA;IAE3C,eAAe,GAAG,CAAC,KAAK,IAAI,EAAE;QAC5B,MAAM,uBAAuB,CAAC,EAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAC,CAAC,CAAA;QACtE,MAAM,sBAAsB,CAAC,0BAA0B,EAAE,CAAC,CAAA;QAC1D,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACxB,CAAC,CAAC,EAAE,CAAA;IAEJ,OAAO,eAAe,CAAA;AACxB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,aAAa,GAAG,IAAI,GAAG,EAAE,CAAA;AAC/B,MAAM,cAAc,GAAG,IAAI,0BAA0B,CAAC;IACpD,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,+BAA+B,CAAC,0BAA0B,EAAE,CAAC;CAClG,CAAC,CAAA;AAEF;;;;;;;GAOG;AACH,SAAS,kBAAkB;IACzB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAA;IAEhC,OAAO,CAAC,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,kBAAkB,KAAK,KAAK,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAA;AACpH,CAAC;AAED;;;;;;;;;GASG;AACH,KAAK,UAAU,uBAAuB,CAAC,EAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAC;IAC5E,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS;QAAE,OAAM;IAE/C,MAAM,eAAe,GAAG,iCAAiC,CAAC,aAAa,CAAC,CAAA;IACxE,mGAAmG;IACnG,MAAM,OAAO,GAAG;QACd,eAAe;QACf,GAAG,eAAe;QAClB,MAAM;QACN,oBAAoB,EAAE,IAAI,CAAC,GAAG,EAAE;QAChC,qBAAqB;QACrB,MAAM;QACN,IAAI,EAAE,sBAAsB;KAC7B,CAAA;IAED,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,EAAC,OAAO,EAAE,oCAAoC,EAAC,EAAE,KAAK,IAAI,EAAE;YACxE,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACpC,IAAI,CAAC;oBACH,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;wBAChC,IAAI,KAAK,EAAE,CAAC;4BACV,MAAM,CAAC,KAAK,CAAC,CAAA;wBACf,CAAC;6BAAM,CAAC;4BACN,OAAO,CAAC,SAAS,CAAC,CAAA;wBACpB,CAAC;oBACH,CAAC,CAAC,CAAA;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,KAAK,CAAC,CAAA;gBACf,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,uEAAuE,EAAE,KAAK,CAAC,CAAA;IAC/F,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY;IACtD,IAAI,CAAC,OAAO,CAAC,IAAI;QAAE,OAAM;IAEzB,MAAM,OAAO,GAAG;QACd,eAAe;QACf,QAAQ,EAAE,OAAO,CAAC,GAAG;QACrB,aAAa,EAAE,OAAO,CAAC,aAAa;QACpC,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,EAAE;QACjB,IAAI;QACJ,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,GAAG,CAAC,IAAI,KAAK,cAAc,CAAC,CAAC,CAAC,EAAC,YAAY,EAAE,YAAY,EAAC,CAAC,CAAC,CAAC,EAAC,WAAW,EAAE,YAAY,EAAC,CAAC;KAC1F,CAAA;IAED,IAAI,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvB,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,wBAAwB;IAC/B,MAAM,MAAM,GAAG,CAAC,GAAG,aAAa,CAAC,CAAA;IACjC,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,+BAA+B,CAAC,CAAA;IACrE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAA;IAEzC,OAAO;QACL,YAAY;QACZ,0BAA0B,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;QAC5E,eAAe;QACf,QAAQ,EAAE,OAAO,CAAC,GAAG;QACrB,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC;QAClD,cAAc,EAAE,EAAE,CAAC,iBAAiB,EAAE;QACtC,QAAQ,EAAE,MAAM,CAAC,MAAM;QACvB,WAAW;QACX,YAAY,EAAE,IAAI,CAAC,GAAG,EAAE;QACxB,QAAQ,EAAE,WAAW,CAAC,GAAG;QACzB,IAAI,EAAE,qBAAqB;QAC3B,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC;KAC9C,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB;IAC5B,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,aAAa,CAAC,IAAI,KAAK,CAAC;QAAE,OAAM;IAErD,IAAI,CAAC;QACH,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,CAAC,CAAA;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;AACH,CAAC;AAED,yDAAyD;AACzD,IAAI,sBAAsB,CAAA;AAE1B;;;;GAIG;AACH,SAAS,iCAAiC,CAAC,OAAO;IAChD,OAAO,OAAO,KAAK,IAAI;WAClB,OAAO,OAAO,KAAK,QAAQ;WAC3B,OAAO,CAAC,IAAI,KAAK,4BAA4B,CAAA;AACpD,CAAC;AAED;;;GAGG;AACH,SAAS,8BAA8B;IACrC,IAAI,sBAAsB,IAAI,CAAC,OAAO,CAAC,IAAI;QAAE,OAAM;IAEnD,sBAAsB,GAAG,WAAW,CAAC,GAAG,EAAE;QACxC,qBAAqB,EAAE,CAAA;IACzB,CAAC,EAAE,8BAA8B,CAAC,CAAA;IAClC,sBAAsB,CAAC,KAAK,EAAE,CAAA;AAChC,CAAC;AAED;;;GAGG;AACH,SAAS,6BAA6B;IACpC,IAAI,CAAC,sBAAsB;QAAE,OAAM;IAEnC,aAAa,CAAC,sBAAsB,CAAC,CAAA;IACrC,sBAAsB,GAAG,SAAS,CAAA;AACpC,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,OAAO;IAC3B,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IACzD,MAAM,MAAM,GAAG,uJAAuJ,CAAC,CAAC,OAAO,CAAC,CAAA;IAEhL,OAAO,MAAM,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAA;AACjI,CAAC;AAED;;;;GAIG;AACH,SAAS,wBAAwB,CAAC,OAAO;IACvC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IACzD,MAAM,MAAM,GAAG,4LAA4L,CAAC,CAAC,OAAO,CAAC,CAAA;IAErN,OAAO,MAAM,CAAC,IAAI,KAAK,kBAAkB;WACpC,2BAA2B,CAAC,MAAM,CAAC,MAAM,CAAC;WAC1C,OAAO,MAAM,CAAC,qBAAqB,KAAK,QAAQ;WAChD,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,qBAAqB,CAAC;WAC7C,2BAA2B,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;AACjD,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,WAAW,CAAC,EAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAC;IACvD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAClB,OAAO,CAAC,SAAS,CAAC,CAAA;YAClB,OAAM;QACR,CAAC;QAED,OAAO,CAAC,IAAI,CAAC;YACX,IAAI,EAAE,aAAa;YACnB,KAAK;YACL,YAAY;YACZ,MAAM;YACN,QAAQ,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,GAAG;YACnC,KAAK,EAAE,KAAK,EAAE,OAAO;SACtB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;IAC9B,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,KAAK,UAAU,MAAM,CAAC,OAAO,EAAE,uBAAuB;IACpD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,oCAAoC,CAAC,uBAAuB,EAAE,KAAK,IAAI,EAAE;YAC5F,OAAO,MAAM,cAAc,CAAC,GAAG,CAAC,uBAAuB,EAAE,KAAK,IAAI,EAAE;gBAClE,OAAO,MAAM,aAAa,CAAC,OAAO,EAAE;oBAClC,gBAAgB,EAAE,KAAK;oBACvB,kBAAkB,EAAE,KAAK;oBACzB,cAAc,EAAE,GAAG,EAAE,CAAC,mBAAmB,CAAC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;oBAC7E,WAAW,EAAE,+BAA+B;iBAC7C,CAAC,CAAA;YACJ,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;QACF,MAAM,WAAW,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAAA;IACpE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,6BAA6B,EAAE,CAAC;YACnD,MAAM,WAAW,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC9E,CAAC;aAAM,CAAC;YACN,MAAM,WAAW,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAC7E,OAAO,CAAC,KAAK,CAAC,sEAAsE,EAAE,WAAW,CAAC,CAAA;YAClG,MAAM,WAAW,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAC,CAAC,CAAA;QACjF,CAAC;IACH,CAAC;YAAS,CAAC;QACT,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAChC,kBAAkB,EAAE,CAAA;QAEpB,IAAI,aAAa,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAC7B,6BAA6B,EAAE,CAAA;QACjC,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,OAAO;IAC5B,IAAI,wBAAwB,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,KAAK,cAAc,CAAC;YAClB,QAAQ,EAAE,OAAO,CAAC,MAAM,KAAK,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,qBAAqB,EAAE,OAAO,CAAC,qBAAqB;YACpD,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CAAC,CAAA;QACF,OAAM;IACR,CAAC;IAED,IAAI,iCAAiC,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/C,qBAAqB,EAAE,CAAA;QACvB,OAAM;IACR,CAAC;IAED,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAAE,OAAM;IAE3E,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IACrC,kBAAkB,EAAE,CAAA;IACpB,mBAAmB,CAAC,cAAc,EAAE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAA;IAChE,8BAA8B,EAAE,CAAA;IAChC,KAAK,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,IAAI,EAAC,QAAQ,EAAE,KAAK,EAAC,CAAC,CAAA;AACpF,CAAC;AAED,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;AAC1D,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,EAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAC,CAAC,CAAC,CAAA;AAC9F,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,EAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,SAAS,EAAC,CAAC,CAAC,CAAA;AAC9G,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,EAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAC,CAAC,CAAC,CAAA;AAC3G,IAAI,OAAO,CAAC,IAAI;IAAE,OAAO,CAAC,IAAI,CAAC,EAAC,eAAe,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC,CAAA","sourcesContent":["// @ts-check\n\nimport { randomUUID } from \"node:crypto\"\nimport v8 from \"node:v8\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport runJobPayload, { BackgroundJobPerformedFailure } from \"./job-runner.js\"\nimport { boundedPooledRunnerInflightJobIds, isPooledChildShutdownReason, isPooledChildShutdownSignal } from \"./pooled-runner-shutdown.js\"\nimport { closeRunnerConnections, closeRunnerFrameworkConnections, currentConfigurationOrNull } from \"./runner-graceful-shutdown.js\"\nimport setRunnerProcessTitle from \"./runner-process-title.js\"\nimport PooledRunnerBrokerIdentity from \"./pooled-runner-broker-identity.js\"\nimport { runWithSharedTransactionBrokerConfig } from \"../testing/shared-transaction-proxy-driver.js\"\n\nconst BASE_PROCESS_TITLE = \"velocious background-jobs-runner\"\n/** A shutdown observation may delay resource teardown only for this bounded IPC send. */\nconst SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS = 100\n/** Stable identity of this pooled child process for the life of the process. */\nconst childInstanceId = randomUUID()\n/** Sampling cadence for the memory observation sampler. */\nconst MEMORY_OBSERVATION_INTERVAL_MS = 10000\n/** Bound on in-flight job ids carried in a memory observation. */\nconst MEMORY_OBSERVATION_JOB_ID_LIMIT = 32\n\nsetRunnerProcessTitle()\n\n/** @type {Promise<void> | undefined} */\nlet shutdownPromise\n\n/**\n * Closes the runner's connections — releasing any advisory lock a killed-mid-pass\n * job still holds — before exiting, instead of leaving a half-open session that\n * keeps the lock until the DB server's `wait_timeout`.\n * @param {object} args - Shutdown observation.\n * @param {number} args.exitCode - Process exit code.\n * @param {import(\"./types.js\").PooledChildShutdownReason} args.reason - Exact shutdown reason observed by the child.\n * @param {number | null} [args.shutdownRequestedAtMs] - Parent request timestamp when supplied over IPC.\n * @param {import(\"node:child_process\").ChildProcess[\"signalCode\"]} [args.signal] - Requested or observed signal.\n * @returns {Promise<void>}\n */\nfunction shutdownRunner({exitCode, reason, shutdownRequestedAtMs = null, signal = null}) {\n  if (shutdownPromise) return shutdownPromise\n\n  shutdownPromise = (async () => {\n    await sendShutdownObservation({reason, shutdownRequestedAtMs, signal})\n    await closeRunnerConnections(currentConfigurationOrNull())\n    process.exit(exitCode)\n  })()\n\n  return shutdownPromise\n}\n\n/**\n * Ids of jobs currently running in this child. A pooled child runs up to\n * `pooledRunnerConcurrency` jobs at once (the worker only dispatches within that\n * bound); the set dedupes a redelivered job id and lets each job settle\n * independently.\n * @type {Set<string>}\n */\nconst runningJobIds = new Set()\nconst brokerIdentity = new PooledRunnerBrokerIdentity({\n  closeConnections: async () => await closeRunnerFrameworkConnections(currentConfigurationOrNull())\n})\n\n/**\n * Sets an aggregate process title from the current in-flight count. A child runs\n * jobs concurrently, so a per-job title (which `runJobPayload` would snapshot and\n * restore around a single job) cannot represent the process — interleaved\n * completions would leave a stale label. Recomputing from `runningJobIds.size` is\n * concurrency-safe and honest: `ps`/`top` show how many jobs the child is running.\n * @returns {void}\n */\nfunction updateProcessTitle() {\n  const count = runningJobIds.size\n\n  process.title = count > 0 ? `${BASE_PROCESS_TITLE}: ${count} ${count === 1 ? \"job\" : \"jobs\"}` : BASE_PROCESS_TITLE\n}\n\n/**\n * Sends one bounded lifecycle observation before application/framework teardown.\n * A closed IPC channel is expected for `ipc_disconnect`; other send failures are\n * surfaced on stderr but never hold connection cleanup past the fixed bound.\n * @param {object} args - Shutdown observation.\n * @param {import(\"./types.js\").PooledChildShutdownReason} args.reason - Shutdown reason.\n * @param {number | null} args.shutdownRequestedAtMs - Parent request timestamp.\n * @param {import(\"node:child_process\").ChildProcess[\"signalCode\"]} args.signal - Requested or observed signal.\n * @returns {Promise<void>} - Resolves after IPC accepts the observation or the bound expires.\n */\nasync function sendShutdownObservation({reason, shutdownRequestedAtMs, signal}) {\n  if (!process.send || !process.connected) return\n\n  const boundedInflight = boundedPooledRunnerInflightJobIds(runningJobIds)\n  /** @type {import(\"./types.js\").PooledChildShutdownObservation & {type: \"shutdown-observation\"}} */\n  const message = {\n    childInstanceId,\n    ...boundedInflight,\n    reason,\n    shutdownObservedAtMs: Date.now(),\n    shutdownRequestedAtMs,\n    signal,\n    type: \"shutdown-observation\"\n  }\n\n  try {\n    await timeout({timeout: SHUTDOWN_OBSERVATION_SEND_TIMEOUT_MS}, async () => {\n      await new Promise((resolve, reject) => {\n        try {\n          process.send?.(message, (error) => {\n            if (error) {\n              reject(error)\n            } else {\n              resolve(undefined)\n            }\n          })\n        } catch (error) {\n          reject(error)\n        }\n      })\n    })\n  } catch (error) {\n    console.error(\"Pooled background job runner could not send its shutdown observation:\", error)\n  }\n}\n\n/**\n * Reports one acceptance observation (job received / perform started) to the\n * worker over IPC. The message carries the job's exact handoff lease so the\n * worker can persist it fenced without any other lookup. Send failures are\n * swallowed: a dead IPC channel is terminal for this child (the disconnect\n * handler owns shutdown), and losing acceptance evidence must never fail the\n * job itself.\n * @param {\"job-received\" | \"job-started\"} type - Observation kind.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload carrying the handoff lease.\n * @param {number} observedAtMs - Epoch ms of the observation.\n * @returns {void}\n */\nfunction sendChildAcceptance(type, payload, observedAtMs) {\n  if (!process.send) return\n\n  const message = {\n    childInstanceId,\n    childPid: process.pid,\n    handedOffAtMs: payload.handedOffAtMs,\n    handoffId: payload.handoffId,\n    jobId: payload.id,\n    type,\n    workerId: payload.workerId,\n    ...(type === \"job-received\" ? {receivedAtMs: observedAtMs} : {startedAtMs: observedAtMs})\n  }\n\n  try {\n    process.send(message)\n  } catch {\n    // The IPC channel is already gone; the disconnect handler owns shutdown.\n  }\n}\n\n/**\n * Collects a bounded diagnostic snapshot of this child's memory state. The\n * pooled child's stdio is ignored by the worker fork, so IPC is the only channel\n * to the worker's log surface — this snapshot (sent periodically and on demand)\n * is how a memory problem names itself in production. The V8 heap-stat\n * breakdown (not a full heap snapshot, which would be far too expensive while a\n * child runs 25 concurrent jobs) distinguishes a V8 heap-growth leak from\n * external/array-buffer (native resource) growth, and the in-flight job ids\n * tie the observation to the work that was running.\n * @returns {{activeJobIds: string[], activeJobIdsTruncatedCount: number, childInstanceId: string, childPid: number, childUptimeMs: number, heapStatistics: ReturnType<typeof v8.getHeapStatistics>, jobCount: number, memoryUsage: ReturnType<typeof process.memoryUsage>, observedAtMs: number, rssBytes: number, type: \"pooled-child-memory\", uptimeMs: number}} - Bounded memory observation for this child.\n */\nfunction collectMemoryObservation() {\n  const jobIds = [...runningJobIds]\n  const activeJobIds = jobIds.slice(0, MEMORY_OBSERVATION_JOB_ID_LIMIT)\n  const memoryUsage = process.memoryUsage()\n\n  return {\n    activeJobIds,\n    activeJobIdsTruncatedCount: Math.max(0, jobIds.length - activeJobIds.length),\n    childInstanceId,\n    childPid: process.pid,\n    childUptimeMs: Math.floor(process.uptime() * 1000),\n    heapStatistics: v8.getHeapStatistics(),\n    jobCount: jobIds.length,\n    memoryUsage,\n    observedAtMs: Date.now(),\n    rssBytes: memoryUsage.rss,\n    type: \"pooled-child-memory\",\n    uptimeMs: Math.floor(process.uptime() * 1000)\n  }\n}\n\n/**\n * Sends a memory observation to the worker. Sampling is cheap (process + V8\n * heap stats) and only runs while jobs are in flight; a closed IPC channel is\n * terminal for this child (the disconnect handler owns shutdown), so a failed\n * send is swallowed.\n * @returns {void}\n */\nfunction sendMemoryObservation() {\n  if (!process.send || runningJobIds.size === 0) return\n\n  try {\n    process.send(collectMemoryObservation())\n  } catch {\n    // The IPC channel is already gone; the disconnect handler owns shutdown.\n  }\n}\n\n/** @type {ReturnType<typeof setInterval> | undefined} */\nlet memoryObservationTimer\n\n/**\n * Checks whether an IPC value requests this child to send a memory observation.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"memory-observation-request\"}} - Whether the message requests one.\n */\nfunction isMemoryObservationRequestMessage(message) {\n  return message !== null\n    && typeof message === \"object\"\n    && message.type === \"memory-observation-request\"\n}\n\n/**\n * Starts the periodic memory observation sampler if it is not already running.\n * @returns {void}\n */\nfunction startMemoryObservationSampling() {\n  if (memoryObservationTimer || !process.send) return\n\n  memoryObservationTimer = setInterval(() => {\n    sendMemoryObservation()\n  }, MEMORY_OBSERVATION_INTERVAL_MS)\n  memoryObservationTimer.unref()\n}\n\n/**\n * Stops the periodic memory observation sampler.\n * @returns {void}\n */\nfunction stopMemoryObservationSampling() {\n  if (!memoryObservationTimer) return\n\n  clearInterval(memoryObservationTimer)\n  memoryObservationTimer = undefined\n}\n\n/**\n * Checks whether an IPC value is a runnable pooled job message.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"job\", payload: import(\"./types.js\").BackgroundJobPayload & {id: string}, sharedTransactionBroker?: import(\"../testing/shared-transaction-proxy-driver.js\").SharedTransactionBrokerJobConfig}} - Whether this is a valid job message.\n */\nfunction isJobMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, payload?: ReturnType<typeof JSON.parse>, sharedTransactionBroker?: ReturnType<typeof JSON.parse>}} */ (message)\n\n  return record.type === \"job\" && !!record.payload && typeof record.payload === \"object\" && typeof record.payload.id === \"string\"\n}\n\n/**\n * Checks whether an IPC value requests a typed pooled-child shutdown.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {message is {type: \"shutdown-request\", reason: import(\"./types.js\").PooledChildShutdownReason, shutdownRequestedAtMs: number, signal: import(\"node:child_process\").ChildProcess[\"signalCode\"]}} - Whether this is a valid parent shutdown request.\n */\nfunction isShutdownRequestMessage(message) {\n  if (!message || typeof message !== \"object\") return false\n  const record = /** @type {{type?: ReturnType<typeof JSON.parse>, reason?: ReturnType<typeof JSON.parse>, shutdownRequestedAtMs?: ReturnType<typeof JSON.parse>, signal?: ReturnType<typeof JSON.parse>}} */ (message)\n\n  return record.type === \"shutdown-request\"\n    && isPooledChildShutdownReason(record.reason)\n    && typeof record.shutdownRequestedAtMs === \"number\"\n    && Number.isFinite(record.shutdownRequestedAtMs)\n    && isPooledChildShutdownSignal(record.signal)\n}\n\n/**\n * Sends the terminal outcome after the main/DB report has been acknowledged or rejected.\n * @param {object} args - Outcome.\n * @param {string} args.jobId - Job id.\n * @param {boolean} args.acknowledged - Whether the terminal report was acknowledged.\n * @param {\"completed\" | \"failed\" | \"rescheduled\"} [args.status] - Acknowledged outcome.\n * @param {Error} [args.error] - Reporting error when acknowledgement was not obtained.\n * @returns {Promise<void>} - Resolves after IPC accepts the message.\n */\nfunction sendOutcome({jobId, acknowledged, status, error}) {\n  return new Promise((resolve) => {\n    if (!process.send) {\n      resolve(undefined)\n      return\n    }\n\n    process.send({\n      type: \"job-outcome\",\n      jobId,\n      acknowledged,\n      status,\n      rssBytes: process.memoryUsage().rss,\n      error: error?.message\n    }, () => resolve(undefined))\n  })\n}\n\n/**\n * Runs one job concurrently with any siblings and reports its own terminal\n * outcome. A single job's unexpected failure reports that job for reclamation\n * (`acknowledged: false`) but does NOT take down the child — its concurrent\n * siblings keep running. Only a process-level fault (which escapes every\n * per-job try/catch) ends the child, which the worker sees as an exit and\n * reclaims for the whole in-flight set.\n * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Job payload.\n * @param {import(\"../testing/shared-transaction-proxy-driver.js\").SharedTransactionBrokerJobConfig} sharedTransactionBroker - Per-job broker configuration.\n * @returns {Promise<void>} - Resolves after reporting.\n */\nasync function runJob(payload, sharedTransactionBroker) {\n  try {\n    const status = await runWithSharedTransactionBrokerConfig(sharedTransactionBroker, async () => {\n      return await brokerIdentity.run(sharedTransactionBroker, async () => {\n        return await runJobPayload(payload, {\n          closeConnections: false,\n          manageProcessTitle: false,\n          onPerformStart: () => sendChildAcceptance(\"job-started\", payload, Date.now()),\n          processType: \"background-jobs-pooled-runner\"\n        })\n      })\n    })\n    await sendOutcome({jobId: payload.id, acknowledged: true, status})\n  } catch (error) {\n    if (error instanceof BackgroundJobPerformedFailure) {\n      await sendOutcome({jobId: payload.id, acknowledged: true, status: \"failed\"})\n    } else {\n      const reportError = error instanceof Error ? error : new Error(String(error))\n      console.error(\"Pooled background job runner failed before terminal acknowledgement:\", reportError)\n      await sendOutcome({jobId: payload.id, acknowledged: false, error: reportError})\n    }\n  } finally {\n    runningJobIds.delete(payload.id)\n    updateProcessTitle()\n\n    if (runningJobIds.size === 0) {\n      stopMemoryObservationSampling()\n    }\n  }\n}\n\n/**\n * Handles a job message, starting it alongside any concurrent siblings.\n * @param {ReturnType<typeof JSON.parse>} message - IPC message.\n * @returns {void}\n */\nfunction handleMessage(message) {\n  if (isShutdownRequestMessage(message)) {\n    void shutdownRunner({\n      exitCode: message.reason === \"parent_retire_drained\" ? 0 : 1,\n      reason: message.reason,\n      shutdownRequestedAtMs: message.shutdownRequestedAtMs,\n      signal: message.signal\n    })\n    return\n  }\n\n  if (isMemoryObservationRequestMessage(message)) {\n    sendMemoryObservation()\n    return\n  }\n\n  if (!isJobMessage(message) || runningJobIds.has(message.payload.id)) return\n\n  runningJobIds.add(message.payload.id)\n  updateProcessTitle()\n  sendChildAcceptance(\"job-received\", message.payload, Date.now())\n  startMemoryObservationSampling()\n  void runJob(message.payload, message.sharedTransactionBroker || {expected: false})\n}\n\nprocess.on(\"message\", (message) => handleMessage(message))\nprocess.once(\"disconnect\", () => void shutdownRunner({exitCode: 0, reason: \"ipc_disconnect\"}))\nprocess.once(\"SIGTERM\", () => void shutdownRunner({exitCode: 1, reason: \"signal_sigterm\", signal: \"SIGTERM\"}))\nprocess.once(\"SIGINT\", () => void shutdownRunner({exitCode: 1, reason: \"signal_sigint\", signal: \"SIGINT\"}))\nif (process.send) process.send({childInstanceId, childPid: process.pid, type: \"ready\"})\n"]}

package/build/src/background-jobs/types.d.ts

@@ -178,6 +178,56 @@ export type PooledChildShutdownObservation = {
      */
     signal: import("node:child_process").ChildProcess["signalCode"];
 };
+export type PooledChildMemoryObservation = {
+    /**
+     * - In-flight job ids, bounded.
+     */
+    activeJobIds: string[];
+    /**
+     * - In-flight job ids omitted by the bound.
+     */
+    activeJobIdsTruncatedCount: number;
+    /**
+     * - Stable identity reported by the child.
+     */
+    childInstanceId: string;
+    /**
+     * - Child process id.
+     */
+    childPid: number;
+    /**
+     * - Child process uptime in ms.
+     */
+    childUptimeMs: number;
+    /**
+     * - V8 heap-stat breakdown at the sample.
+     */
+    heapStatistics: ReturnType<typeof import("node:v8").getHeapStatistics>;
+    /**
+     * - In-flight job count.
+     */
+    jobCount: number;
+    /**
+     * - Process memory breakdown at the sample.
+     */
+    memoryUsage: ReturnType<typeof import("node:process").memoryUsage>;
+    /**
+     * - Epoch ms the child sampled.
+     */
+    observedAtMs: number;
+    /**
+     * - Resident set size in bytes at the sample.
+     */
+    rssBytes: number;
+    /**
+     * - Discriminator.
+     */
+    type: "pooled-child-memory";
+    /**
+     * - Process uptime in ms.
+     */
+    uptimeMs: number;
+};
 export type LocalBackgroundJobsClock = {
     /**
      * - Current epoch milliseconds.
@@ -886,6 +936,27 @@ export type BackgroundJobSocketMessage = BackgroundJobHelloMessage | BackgroundJ
  * @property {number | null} shutdownRequestedAtMs - Parent request timestamp when supplied over IPC.
  * @property {import("node:child_process").ChildProcess["signalCode"]} signal - Requested or observed signal when available.
  */
+/**
+ * Bounded pooled-child memory observation sent over the child IPC channel.
+ * The pooled child's stdio is ignored by the worker fork, so this observation
+ * (sent periodically while jobs run, plus on demand) is how a memory problem
+ * in a running child names itself. `heapStatistics` and `memoryUsage`
+ * distinguish V8-heap growth from external/array-buffer (native resource)
+ * growth; `activeJobIds` ties the sample to the work that was in flight.
+ * @typedef {object} PooledChildMemoryObservation
+ * @property {string[]} activeJobIds - In-flight job ids, bounded.
+ * @property {number} activeJobIdsTruncatedCount - In-flight job ids omitted by the bound.
+ * @property {string} childInstanceId - Stable identity reported by the child.
+ * @property {number} childPid - Child process id.
+ * @property {number} childUptimeMs - Child process uptime in ms.
+ * @property {ReturnType<typeof import("node:v8").getHeapStatistics>} heapStatistics - V8 heap-stat breakdown at the sample.
+ * @property {number} jobCount - In-flight job count.
+ * @property {ReturnType<typeof import("node:process").memoryUsage>} memoryUsage - Process memory breakdown at the sample.
+ * @property {number} observedAtMs - Epoch ms the child sampled.
+ * @property {number} rssBytes - Resident set size in bytes at the sample.
+ * @property {"pooled-child-memory"} type - Discriminator.
+ * @property {number} uptimeMs - Process uptime in ms.
+ */
 /**
  * @typedef {object} LocalBackgroundJobsClock
  * @property {() => number} now - Current epoch milliseconds.

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

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

package/build/src/background-jobs/types.js

@@ -72,6 +72,27 @@
  * @property {number | null} shutdownRequestedAtMs - Parent request timestamp when supplied over IPC.
  * @property {import("node:child_process").ChildProcess["signalCode"]} signal - Requested or observed signal when available.
  */
+/**
+ * Bounded pooled-child memory observation sent over the child IPC channel.
+ * The pooled child's stdio is ignored by the worker fork, so this observation
+ * (sent periodically while jobs run, plus on demand) is how a memory problem
+ * in a running child names itself. `heapStatistics` and `memoryUsage`
+ * distinguish V8-heap growth from external/array-buffer (native resource)
+ * growth; `activeJobIds` ties the sample to the work that was in flight.
+ * @typedef {object} PooledChildMemoryObservation
+ * @property {string[]} activeJobIds - In-flight job ids, bounded.
+ * @property {number} activeJobIdsTruncatedCount - In-flight job ids omitted by the bound.
+ * @property {string} childInstanceId - Stable identity reported by the child.
+ * @property {number} childPid - Child process id.
+ * @property {number} childUptimeMs - Child process uptime in ms.
+ * @property {ReturnType<typeof import("node:v8").getHeapStatistics>} heapStatistics - V8 heap-stat breakdown at the sample.
+ * @property {number} jobCount - In-flight job count.
+ * @property {ReturnType<typeof import("node:process").memoryUsage>} memoryUsage - Process memory breakdown at the sample.
+ * @property {number} observedAtMs - Epoch ms the child sampled.
+ * @property {number} rssBytes - Resident set size in bytes at the sample.
+ * @property {"pooled-child-memory"} type - Discriminator.
+ * @property {number} uptimeMs - Process uptime in ms.
+ */
 /**
  * @typedef {object} LocalBackgroundJobsClock
  * @property {() => number} now - Current epoch milliseconds.
@@ -280,4 +301,4 @@
  * @typedef {BackgroundJobHelloMessage | BackgroundJobGenerationAcceptedMessage | BackgroundJobGenerationRejectedMessage | BackgroundJobReadyMessage | BackgroundJobDrainingMessage | BackgroundJobHeartbeatMessage | BackgroundJobEnqueueMessage | BackgroundJobEnqueuedMessage | BackgroundJobEnqueueErrorMessage | BackgroundJobReplaceScheduledMessage | BackgroundJobScheduleReplacedMessage | BackgroundJobReplaceScheduledErrorMessage | BackgroundJobCancelScheduledMessage | BackgroundJobScheduleCancelledMessage | BackgroundJobCancelScheduledErrorMessage | BackgroundJobGetScheduledMessage | BackgroundJobScheduledMessage | BackgroundJobGetScheduledErrorMessage | BackgroundJobWakeScheduledMessage | BackgroundJobScheduleWokenMessage | BackgroundJobWakeScheduledErrorMessage | BackgroundJobJobMessage | BackgroundJobAcceptedMessage | BackgroundJobCompleteMessage | BackgroundJobFailedMessage | BackgroundJobRescheduleMessage | BackgroundJobUpdatedMessage | BackgroundJobUpdateErrorMessage} BackgroundJobSocketMessage
  */
 export const nothing = {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/background-jobs/types.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;GAEG;AACH,yFAAyF;AACzF,iIAAiI;AACjI,6NAA6N;AAC7N,mEAAmE;AACnE,+FAA+F;AAC/F,6FAA6F;AAC7F,iFAAiF;AACjF,gFAAgF;AAChF,qOAAqO;AACrO;;;GAGG;AACH,wFAAwF;AACxF;;;;;;;;GAQG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;;;;;;;;;GAUG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;GAYG;AACH;;;GAGG;AACH;;;;;;;GAOG;AACH;;;;;GAKG;AACH;;;;;;GAMG;AACH;;;;;GAKG;AACH;;;;;;;;;;;GAWG;AACH;;;;;;;;;GASG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;GAEG;AACH;;;;;GAKG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;GAIG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;;;;;;;;GAWG;AACH;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;GAEG;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAA","sourcesContent":["// @ts-check\n\n/**\n * @typedef {\"inline\" | \"forked\" | \"pooled\" | \"spawned\"} BackgroundJobExecutionMode\n */\n/** @typedef {\"candidate\" | \"active\" | \"retired\"} BackgroundJobsGenerationInitialState */\n/** @typedef {\"starting\" | \"candidate\" | \"active\" | \"retiring\" | \"retired\" | \"stopped\"} BackgroundJobsGenerationLifecycleState */\n/** @typedef {\"missing-generation\" | \"unexpected-generation\" | \"malformed-generation\" | \"generation-mismatch\" | \"worker-admission-retired\" | \"worker-has-no-recoverable-handoffs\"} BackgroundJobsGenerationRejectionReason */\n/** @typedef {\"queued\" | \"handed_off\"} BackgroundJobActiveStatus */\n/** @typedef {\"cancelled\" | \"completed\" | \"failed\" | \"orphaned\"} BackgroundJobTerminalStatus */\n/** @typedef {BackgroundJobActiveStatus | BackgroundJobTerminalStatus} BackgroundJobStatus */\n/** @typedef {\"exit\" | \"process-error\" | \"ipc-send\"} PooledRunnerFailureOrigin */\n/** @typedef {\"starting\" | \"running\" | \"retiring\"} PooledRunnerLifecycleState */\n/** @typedef {\"parent_retire_drained\" | \"job_timeout\" | \"worker_stop\" | \"signal_sigterm\" | \"signal_sigint\" | \"signal_sigkill\" | \"signal_other\" | \"ipc_disconnect\" | \"process_error\" | \"unexpected_exit\"} PooledChildShutdownReason */\n/**\n * @deprecated Use PooledChildShutdownReason for exact shutdown provenance.\n * @typedef {\"unexpected\" | \"job-timeout\" | \"worker-shutdown-timeout\"} PooledRunnerTerminationReason\n */\n/** @typedef {\"running\" | \"retiring\" | \"stopping\"} BackgroundJobsWorkerLifecycleState */\n/**\n * Exact durable handoff ownership carried by an executing job when it produces\n * follow-up work.\n * @typedef {object} BackgroundJobProducerProof\n * @property {string} jobId - Producing job id.\n * @property {string} handoffId - Producing handoff lease id.\n * @property {string} workerId - Worker identity persisted with the handoff.\n * @property {number} handedOffAtMs - Durable handoff timestamp.\n */\n/**\n * @typedef {object} PooledRunnerActiveJob\n * @property {string | null} handoffId - Durable handoff lease id.\n * @property {number | null} handedOffAtMs - Durable handoff timestamp.\n * @property {string} jobId - Durable background job id.\n * @property {string} jobName - Registered job class name.\n * @property {string} workerId - Worker identity persisted with the handoff.\n */\n/**\n * One process-failure snapshot shared by every job lost with a pooled child.\n * @typedef {object} PooledRunnerFailure\n * @property {PooledRunnerActiveJob[]} activeJobs - Jobs that were in flight when the child failed, ordered by job id.\n * @property {string | null} childInstanceId - Stable pooled-child identity when its startup or shutdown observation arrived.\n * @property {number | null} exitCode - Child exit code, or null for signal/process errors.\n * @property {string | null} generationId - Release generation identity, or null in legacy mode.\n * @property {string[]} inflightJobIds - Bounded job ids in flight when failure handling started.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {boolean | null} oomKilled - False when the observed exit rules OOM out; null when an unexpected SIGKILL cannot be distinguished from an OOM kill without supervisor/kernel evidence.\n * @property {PooledRunnerFailureOrigin} origin - Worker observation that initiated failure handling.\n * @property {number} runnerAgeMs - Child age when failure handling started.\n * @property {number} runnerCreatedAtMs - Child creation timestamp.\n * @property {boolean} runnerDetached - Whether the runner owned a detached process group.\n * @property {number} runnerJobsRun - Previously acknowledged jobs handled by the child.\n * @property {PooledRunnerLifecycleState} runnerLifecycle - Child lifecycle immediately before recovery.\n * @property {number | null} runnerPid - Child process id when available.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Child termination signal when available.\n * @property {number | null} shutdownObservedAtMs - Time the child or parent observed shutdown beginning.\n * @property {number | null} shutdownRequestedAtMs - Exact parent request timestamp, or null for external/unrequested shutdown.\n * @property {PooledChildShutdownReason} shutdownReason - Exact recorded parent request or observed child shutdown cause.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} shutdownSignal - Parent-requested or child-observed shutdown signal when available.\n * @property {PooledRunnerTerminationReason} terminationReason - Deprecated compatibility category; use shutdownReason for exact provenance.\n * @property {string | null} timeoutJobId - Job whose timeout initiated child termination, or null.\n * @property {string} workerId - Stable generation-qualified worker id.\n * @property {BackgroundJobsWorkerLifecycleState} workerLifecycle - Parent worker lifecycle immediately before recovery.\n * @property {number} workerPid - Parent worker process id.\n */\n/**\n * Best-effort observation sent before a pooled child closes its resources.\n * @typedef {object} PooledChildShutdownObservation\n * @property {string} childInstanceId - Stable pooled-child identity.\n * @property {string[]} inflightJobIds - Bounded in-flight durable job ids.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {PooledChildShutdownReason} reason - Shutdown reason observed by the child.\n * @property {number} shutdownObservedAtMs - Child observation timestamp.\n * @property {number | null} shutdownRequestedAtMs - Parent request timestamp when supplied over IPC.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Requested or observed signal when available.\n */\n/**\n * @typedef {object} LocalBackgroundJobsClock\n * @property {() => number} now - Current epoch milliseconds.\n * @property {(callback: () => void, delayMs: number) => ReturnType<typeof setTimeout> | number} setTimeout - Arms a timer.\n * @property {(timerId: ReturnType<typeof setTimeout> | number) => void} clearTimeout - Clears a timer.\n */\n/**\n * @typedef {object} ResolvedBackgroundJobConcurrency\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} maxConcurrency - Positive cap.\n * @property {boolean} queueDerived - Whether queue configuration owns the cap.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyRepair\n * @property {number} activeCount - Exact handed-off job count persisted by the repair.\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} previousActiveCount - Persisted count replaced by the repair.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyReconciliation\n * @property {number} candidateCount - Snapshot mismatches rechecked under their counter locks.\n * @property {number} checkedCount - Active or nonzero durable counters compared in the initial snapshot.\n * @property {number} repairedCount - Counters whose persisted values were changed.\n * @property {BackgroundJobConcurrencyRepair[]} repairs - Bounded deterministic sample of applied repairs.\n * @property {number} repairsTruncatedCount - Applied repairs omitted from the sample.\n */\n/**\n * @typedef {object} PreparedLocalBackgroundJob\n * @property {string} argsDigest - Fixed-width digest of the serialized arguments.\n * @property {string} argsJson - Serialized arguments.\n * @property {ResolvedBackgroundJobConcurrency | null} concurrency - Resolved concurrency.\n * @property {number} createdAtMs - Creation timestamp.\n * @property {\"inline\"} executionMode - Local in-process execution mode.\n * @property {string} jobId - Durable id.\n * @property {string} jobName - Registered name.\n * @property {number} maxRetries - Retry cap.\n * @property {string} queue - Queue name.\n * @property {number} scheduledAtMs - Eligibility timestamp.\n */\n/**\n * @typedef {object} BackgroundJobsHealth\n * @property {boolean} ready - Whether the adapter can accept and process work.\n */\n/**\n * @typedef {object} BackgroundJobsProducer\n * @property {(args: {jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}) => Promise<string>} enqueue - Enqueues a job.\n * @property {(args: {scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}) => Promise<BackgroundJobReplacementResult>} replaceScheduled - Replaces a stable schedule.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobCancellationResult>} cancelScheduled - Cancels a stable schedule.\n * @property {(args: {scheduleKey: string, includeLatestTerminal?: boolean}) => Promise<BackgroundJobScheduledLookupResult>} getScheduledJob - Reads stable schedule ownership and history.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobWakeResult>} wakeScheduled - Expedites a stable schedule owner.\n */\n/**\n * @typedef {object} BackgroundJobHandoff\n * @property {string} handoffId - Unique handoff lease id.\n * @property {number} handedOffAtMs - Time handed to a worker in ms.\n * @property {BackgroundJobRow} [job] - Exact committed job snapshot when the adapter changes dispatch data during the claim.\n */\n/**\n * @typedef {object} BackgroundJobHandoffSnapshot\n * @property {string} jobId - Job holding the lease.\n * @property {string} handoffId - Exact durable lease id.\n * @property {string} workerId - Stable worker id that received the lease.\n * @property {number} handedOffAtMs - Time handed to the worker in ms.\n */\n/**\n * @typedef {object} BackgroundJobHandoffRequest\n * @property {string} jobId - Job to claim.\n * @property {string} [handoffId] - Exact caller-selected lease id. Adapters must persist and return this id when supplied; built-in adapters generate one when omitted for legacy direct callers.\n * @property {string} [workerId] - Worker claiming the job.\n */\n/**\n * @typedef {object} BackgroundJobOptions\n * @property {BackgroundJobExecutionMode} [executionMode] - How the job should run. Node defaults to `\"pooled\"` (a warm, reused local runner process). Browser/Expo local dispatch defaults to and only accepts `\"inline\"`. `\"forked\"` runs a Node job in a fresh `child_process.fork()` child, and `\"spawned\"` in a detached CLI runner.\n * @property {number} [maxRetries] - Max retries for a failed job before it is marked failed.\n * @property {string} [queue] - Queue name. Defaults to `\"default\"`. When the queue has a configured cap in `backgroundJobs.queues`, that cap is enforced cluster-wide.\n * @property {string} [concurrencyKey] - Opaque non-empty key used to share a concurrency cap. Overrides any queue-derived cap.\n * @property {number} [maxConcurrency] - Positive integer cap; must be paired with `concurrencyKey`.\n * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.\n * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.\n * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.\n * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.\n */\n/**\n * @typedef {object} BackgroundJobPayload\n * @property {string} [id] - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} [args] - Serialized job arguments.\n * @property {string} [handoffId] - Unique handoff lease id.\n * @property {string} [workerId] - Worker id handling the job.\n * @property {number} [handedOffAtMs] - Time handed to a worker in ms.\n * @property {BackgroundJobOptions} [options] - Runtime options.\n */\n/**\n * @typedef {object} BackgroundJobContext\n * @property {typeof import(\"./platform-job.js\").default} jobClass - Concrete job class.\n * @property {string} jobName - Registered job name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobOptions} options - Resolved enqueue/runtime options.\n * @property {BackgroundJobPayload} [payload] - Complete persisted runner payload when the job is performing.\n */\n/**\n * @typedef {object} BackgroundJobRow\n * @property {string} id - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobExecutionMode} executionMode - How the job should run.\n * @property {string} queue - Queue name (defaults to `\"default\"`).\n * @property {string | null} scheduleKey - Stable logical schedule key retained for history.\n * @property {number | null} scheduleOrder - Transaction-assigned monotonic ownership order for this schedule key; Node preserves its high-water mark across terminal-history pruning. Null for legacy/non-scheduled rows.\n * @property {BackgroundJobStatus} status - Current job status.\n * @property {number | null} attempts - Failure attempts count.\n * @property {number | null} maxRetries - Max retry attempts.\n * @property {number | null} scheduledAtMs - Next scheduled time in ms.\n * @property {number | null} createdAtMs - Creation time in ms.\n * @property {number | null} handedOffAtMs - Time handed to worker in ms.\n * @property {string | null} handoffId - Unique latest handoff lease id.\n * @property {number | null} completedAtMs - Completion time in ms.\n * @property {number | null} failedAtMs - Failure time in ms.\n * @property {number | null} orphanedAtMs - Orphaned time in ms.\n * @property {string | null} workerId - Worker id handling the job.\n * @property {string | null} lastError - Last failure message.\n * @property {string | null} concurrencyKey - Durable concurrency key.\n * @property {number | null} maxConcurrency - Durable per-key cap.\n * @property {number | null} timeoutMs - Per-job wall-clock timeout override, or null when omitted.\n * @property {number | null} childReceivedAtMs - Epoch ms when the executing pooled child's event loop processed the job message, or null when no runner accepted it yet.\n * @property {number | null} childStartedAtMs - Epoch ms when the job's perform started in the pooled child, or null when it never started.\n * @property {string | null} childInstanceId - Stable identity of the pooled child process that accepted the job, or null.\n * @property {number | null} childPid - OS pid of the pooled child process that accepted the job, or null.\n */\n/**\n * @typedef {\"queued\" | \"handed_off\" | null} BackgroundJobReplacementPreviousStatus\n */\n/**\n * @typedef {object} BackgroundJobReplacementResult\n * @property {string} jobId - Newly queued job id.\n * @property {string | null} previousJobId - Previous active owner's job id.\n * @property {BackgroundJobReplacementPreviousStatus} previousStatus - Previous owner's observed state.\n */\n/**\n * @typedef {\"cancelled\" | \"handed_off\" | \"not_found\"} BackgroundJobCancellationOutcome\n */\n/**\n * @typedef {object} BackgroundJobCancellationResult\n * @property {string | null} jobId - Detached owner's job id, when one was active.\n * @property {BackgroundJobCancellationOutcome} outcome - Truthful best-effort outcome.\n */\n/**\n * @typedef {object} BackgroundJobScheduledLookupResult\n * @property {BackgroundJobRow | null} currentJob - Current queued or handed-off owner.\n * @property {BackgroundJobRow | null} latestTerminalJob - Latest terminal history when requested.\n */\n/**\n * @typedef {\"woken\" | \"already_due\" | \"handed_off\" | \"not_found\"} BackgroundJobWakeOutcome\n */\n/**\n * @typedef {object} BackgroundJobWakeResult\n * @property {string | null} jobId - Current owner's durable job id, when found.\n * @property {BackgroundJobWakeOutcome} outcome - Exact wake outcome.\n */\n/**\n * @typedef {object} BackgroundJobFailureEvent\n * @property {BackgroundJobRow} job - Updated job row after failure handling.\n * @property {ReturnType<typeof JSON.parse>} error - Failure error.\n * @property {number | null} attempts - Updated failure attempts count.\n * @property {boolean} terminal - Whether this failure ended the job.\n * @property {boolean} willRetry - Whether the job was returned to the queue.\n * @property {string | undefined} handoffId - Handoff lease id from the worker report.\n * @property {number | undefined} handedOffAtMs - Handoff timestamp from the worker report.\n * @property {string | undefined} workerId - Worker id from the worker report.\n * @property {PooledRunnerFailure | undefined} runnerFailure - Shared pooled-child process failure provenance.\n */\n/**\n * @typedef {\"worker\" | \"client\" | \"reporter\"} BackgroundJobSocketRole\n */\n/**\n * @typedef {{type: \"hello\", role: BackgroundJobSocketRole, generationId?: string, supportsHandoffIdReporting?: boolean, supportsHeartbeat?: boolean, supportsPooled?: boolean, workerId?: string}} BackgroundJobHelloMessage\n * @typedef {{type: \"generation-accepted\", generationId: string, lifecycleState: BackgroundJobsGenerationLifecycleState}} BackgroundJobGenerationAcceptedMessage\n * @typedef {{type: \"generation-rejected\", reason: BackgroundJobsGenerationRejectionReason}} BackgroundJobGenerationRejectedMessage\n * @typedef {{type: \"ready\", acceptsForked?: boolean, acceptsInline?: boolean, acceptsPooled?: boolean, acceptsSpawned?: boolean, availablePooledSlots?: number}} BackgroundJobReadyMessage\n * @typedef {{type: \"draining\"}} BackgroundJobDrainingMessage\n * @typedef {{type: \"heartbeat\", workerId?: string}} BackgroundJobHeartbeatMessage\n * @typedef {{type: \"enqueue\", jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}} BackgroundJobEnqueueMessage\n * @typedef {{type: \"enqueued\", jobId: string}} BackgroundJobEnqueuedMessage\n * @typedef {{type: \"enqueue-error\", error?: string}} BackgroundJobEnqueueErrorMessage\n * @typedef {{type: \"replace-scheduled\", scheduleKey: string, jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}} BackgroundJobReplaceScheduledMessage\n * @typedef {{type: \"schedule-replaced\", jobId: string, previousJobId: string | null, previousStatus: BackgroundJobReplacementPreviousStatus}} BackgroundJobScheduleReplacedMessage\n * @typedef {{type: \"replace-scheduled-error\", error?: string}} BackgroundJobReplaceScheduledErrorMessage\n * @typedef {{type: \"cancel-scheduled\", scheduleKey: string}} BackgroundJobCancelScheduledMessage\n * @typedef {{type: \"schedule-cancelled\", jobId: string | null, outcome: BackgroundJobCancellationOutcome}} BackgroundJobScheduleCancelledMessage\n * @typedef {{type: \"cancel-scheduled-error\", error?: string}} BackgroundJobCancelScheduledErrorMessage\n * @typedef {{type: \"get-scheduled-job\", scheduleKey: string, includeLatestTerminal?: boolean}} BackgroundJobGetScheduledMessage\n * @typedef {{type: \"scheduled-job\", currentJob: BackgroundJobRow | null, latestTerminalJob: BackgroundJobRow | null}} BackgroundJobScheduledMessage\n * @typedef {{type: \"get-scheduled-job-error\", error?: string}} BackgroundJobGetScheduledErrorMessage\n * @typedef {{type: \"wake-scheduled\", scheduleKey: string}} BackgroundJobWakeScheduledMessage\n * @typedef {{type: \"schedule-woken\", jobId: string | null, outcome: BackgroundJobWakeOutcome}} BackgroundJobScheduleWokenMessage\n * @typedef {{type: \"wake-scheduled-error\", error?: string}} BackgroundJobWakeScheduledErrorMessage\n * @typedef {{type: \"job\", payload: BackgroundJobPayload}} BackgroundJobJobMessage\n * @typedef {{type: \"job-accepted\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number}} BackgroundJobAcceptedMessage\n * @typedef {{type: \"job-complete\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobCompleteMessage\n * @typedef {{type: \"job-failed\", jobId: string, error?: ReturnType<typeof JSON.parse>, handoffId?: string, workerId?: string, handedOffAtMs?: number, runnerFailure?: PooledRunnerFailure}} BackgroundJobFailedMessage\n * @typedef {{type: \"job-reschedule\", jobId: string, delayMs: number, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobRescheduleMessage\n * @typedef {{type: \"job-updated\", jobId: string}} BackgroundJobUpdatedMessage\n * @typedef {{type: \"job-update-error\", jobId: string, error?: string}} BackgroundJobUpdateErrorMessage\n */\n/**\n * @typedef {BackgroundJobHelloMessage | BackgroundJobGenerationAcceptedMessage | BackgroundJobGenerationRejectedMessage | BackgroundJobReadyMessage | BackgroundJobDrainingMessage | BackgroundJobHeartbeatMessage | BackgroundJobEnqueueMessage | BackgroundJobEnqueuedMessage | BackgroundJobEnqueueErrorMessage | BackgroundJobReplaceScheduledMessage | BackgroundJobScheduleReplacedMessage | BackgroundJobReplaceScheduledErrorMessage | BackgroundJobCancelScheduledMessage | BackgroundJobScheduleCancelledMessage | BackgroundJobCancelScheduledErrorMessage | BackgroundJobGetScheduledMessage | BackgroundJobScheduledMessage | BackgroundJobGetScheduledErrorMessage | BackgroundJobWakeScheduledMessage | BackgroundJobScheduleWokenMessage | BackgroundJobWakeScheduledErrorMessage | BackgroundJobJobMessage | BackgroundJobAcceptedMessage | BackgroundJobCompleteMessage | BackgroundJobFailedMessage | BackgroundJobRescheduleMessage | BackgroundJobUpdatedMessage | BackgroundJobUpdateErrorMessage} BackgroundJobSocketMessage\n */\n\nexport const nothing = {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/background-jobs/types.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;GAEG;AACH,yFAAyF;AACzF,iIAAiI;AACjI,6NAA6N;AAC7N,mEAAmE;AACnE,+FAA+F;AAC/F,6FAA6F;AAC7F,iFAAiF;AACjF,gFAAgF;AAChF,qOAAqO;AACrO;;;GAGG;AACH,wFAAwF;AACxF;;;;;;;;GAQG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;;;;;;;;;GAUG;AACH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;GAKG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;GAYG;AACH;;;GAGG;AACH;;;;;;;GAOG;AACH;;;;;GAKG;AACH;;;;;;GAMG;AACH;;;;;GAKG;AACH;;;;;;;;;;;GAWG;AACH;;;;;;;;;GASG;AACH;;;;;;;GAOG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;GAEG;AACH;;;;;GAKG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;GAIG;AACH;;GAEG;AACH;;;;GAIG;AACH;;;;;;;;;;;GAWG;AACH;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;GAEG;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAE,CAAA","sourcesContent":["// @ts-check\n\n/**\n * @typedef {\"inline\" | \"forked\" | \"pooled\" | \"spawned\"} BackgroundJobExecutionMode\n */\n/** @typedef {\"candidate\" | \"active\" | \"retired\"} BackgroundJobsGenerationInitialState */\n/** @typedef {\"starting\" | \"candidate\" | \"active\" | \"retiring\" | \"retired\" | \"stopped\"} BackgroundJobsGenerationLifecycleState */\n/** @typedef {\"missing-generation\" | \"unexpected-generation\" | \"malformed-generation\" | \"generation-mismatch\" | \"worker-admission-retired\" | \"worker-has-no-recoverable-handoffs\"} BackgroundJobsGenerationRejectionReason */\n/** @typedef {\"queued\" | \"handed_off\"} BackgroundJobActiveStatus */\n/** @typedef {\"cancelled\" | \"completed\" | \"failed\" | \"orphaned\"} BackgroundJobTerminalStatus */\n/** @typedef {BackgroundJobActiveStatus | BackgroundJobTerminalStatus} BackgroundJobStatus */\n/** @typedef {\"exit\" | \"process-error\" | \"ipc-send\"} PooledRunnerFailureOrigin */\n/** @typedef {\"starting\" | \"running\" | \"retiring\"} PooledRunnerLifecycleState */\n/** @typedef {\"parent_retire_drained\" | \"job_timeout\" | \"worker_stop\" | \"signal_sigterm\" | \"signal_sigint\" | \"signal_sigkill\" | \"signal_other\" | \"ipc_disconnect\" | \"process_error\" | \"unexpected_exit\"} PooledChildShutdownReason */\n/**\n * @deprecated Use PooledChildShutdownReason for exact shutdown provenance.\n * @typedef {\"unexpected\" | \"job-timeout\" | \"worker-shutdown-timeout\"} PooledRunnerTerminationReason\n */\n/** @typedef {\"running\" | \"retiring\" | \"stopping\"} BackgroundJobsWorkerLifecycleState */\n/**\n * Exact durable handoff ownership carried by an executing job when it produces\n * follow-up work.\n * @typedef {object} BackgroundJobProducerProof\n * @property {string} jobId - Producing job id.\n * @property {string} handoffId - Producing handoff lease id.\n * @property {string} workerId - Worker identity persisted with the handoff.\n * @property {number} handedOffAtMs - Durable handoff timestamp.\n */\n/**\n * @typedef {object} PooledRunnerActiveJob\n * @property {string | null} handoffId - Durable handoff lease id.\n * @property {number | null} handedOffAtMs - Durable handoff timestamp.\n * @property {string} jobId - Durable background job id.\n * @property {string} jobName - Registered job class name.\n * @property {string} workerId - Worker identity persisted with the handoff.\n */\n/**\n * One process-failure snapshot shared by every job lost with a pooled child.\n * @typedef {object} PooledRunnerFailure\n * @property {PooledRunnerActiveJob[]} activeJobs - Jobs that were in flight when the child failed, ordered by job id.\n * @property {string | null} childInstanceId - Stable pooled-child identity when its startup or shutdown observation arrived.\n * @property {number | null} exitCode - Child exit code, or null for signal/process errors.\n * @property {string | null} generationId - Release generation identity, or null in legacy mode.\n * @property {string[]} inflightJobIds - Bounded job ids in flight when failure handling started.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {boolean | null} oomKilled - False when the observed exit rules OOM out; null when an unexpected SIGKILL cannot be distinguished from an OOM kill without supervisor/kernel evidence.\n * @property {PooledRunnerFailureOrigin} origin - Worker observation that initiated failure handling.\n * @property {number} runnerAgeMs - Child age when failure handling started.\n * @property {number} runnerCreatedAtMs - Child creation timestamp.\n * @property {boolean} runnerDetached - Whether the runner owned a detached process group.\n * @property {number} runnerJobsRun - Previously acknowledged jobs handled by the child.\n * @property {PooledRunnerLifecycleState} runnerLifecycle - Child lifecycle immediately before recovery.\n * @property {number | null} runnerPid - Child process id when available.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Child termination signal when available.\n * @property {number | null} shutdownObservedAtMs - Time the child or parent observed shutdown beginning.\n * @property {number | null} shutdownRequestedAtMs - Exact parent request timestamp, or null for external/unrequested shutdown.\n * @property {PooledChildShutdownReason} shutdownReason - Exact recorded parent request or observed child shutdown cause.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} shutdownSignal - Parent-requested or child-observed shutdown signal when available.\n * @property {PooledRunnerTerminationReason} terminationReason - Deprecated compatibility category; use shutdownReason for exact provenance.\n * @property {string | null} timeoutJobId - Job whose timeout initiated child termination, or null.\n * @property {string} workerId - Stable generation-qualified worker id.\n * @property {BackgroundJobsWorkerLifecycleState} workerLifecycle - Parent worker lifecycle immediately before recovery.\n * @property {number} workerPid - Parent worker process id.\n */\n/**\n * Best-effort observation sent before a pooled child closes its resources.\n * @typedef {object} PooledChildShutdownObservation\n * @property {string} childInstanceId - Stable pooled-child identity.\n * @property {string[]} inflightJobIds - Bounded in-flight durable job ids.\n * @property {number} inflightJobIdsTruncatedCount - In-flight ids omitted from the bounded snapshot.\n * @property {PooledChildShutdownReason} reason - Shutdown reason observed by the child.\n * @property {number} shutdownObservedAtMs - Child observation timestamp.\n * @property {number | null} shutdownRequestedAtMs - Parent request timestamp when supplied over IPC.\n * @property {import(\"node:child_process\").ChildProcess[\"signalCode\"]} signal - Requested or observed signal when available.\n */\n/**\n * Bounded pooled-child memory observation sent over the child IPC channel.\n * The pooled child's stdio is ignored by the worker fork, so this observation\n * (sent periodically while jobs run, plus on demand) is how a memory problem\n * in a running child names itself. `heapStatistics` and `memoryUsage`\n * distinguish V8-heap growth from external/array-buffer (native resource)\n * growth; `activeJobIds` ties the sample to the work that was in flight.\n * @typedef {object} PooledChildMemoryObservation\n * @property {string[]} activeJobIds - In-flight job ids, bounded.\n * @property {number} activeJobIdsTruncatedCount - In-flight job ids omitted by the bound.\n * @property {string} childInstanceId - Stable identity reported by the child.\n * @property {number} childPid - Child process id.\n * @property {number} childUptimeMs - Child process uptime in ms.\n * @property {ReturnType<typeof import(\"node:v8\").getHeapStatistics>} heapStatistics - V8 heap-stat breakdown at the sample.\n * @property {number} jobCount - In-flight job count.\n * @property {ReturnType<typeof import(\"node:process\").memoryUsage>} memoryUsage - Process memory breakdown at the sample.\n * @property {number} observedAtMs - Epoch ms the child sampled.\n * @property {number} rssBytes - Resident set size in bytes at the sample.\n * @property {\"pooled-child-memory\"} type - Discriminator.\n * @property {number} uptimeMs - Process uptime in ms.\n */\n/**\n * @typedef {object} LocalBackgroundJobsClock\n * @property {() => number} now - Current epoch milliseconds.\n * @property {(callback: () => void, delayMs: number) => ReturnType<typeof setTimeout> | number} setTimeout - Arms a timer.\n * @property {(timerId: ReturnType<typeof setTimeout> | number) => void} clearTimeout - Clears a timer.\n */\n/**\n * @typedef {object} ResolvedBackgroundJobConcurrency\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} maxConcurrency - Positive cap.\n * @property {boolean} queueDerived - Whether queue configuration owns the cap.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyRepair\n * @property {number} activeCount - Exact handed-off job count persisted by the repair.\n * @property {string} concurrencyKey - Durable cap identity.\n * @property {number} previousActiveCount - Persisted count replaced by the repair.\n */\n/**\n * @typedef {object} BackgroundJobConcurrencyReconciliation\n * @property {number} candidateCount - Snapshot mismatches rechecked under their counter locks.\n * @property {number} checkedCount - Active or nonzero durable counters compared in the initial snapshot.\n * @property {number} repairedCount - Counters whose persisted values were changed.\n * @property {BackgroundJobConcurrencyRepair[]} repairs - Bounded deterministic sample of applied repairs.\n * @property {number} repairsTruncatedCount - Applied repairs omitted from the sample.\n */\n/**\n * @typedef {object} PreparedLocalBackgroundJob\n * @property {string} argsDigest - Fixed-width digest of the serialized arguments.\n * @property {string} argsJson - Serialized arguments.\n * @property {ResolvedBackgroundJobConcurrency | null} concurrency - Resolved concurrency.\n * @property {number} createdAtMs - Creation timestamp.\n * @property {\"inline\"} executionMode - Local in-process execution mode.\n * @property {string} jobId - Durable id.\n * @property {string} jobName - Registered name.\n * @property {number} maxRetries - Retry cap.\n * @property {string} queue - Queue name.\n * @property {number} scheduledAtMs - Eligibility timestamp.\n */\n/**\n * @typedef {object} BackgroundJobsHealth\n * @property {boolean} ready - Whether the adapter can accept and process work.\n */\n/**\n * @typedef {object} BackgroundJobsProducer\n * @property {(args: {jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}) => Promise<string>} enqueue - Enqueues a job.\n * @property {(args: {scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}) => Promise<BackgroundJobReplacementResult>} replaceScheduled - Replaces a stable schedule.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobCancellationResult>} cancelScheduled - Cancels a stable schedule.\n * @property {(args: {scheduleKey: string, includeLatestTerminal?: boolean}) => Promise<BackgroundJobScheduledLookupResult>} getScheduledJob - Reads stable schedule ownership and history.\n * @property {(args: {scheduleKey: string}) => Promise<BackgroundJobWakeResult>} wakeScheduled - Expedites a stable schedule owner.\n */\n/**\n * @typedef {object} BackgroundJobHandoff\n * @property {string} handoffId - Unique handoff lease id.\n * @property {number} handedOffAtMs - Time handed to a worker in ms.\n * @property {BackgroundJobRow} [job] - Exact committed job snapshot when the adapter changes dispatch data during the claim.\n */\n/**\n * @typedef {object} BackgroundJobHandoffSnapshot\n * @property {string} jobId - Job holding the lease.\n * @property {string} handoffId - Exact durable lease id.\n * @property {string} workerId - Stable worker id that received the lease.\n * @property {number} handedOffAtMs - Time handed to the worker in ms.\n */\n/**\n * @typedef {object} BackgroundJobHandoffRequest\n * @property {string} jobId - Job to claim.\n * @property {string} [handoffId] - Exact caller-selected lease id. Adapters must persist and return this id when supplied; built-in adapters generate one when omitted for legacy direct callers.\n * @property {string} [workerId] - Worker claiming the job.\n */\n/**\n * @typedef {object} BackgroundJobOptions\n * @property {BackgroundJobExecutionMode} [executionMode] - How the job should run. Node defaults to `\"pooled\"` (a warm, reused local runner process). Browser/Expo local dispatch defaults to and only accepts `\"inline\"`. `\"forked\"` runs a Node job in a fresh `child_process.fork()` child, and `\"spawned\"` in a detached CLI runner.\n * @property {number} [maxRetries] - Max retries for a failed job before it is marked failed.\n * @property {string} [queue] - Queue name. Defaults to `\"default\"`. When the queue has a configured cap in `backgroundJobs.queues`, that cap is enforced cluster-wide.\n * @property {string} [concurrencyKey] - Opaque non-empty key used to share a concurrency cap. Overrides any queue-derived cap.\n * @property {number} [maxConcurrency] - Positive integer cap; must be paired with `concurrencyKey`.\n * @property {boolean} [deduplicateWhileQueued] - When true, skip the enqueue if an identical still-queued job (same job name, args and queue) is scheduled no later than this enqueue, returning the earliest matching job's id. A future retry does not suppress earlier work. Deduplication is independent of `concurrencyKey`, so the job keeps its normal (e.g. queue-derived) concurrency cap. Keeps an interval-scheduled recurring job (e.g. retention pruning) from piling up redundant queued rows when it runs slower than its interval or no worker is free.\n * @property {string} [idempotencyKey] - Durable enqueue identity scoped to the resolved job class name and queue. Exact replay returns the original job id across every state and after job pruning; reuse with different canonical arguments or behavior-affecting options fails. Ownership is independent of `deduplicateWhileQueued` and is retained until an explicit future retention policy removes it.\n * @property {number} [scheduledAtMs] - Epoch timestamp in milliseconds when the job becomes eligible for dispatch. Defaults to enqueue time.\n * @property {number} [timeoutMs] - Per-job wall-clock timeout for forked and pooled execution. A positive integer up to 2,147,483,647 overrides the worker-level `jobTimeoutMs`; a non-positive finite value disables the timeout for this job.\n */\n/**\n * @typedef {object} BackgroundJobPayload\n * @property {string} [id] - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} [args] - Serialized job arguments.\n * @property {string} [handoffId] - Unique handoff lease id.\n * @property {string} [workerId] - Worker id handling the job.\n * @property {number} [handedOffAtMs] - Time handed to a worker in ms.\n * @property {BackgroundJobOptions} [options] - Runtime options.\n */\n/**\n * @typedef {object} BackgroundJobContext\n * @property {typeof import(\"./platform-job.js\").default} jobClass - Concrete job class.\n * @property {string} jobName - Registered job name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobOptions} options - Resolved enqueue/runtime options.\n * @property {BackgroundJobPayload} [payload] - Complete persisted runner payload when the job is performing.\n */\n/**\n * @typedef {object} BackgroundJobRow\n * @property {string} id - Job id.\n * @property {string} jobName - Job class name.\n * @property {Array<ReturnType<typeof JSON.parse>>} args - Serialized job arguments.\n * @property {BackgroundJobExecutionMode} executionMode - How the job should run.\n * @property {string} queue - Queue name (defaults to `\"default\"`).\n * @property {string | null} scheduleKey - Stable logical schedule key retained for history.\n * @property {number | null} scheduleOrder - Transaction-assigned monotonic ownership order for this schedule key; Node preserves its high-water mark across terminal-history pruning. Null for legacy/non-scheduled rows.\n * @property {BackgroundJobStatus} status - Current job status.\n * @property {number | null} attempts - Failure attempts count.\n * @property {number | null} maxRetries - Max retry attempts.\n * @property {number | null} scheduledAtMs - Next scheduled time in ms.\n * @property {number | null} createdAtMs - Creation time in ms.\n * @property {number | null} handedOffAtMs - Time handed to worker in ms.\n * @property {string | null} handoffId - Unique latest handoff lease id.\n * @property {number | null} completedAtMs - Completion time in ms.\n * @property {number | null} failedAtMs - Failure time in ms.\n * @property {number | null} orphanedAtMs - Orphaned time in ms.\n * @property {string | null} workerId - Worker id handling the job.\n * @property {string | null} lastError - Last failure message.\n * @property {string | null} concurrencyKey - Durable concurrency key.\n * @property {number | null} maxConcurrency - Durable per-key cap.\n * @property {number | null} timeoutMs - Per-job wall-clock timeout override, or null when omitted.\n * @property {number | null} childReceivedAtMs - Epoch ms when the executing pooled child's event loop processed the job message, or null when no runner accepted it yet.\n * @property {number | null} childStartedAtMs - Epoch ms when the job's perform started in the pooled child, or null when it never started.\n * @property {string | null} childInstanceId - Stable identity of the pooled child process that accepted the job, or null.\n * @property {number | null} childPid - OS pid of the pooled child process that accepted the job, or null.\n */\n/**\n * @typedef {\"queued\" | \"handed_off\" | null} BackgroundJobReplacementPreviousStatus\n */\n/**\n * @typedef {object} BackgroundJobReplacementResult\n * @property {string} jobId - Newly queued job id.\n * @property {string | null} previousJobId - Previous active owner's job id.\n * @property {BackgroundJobReplacementPreviousStatus} previousStatus - Previous owner's observed state.\n */\n/**\n * @typedef {\"cancelled\" | \"handed_off\" | \"not_found\"} BackgroundJobCancellationOutcome\n */\n/**\n * @typedef {object} BackgroundJobCancellationResult\n * @property {string | null} jobId - Detached owner's job id, when one was active.\n * @property {BackgroundJobCancellationOutcome} outcome - Truthful best-effort outcome.\n */\n/**\n * @typedef {object} BackgroundJobScheduledLookupResult\n * @property {BackgroundJobRow | null} currentJob - Current queued or handed-off owner.\n * @property {BackgroundJobRow | null} latestTerminalJob - Latest terminal history when requested.\n */\n/**\n * @typedef {\"woken\" | \"already_due\" | \"handed_off\" | \"not_found\"} BackgroundJobWakeOutcome\n */\n/**\n * @typedef {object} BackgroundJobWakeResult\n * @property {string | null} jobId - Current owner's durable job id, when found.\n * @property {BackgroundJobWakeOutcome} outcome - Exact wake outcome.\n */\n/**\n * @typedef {object} BackgroundJobFailureEvent\n * @property {BackgroundJobRow} job - Updated job row after failure handling.\n * @property {ReturnType<typeof JSON.parse>} error - Failure error.\n * @property {number | null} attempts - Updated failure attempts count.\n * @property {boolean} terminal - Whether this failure ended the job.\n * @property {boolean} willRetry - Whether the job was returned to the queue.\n * @property {string | undefined} handoffId - Handoff lease id from the worker report.\n * @property {number | undefined} handedOffAtMs - Handoff timestamp from the worker report.\n * @property {string | undefined} workerId - Worker id from the worker report.\n * @property {PooledRunnerFailure | undefined} runnerFailure - Shared pooled-child process failure provenance.\n */\n/**\n * @typedef {\"worker\" | \"client\" | \"reporter\"} BackgroundJobSocketRole\n */\n/**\n * @typedef {{type: \"hello\", role: BackgroundJobSocketRole, generationId?: string, supportsHandoffIdReporting?: boolean, supportsHeartbeat?: boolean, supportsPooled?: boolean, workerId?: string}} BackgroundJobHelloMessage\n * @typedef {{type: \"generation-accepted\", generationId: string, lifecycleState: BackgroundJobsGenerationLifecycleState}} BackgroundJobGenerationAcceptedMessage\n * @typedef {{type: \"generation-rejected\", reason: BackgroundJobsGenerationRejectionReason}} BackgroundJobGenerationRejectedMessage\n * @typedef {{type: \"ready\", acceptsForked?: boolean, acceptsInline?: boolean, acceptsPooled?: boolean, acceptsSpawned?: boolean, availablePooledSlots?: number}} BackgroundJobReadyMessage\n * @typedef {{type: \"draining\"}} BackgroundJobDrainingMessage\n * @typedef {{type: \"heartbeat\", workerId?: string}} BackgroundJobHeartbeatMessage\n * @typedef {{type: \"enqueue\", jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions, producerInvocationId?: string, producerProof?: BackgroundJobProducerProof}} BackgroundJobEnqueueMessage\n * @typedef {{type: \"enqueued\", jobId: string}} BackgroundJobEnqueuedMessage\n * @typedef {{type: \"enqueue-error\", error?: string}} BackgroundJobEnqueueErrorMessage\n * @typedef {{type: \"replace-scheduled\", scheduleKey: string, jobName: string, args?: Array<ReturnType<typeof JSON.parse>>, options?: BackgroundJobOptions}} BackgroundJobReplaceScheduledMessage\n * @typedef {{type: \"schedule-replaced\", jobId: string, previousJobId: string | null, previousStatus: BackgroundJobReplacementPreviousStatus}} BackgroundJobScheduleReplacedMessage\n * @typedef {{type: \"replace-scheduled-error\", error?: string}} BackgroundJobReplaceScheduledErrorMessage\n * @typedef {{type: \"cancel-scheduled\", scheduleKey: string}} BackgroundJobCancelScheduledMessage\n * @typedef {{type: \"schedule-cancelled\", jobId: string | null, outcome: BackgroundJobCancellationOutcome}} BackgroundJobScheduleCancelledMessage\n * @typedef {{type: \"cancel-scheduled-error\", error?: string}} BackgroundJobCancelScheduledErrorMessage\n * @typedef {{type: \"get-scheduled-job\", scheduleKey: string, includeLatestTerminal?: boolean}} BackgroundJobGetScheduledMessage\n * @typedef {{type: \"scheduled-job\", currentJob: BackgroundJobRow | null, latestTerminalJob: BackgroundJobRow | null}} BackgroundJobScheduledMessage\n * @typedef {{type: \"get-scheduled-job-error\", error?: string}} BackgroundJobGetScheduledErrorMessage\n * @typedef {{type: \"wake-scheduled\", scheduleKey: string}} BackgroundJobWakeScheduledMessage\n * @typedef {{type: \"schedule-woken\", jobId: string | null, outcome: BackgroundJobWakeOutcome}} BackgroundJobScheduleWokenMessage\n * @typedef {{type: \"wake-scheduled-error\", error?: string}} BackgroundJobWakeScheduledErrorMessage\n * @typedef {{type: \"job\", payload: BackgroundJobPayload}} BackgroundJobJobMessage\n * @typedef {{type: \"job-accepted\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number}} BackgroundJobAcceptedMessage\n * @typedef {{type: \"job-complete\", jobId: string, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobCompleteMessage\n * @typedef {{type: \"job-failed\", jobId: string, error?: ReturnType<typeof JSON.parse>, handoffId?: string, workerId?: string, handedOffAtMs?: number, runnerFailure?: PooledRunnerFailure}} BackgroundJobFailedMessage\n * @typedef {{type: \"job-reschedule\", jobId: string, delayMs: number, handoffId?: string, workerId?: string, handedOffAtMs?: number}} BackgroundJobRescheduleMessage\n * @typedef {{type: \"job-updated\", jobId: string}} BackgroundJobUpdatedMessage\n * @typedef {{type: \"job-update-error\", jobId: string, error?: string}} BackgroundJobUpdateErrorMessage\n */\n/**\n * @typedef {BackgroundJobHelloMessage | BackgroundJobGenerationAcceptedMessage | BackgroundJobGenerationRejectedMessage | BackgroundJobReadyMessage | BackgroundJobDrainingMessage | BackgroundJobHeartbeatMessage | BackgroundJobEnqueueMessage | BackgroundJobEnqueuedMessage | BackgroundJobEnqueueErrorMessage | BackgroundJobReplaceScheduledMessage | BackgroundJobScheduleReplacedMessage | BackgroundJobReplaceScheduledErrorMessage | BackgroundJobCancelScheduledMessage | BackgroundJobScheduleCancelledMessage | BackgroundJobCancelScheduledErrorMessage | BackgroundJobGetScheduledMessage | BackgroundJobScheduledMessage | BackgroundJobGetScheduledErrorMessage | BackgroundJobWakeScheduledMessage | BackgroundJobScheduleWokenMessage | BackgroundJobWakeScheduledErrorMessage | BackgroundJobJobMessage | BackgroundJobAcceptedMessage | BackgroundJobCompleteMessage | BackgroundJobFailedMessage | BackgroundJobRescheduleMessage | BackgroundJobUpdatedMessage | BackgroundJobUpdateErrorMessage} BackgroundJobSocketMessage\n */\n\nexport const nothing = {}\n"]}