velocious 1.0.665 → 1.0.667

package/build/src/background-jobs/job-semantics.js

@@ -6,6 +6,33 @@ export const DEFAULT_BACKGROUND_JOB_QUEUE = "default";
 export const QUEUE_CONCURRENCY_KEY_PREFIX = "queue:";
 /** @type {import("./types.js").BackgroundJobExecutionMode[]} */
 export const BACKGROUND_JOB_EXECUTION_MODES = ["inline", "forked", "pooled", "spawned"];
+/** @type {import("./types.js").BackgroundJobActiveStatus[]} */
+export const BACKGROUND_JOB_ACTIVE_STATUSES = ["queued", "handed_off"];
+/** @type {import("./types.js").BackgroundJobTerminalStatus[]} */
+export const BACKGROUND_JOB_TERMINAL_STATUSES = ["cancelled", "completed", "failed", "orphaned"];
+/** @type {import("./types.js").BackgroundJobStatus[]} */
+export const BACKGROUND_JOB_STATUSES = [...BACKGROUND_JOB_ACTIVE_STATUSES, ...BACKGROUND_JOB_TERMINAL_STATUSES];
+/**
+ * Normalizes persisted or transported job status vocabulary.
+ * @param {string} value - Candidate status.
+ * @returns {import("./types.js").BackgroundJobStatus} - Known status.
+ */
+export function normalizeBackgroundJobStatus(value) {
+    const status = BACKGROUND_JOB_STATUSES.find((candidate) => candidate === value);
+    if (status)
+        return status;
+    throw new Error(`Unknown background job status: ${value}`);
+}
+/**
+ * Validates a stable logical schedule key at every persistence boundary.
+ * @param {string} scheduleKey - Stable schedule key.
+ * @returns {string} - Validated key.
+ */
+export function normalizeBackgroundJobScheduleKey(scheduleKey) {
+    if (typeof scheduleKey === "string" && scheduleKey.length > 0 && scheduleKey.length <= 255)
+        return scheduleKey;
+    throw VelociousError.safe("background job scheduleKey must be a non-empty string of at most 255 characters");
+}
 /**
  * Normalizes a job queue.
  * @param {import("./types.js").BackgroundJobOptions} [options] - Job options.
@@ -122,4 +149,4 @@ export function normalizeBackgroundJobConcurrency({ options = {}, queue, queues
         queueDerived: true
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-semantics.js","sourceRoot":"","sources":["../../../src/background-jobs/job-semantics.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nexport const DEFAULT_BACKGROUND_JOB_EXECUTION_MODE = \"pooled\"\nexport const DEFAULT_BACKGROUND_JOB_MAX_RETRIES = 10\nexport const DEFAULT_BACKGROUND_JOB_QUEUE = \"default\"\nexport const QUEUE_CONCURRENCY_KEY_PREFIX = \"queue:\"\n/** @type {import(\"./types.js\").BackgroundJobExecutionMode[]} */\nexport const BACKGROUND_JOB_EXECUTION_MODES = [\"inline\", \"forked\", \"pooled\", \"spawned\"]\n\n/**\n * Normalizes a job queue.\n * @param {import(\"./types.js\").BackgroundJobOptions} [options] - Job options.\n * @returns {string} - Queue name.\n */\nexport function normalizeBackgroundJobQueue(options) {\n  const queue = options?.queue\n\n  if (typeof queue === \"string\" && queue.trim().length > 0) return queue.trim()\n\n  return DEFAULT_BACKGROUND_JOB_QUEUE\n}\n\n/**\n * Normalizes an explicit execution mode while retaining the Node default.\n * @param {Omit<import(\"./types.js\").BackgroundJobOptions, \"executionMode\"> & {executionMode?: string}} options - Job options.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode} [defaultExecutionMode] - Default mode.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode[]} [supportedExecutionModes] - Modes accepted by the caller.\n * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Execution mode.\n */\nexport function normalizeBackgroundJobExecutionMode(options = {}, defaultExecutionMode = DEFAULT_BACKGROUND_JOB_EXECUTION_MODE, supportedExecutionModes = BACKGROUND_JOB_EXECUTION_MODES) {\n  if (\"forked\" in options) {\n    throw new Error(\"The background job `forked` option was removed; pass `executionMode` (\\\"inline\\\", \\\"forked\\\", \\\"pooled\\\", or \\\"spawned\\\") instead\")\n  }\n\n  const requestedExecutionMode = options.executionMode || defaultExecutionMode\n  /** @type {import(\"./types.js\").BackgroundJobExecutionMode | undefined} */\n  let executionMode\n\n  for (const candidate of BACKGROUND_JOB_EXECUTION_MODES) {\n    if (candidate === requestedExecutionMode) executionMode = candidate\n  }\n\n  if (!executionMode) throw new Error(`Invalid background job executionMode: ${requestedExecutionMode}`)\n\n  if (!supportedExecutionModes.includes(executionMode)) {\n    throw new Error(`Background job executionMode \"${executionMode}\" is not supported by the local background-jobs adapter`)\n  }\n\n  return executionMode\n}\n\n/**\n * Validates and normalizes a retry cap.\n * @param {number | null | undefined} maxRetries - Requested retry cap.\n * @returns {number} - Retry cap.\n */\nexport function normalizeBackgroundJobMaxRetries(maxRetries) {\n  if (typeof maxRetries === \"number\" && Number.isFinite(maxRetries) && maxRetries >= 0) {\n    return Math.floor(maxRetries)\n  }\n\n  return DEFAULT_BACKGROUND_JOB_MAX_RETRIES\n}\n\n/**\n * Validates an enqueue eligibility timestamp.\n * @param {number | undefined} scheduledAtMs - Requested timestamp.\n * @param {number} defaultScheduledAtMs - Default timestamp.\n * @returns {number} - Eligibility timestamp.\n */\nexport function normalizeBackgroundJobScheduledAtMs(scheduledAtMs, defaultScheduledAtMs) {\n  if (scheduledAtMs === undefined) return defaultScheduledAtMs\n  if (Number.isSafeInteger(scheduledAtMs) && scheduledAtMs >= 0) return scheduledAtMs\n\n  throw VelociousError.safe(\"background job scheduledAtMs must be a non-negative safe integer\")\n}\n\n/**\n * Validates a reschedule delay and resolves it at persistence time.\n * @param {number} delayMs - Requested delay.\n * @param {number} nowMs - Persistence timestamp.\n * @returns {number} - New eligibility timestamp.\n */\nexport function rescheduledBackgroundJobAtMs(delayMs, nowMs) {\n  if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n    throw VelociousError.safe(\"background job reschedule delayMs must be a non-negative safe integer\")\n  }\n\n  const scheduledAtMs = nowMs + delayMs\n\n  if (!Number.isSafeInteger(scheduledAtMs)) {\n    throw VelociousError.safe(\"background job reschedule scheduledAtMs must be a safe integer\")\n  }\n\n  return scheduledAtMs\n}\n\n/**\n * Returns the shared failure backoff.\n * @param {number} retryCount - One-based failed attempt count.\n * @returns {number} - Backoff in milliseconds.\n */\nexport function retryDelayMs(retryCount) {\n  const scheduleSeconds = [10, 60, 600, 3600]\n\n  if (retryCount <= scheduleSeconds.length) return scheduleSeconds[retryCount - 1] * 1000\n\n  return (retryCount - 3) * 60 * 60 * 1000\n}\n\n/**\n * Resolves explicit or queue-derived concurrency.\n * @param {object} args - Resolution arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n * @param {string} args.queue - Normalized queue.\n * @param {Record<string, {maxConcurrent?: number, priority?: number}>} args.queues - Queue configuration.\n * @returns {import(\"./types.js\").ResolvedBackgroundJobConcurrency | null} - Concurrency contract.\n */\nexport function normalizeBackgroundJobConcurrency({options = {}, queue, queues}) {\n  const key = options.concurrencyKey\n  const cap = options.maxConcurrency\n\n  if (key !== undefined || cap !== undefined) {\n    if (typeof key !== \"string\" || key.length === 0 || !Number.isInteger(cap) || Number(cap) <= 0) {\n      throw new Error(\"background job concurrencyKey and maxConcurrency must be paired; concurrencyKey must be non-empty and maxConcurrency must be a positive integer\")\n    }\n    if (key.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) {\n      throw new Error(`background job concurrencyKey must not start with the reserved \"${QUEUE_CONCURRENCY_KEY_PREFIX}\" prefix, which is reserved for queue-derived concurrency caps`)\n    }\n\n    return {concurrencyKey: key, maxConcurrency: Number(cap), queueDerived: false}\n  }\n\n  const queueCap = queues[queue]?.maxConcurrent\n\n  if (!Number.isInteger(queueCap) || Number(queueCap) <= 0) return null\n\n  return {\n    concurrencyKey: `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`,\n    maxConcurrency: Number(queueCap),\n    queueDerived: true\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-semantics.js","sourceRoot":"","sources":["../../../src/background-jobs/job-semantics.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\nexport const DEFAULT_BACKGROUND_JOB_EXECUTION_MODE = \"pooled\"\nexport const DEFAULT_BACKGROUND_JOB_MAX_RETRIES = 10\nexport const DEFAULT_BACKGROUND_JOB_QUEUE = \"default\"\nexport const QUEUE_CONCURRENCY_KEY_PREFIX = \"queue:\"\n/** @type {import(\"./types.js\").BackgroundJobExecutionMode[]} */\nexport const BACKGROUND_JOB_EXECUTION_MODES = [\"inline\", \"forked\", \"pooled\", \"spawned\"]\n/** @type {import(\"./types.js\").BackgroundJobActiveStatus[]} */\nexport const BACKGROUND_JOB_ACTIVE_STATUSES = [\"queued\", \"handed_off\"]\n/** @type {import(\"./types.js\").BackgroundJobTerminalStatus[]} */\nexport const BACKGROUND_JOB_TERMINAL_STATUSES = [\"cancelled\", \"completed\", \"failed\", \"orphaned\"]\n/** @type {import(\"./types.js\").BackgroundJobStatus[]} */\nexport const BACKGROUND_JOB_STATUSES = [...BACKGROUND_JOB_ACTIVE_STATUSES, ...BACKGROUND_JOB_TERMINAL_STATUSES]\n\n/**\n * Normalizes persisted or transported job status vocabulary.\n * @param {string} value - Candidate status.\n * @returns {import(\"./types.js\").BackgroundJobStatus} - Known status.\n */\nexport function normalizeBackgroundJobStatus(value) {\n  const status = BACKGROUND_JOB_STATUSES.find((candidate) => candidate === value)\n\n  if (status) return status\n\n  throw new Error(`Unknown background job status: ${value}`)\n}\n\n/**\n * Validates a stable logical schedule key at every persistence boundary.\n * @param {string} scheduleKey - Stable schedule key.\n * @returns {string} - Validated key.\n */\nexport function normalizeBackgroundJobScheduleKey(scheduleKey) {\n  if (typeof scheduleKey === \"string\" && scheduleKey.length > 0 && scheduleKey.length <= 255) return scheduleKey\n\n  throw VelociousError.safe(\"background job scheduleKey must be a non-empty string of at most 255 characters\")\n}\n\n/**\n * Normalizes a job queue.\n * @param {import(\"./types.js\").BackgroundJobOptions} [options] - Job options.\n * @returns {string} - Queue name.\n */\nexport function normalizeBackgroundJobQueue(options) {\n  const queue = options?.queue\n\n  if (typeof queue === \"string\" && queue.trim().length > 0) return queue.trim()\n\n  return DEFAULT_BACKGROUND_JOB_QUEUE\n}\n\n/**\n * Normalizes an explicit execution mode while retaining the Node default.\n * @param {Omit<import(\"./types.js\").BackgroundJobOptions, \"executionMode\"> & {executionMode?: string}} options - Job options.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode} [defaultExecutionMode] - Default mode.\n * @param {import(\"./types.js\").BackgroundJobExecutionMode[]} [supportedExecutionModes] - Modes accepted by the caller.\n * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Execution mode.\n */\nexport function normalizeBackgroundJobExecutionMode(options = {}, defaultExecutionMode = DEFAULT_BACKGROUND_JOB_EXECUTION_MODE, supportedExecutionModes = BACKGROUND_JOB_EXECUTION_MODES) {\n  if (\"forked\" in options) {\n    throw new Error(\"The background job `forked` option was removed; pass `executionMode` (\\\"inline\\\", \\\"forked\\\", \\\"pooled\\\", or \\\"spawned\\\") instead\")\n  }\n\n  const requestedExecutionMode = options.executionMode || defaultExecutionMode\n  /** @type {import(\"./types.js\").BackgroundJobExecutionMode | undefined} */\n  let executionMode\n\n  for (const candidate of BACKGROUND_JOB_EXECUTION_MODES) {\n    if (candidate === requestedExecutionMode) executionMode = candidate\n  }\n\n  if (!executionMode) throw new Error(`Invalid background job executionMode: ${requestedExecutionMode}`)\n\n  if (!supportedExecutionModes.includes(executionMode)) {\n    throw new Error(`Background job executionMode \"${executionMode}\" is not supported by the local background-jobs adapter`)\n  }\n\n  return executionMode\n}\n\n/**\n * Validates and normalizes a retry cap.\n * @param {number | null | undefined} maxRetries - Requested retry cap.\n * @returns {number} - Retry cap.\n */\nexport function normalizeBackgroundJobMaxRetries(maxRetries) {\n  if (typeof maxRetries === \"number\" && Number.isFinite(maxRetries) && maxRetries >= 0) {\n    return Math.floor(maxRetries)\n  }\n\n  return DEFAULT_BACKGROUND_JOB_MAX_RETRIES\n}\n\n/**\n * Validates an enqueue eligibility timestamp.\n * @param {number | undefined} scheduledAtMs - Requested timestamp.\n * @param {number} defaultScheduledAtMs - Default timestamp.\n * @returns {number} - Eligibility timestamp.\n */\nexport function normalizeBackgroundJobScheduledAtMs(scheduledAtMs, defaultScheduledAtMs) {\n  if (scheduledAtMs === undefined) return defaultScheduledAtMs\n  if (Number.isSafeInteger(scheduledAtMs) && scheduledAtMs >= 0) return scheduledAtMs\n\n  throw VelociousError.safe(\"background job scheduledAtMs must be a non-negative safe integer\")\n}\n\n/**\n * Validates a reschedule delay and resolves it at persistence time.\n * @param {number} delayMs - Requested delay.\n * @param {number} nowMs - Persistence timestamp.\n * @returns {number} - New eligibility timestamp.\n */\nexport function rescheduledBackgroundJobAtMs(delayMs, nowMs) {\n  if (!Number.isSafeInteger(delayMs) || delayMs < 0) {\n    throw VelociousError.safe(\"background job reschedule delayMs must be a non-negative safe integer\")\n  }\n\n  const scheduledAtMs = nowMs + delayMs\n\n  if (!Number.isSafeInteger(scheduledAtMs)) {\n    throw VelociousError.safe(\"background job reschedule scheduledAtMs must be a safe integer\")\n  }\n\n  return scheduledAtMs\n}\n\n/**\n * Returns the shared failure backoff.\n * @param {number} retryCount - One-based failed attempt count.\n * @returns {number} - Backoff in milliseconds.\n */\nexport function retryDelayMs(retryCount) {\n  const scheduleSeconds = [10, 60, 600, 3600]\n\n  if (retryCount <= scheduleSeconds.length) return scheduleSeconds[retryCount - 1] * 1000\n\n  return (retryCount - 3) * 60 * 60 * 1000\n}\n\n/**\n * Resolves explicit or queue-derived concurrency.\n * @param {object} args - Resolution arguments.\n * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n * @param {string} args.queue - Normalized queue.\n * @param {Record<string, {maxConcurrent?: number, priority?: number}>} args.queues - Queue configuration.\n * @returns {import(\"./types.js\").ResolvedBackgroundJobConcurrency | null} - Concurrency contract.\n */\nexport function normalizeBackgroundJobConcurrency({options = {}, queue, queues}) {\n  const key = options.concurrencyKey\n  const cap = options.maxConcurrency\n\n  if (key !== undefined || cap !== undefined) {\n    if (typeof key !== \"string\" || key.length === 0 || !Number.isInteger(cap) || Number(cap) <= 0) {\n      throw new Error(\"background job concurrencyKey and maxConcurrency must be paired; concurrencyKey must be non-empty and maxConcurrency must be a positive integer\")\n    }\n    if (key.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) {\n      throw new Error(`background job concurrencyKey must not start with the reserved \"${QUEUE_CONCURRENCY_KEY_PREFIX}\" prefix, which is reserved for queue-derived concurrency caps`)\n    }\n\n    return {concurrencyKey: key, maxConcurrency: Number(cap), queueDerived: false}\n  }\n\n  const queueCap = queues[queue]?.maxConcurrent\n\n  if (!Number.isInteger(queueCap) || Number(queueCap) <= 0) return null\n\n  return {\n    concurrencyKey: `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`,\n    maxConcurrency: Number(queueCap),\n    queueDerived: true\n  }\n}\n"]}

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

@@ -43,5 +43,20 @@ export default class VelociousJob<TArgs extends Array<ReturnType<typeof JSON.par
      * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
      */
     static cancelScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
+    /**
+     * Reads current ownership and optional terminal history for a stable key.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.
+     */
+    static getScheduledJob(scheduleKey: string, options?: {
+        includeLatestTerminal?: boolean;
+    }): Promise<import("./types.js").BackgroundJobScheduledLookupResult>;
+    /**
+     * Expedites a future queued owner without creating another job.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Wake result.
+     */
+    static wakeScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobWakeResult>;
 }
 //# sourceMappingURL=job.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAMA,OAAO,oBAAoB,MAAM,mBAAmB,CAAA;AAOpD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY,CAHoB,KAAK,SAA5C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAS,EAAG,CAG5B,SAAQ,oBAAoB,CAF3B,KAAK,CAEsB;IAC5D;;;;OAIG;IACH,OAAa,YAAY,CAAC,GAAG,IAAI,EAHnB,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAGV,GAFpB,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;OAMG;IACH,OAAa,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,EAJjD;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEiD,GAFvC,OAAO,CAAC,MAAM,CAAC,CAc3B;IAED;;;;;;;OAOG;IACH,OAAa,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC,EALvD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEuD,GAF7C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAMxE;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,WAAW,EAH7B,MAG6B,GAF3B,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAMzE;CACF"}
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAMA,OAAO,oBAAoB,MAAM,mBAAmB,CAAA;AASpD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY,CAHoB,KAAK,SAA5C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAS,EAAG,CAG5B,SAAQ,oBAAoB,CAF3B,KAAK,CAEsB;IAC5D;;;;OAIG;IACH,OAAa,YAAY,CAAC,GAAG,IAAI,EAHnB,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAGV,GAFpB,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;OAMG;IACH,OAAa,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,EAJjD;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEiD,GAFvC,OAAO,CAAC,MAAM,CAAC,CAc3B;IAED;;;;;;;OAOG;IACH,OAAa,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC,EALvD;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAmD,IAAI,EAA/C,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAC5C;QAAyD,OAAO,AAAhE,CACA,EADQ,OAAO,YAAY,EAAE,oBAAoB,CACjD;KAEuD,GAF7C,OAAO,CAAC,OAAO,YAAY,EAAE,8BAA8B,CAAC,CAMxE;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,WAAW,EAH7B,MAG6B,GAF3B,OAAO,CAAC,OAAO,YAAY,EAAE,+BAA+B,CAAC,CAMzE;IAED;;;;;OAKG;IACH,OAAa,eAAe,CAAC,WAAW,EAJ7B,MAI6B,EAAE,OAAO,AAH9C,CACA,EADQ;QAAC,qBAAqB,CAAC,EAAE,OAAO,CAAA;KAGW,GAFzC,OAAO,CAAC,OAAO,YAAY,EAAE,kCAAkC,CAAC,CAM5E;IAED;;;;OAIG;IACH,OAAa,aAAa,CAAC,WAAW,EAH3B,MAG2B,GAFzB,OAAO,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAMjE;CACF"}

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

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import configurationResolver from "../configuration-resolver.js";
 import { currentBackgroundJobProducerProof } from "./execution-context.js";
 import PlatformVelociousJob from "./platform-job.js";
-import { cancelScheduledBackgroundJobForConfiguration, enqueueBackgroundJobForConfiguration, replaceScheduledBackgroundJobForConfiguration } from "./runtime.js";
+import { cancelScheduledBackgroundJobForConfiguration, enqueueBackgroundJobForConfiguration, getScheduledBackgroundJobForConfiguration, replaceScheduledBackgroundJobForConfiguration, wakeScheduledBackgroundJobForConfiguration } from "./runtime.js";
 /**
  * Node background-job entry. It preserves lazy configuration discovery for
  * fresh producer processes while the explicit platform entry stays free of
@@ -70,5 +70,24 @@ export default class VelociousJob extends PlatformVelociousJob {
         const configuration = await configurationResolver();
         return await cancelScheduledBackgroundJobForConfiguration({ configuration, scheduleKey });
     }
+    /**
+     * Reads current ownership and optional terminal history for a stable key.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.
+     */
+    static async getScheduledJob(scheduleKey, options = {}) {
+        const configuration = await configurationResolver();
+        return await getScheduledBackgroundJobForConfiguration({ configuration, scheduleKey, ...options });
+    }
+    /**
+     * Expedites a future queued owner without creating another job.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Wake result.
+     */
+    static async wakeScheduled(scheduleKey) {
+        const configuration = await configurationResolver();
+        return await wakeScheduledBackgroundJobForConfiguration({ configuration, scheduleKey });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.js","sourceRoot":"","sources":["../../../src/background-jobs/job.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC,OAAO,qBAAqB,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAA;AAC1E,OAAO,oBAAoB,MAAM,mBAAmB,CAAA;AACpD,OAAO,EACL,4CAA4C,EAC5C,oCAAoC,EACpC,yCAAyC,EACzC,6CAA6C,EAC7C,0CAA0C,EAC3C,MAAM,cAAc,CAAA;AAErB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,oBAAoB;IAC5D;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI;QAC/B,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QACnD,MAAM,EAAC,OAAO,EAAE,UAAU,EAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAA;QAC7D,MAAM,aAAa,GAAG,iCAAiC,EAAE,CAAA;QAEzD,OAAO,MAAM,oCAAoC,CAAC;YAChD,aAAa;YACb,QAAQ,EAAE,IAAI;YACd,OAAO;YACP,UAAU;YACV,aAAa;YACb,oBAAoB,EAAE,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,SAAS;SAC/D,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC;QAClD,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QACnD,MAAM,aAAa,GAAG,iCAAiC,EAAE,CAAA;QAEzD,OAAO,MAAM,oCAAoC,CAAC;YAChD,aAAa;YACb,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,IAAI;YACb,UAAU,EAAE,OAAO;YACnB,aAAa;YACb,oBAAoB,EAAE,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,SAAS;SAC/D,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAC;QACxD,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,6CAA6C,CAAC,EAAC,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAC,CAAC,CAAA;IAC9I,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW;QACtC,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,4CAA4C,CAAC,EAAC,aAAa,EAAE,WAAW,EAAC,CAAC,CAAA;IACzF,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW,EAAE,OAAO,GAAG,EAAE;QACpD,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,yCAAyC,CAAC,EAAC,aAAa,EAAE,WAAW,EAAE,GAAG,OAAO,EAAC,CAAC,CAAA;IAClG,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,WAAW;QACpC,MAAM,aAAa,GAAG,MAAM,qBAAqB,EAAE,CAAA;QAEnD,OAAO,MAAM,0CAA0C,CAAC,EAAC,aAAa,EAAE,WAAW,EAAC,CAAC,CAAA;IACvF,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport { randomUUID } from \"node:crypto\"\n\nimport configurationResolver from \"../configuration-resolver.js\"\nimport { currentBackgroundJobProducerProof } from \"./execution-context.js\"\nimport PlatformVelociousJob from \"./platform-job.js\"\nimport {\n  cancelScheduledBackgroundJobForConfiguration,\n  enqueueBackgroundJobForConfiguration,\n  getScheduledBackgroundJobForConfiguration,\n  replaceScheduledBackgroundJobForConfiguration,\n  wakeScheduledBackgroundJobForConfiguration\n} from \"./runtime.js\"\n\n/**\n * Node background-job entry. It preserves lazy configuration discovery for\n * fresh producer processes while the explicit platform entry stays free of\n * Node-only configuration resolution.\n * @template {Array<ReturnType<typeof JSON.parse>>} [TArgs=[]]\n * @augments {PlatformVelociousJob<TArgs>}\n */\nexport default class VelociousJob extends PlatformVelociousJob {\n  /**\n   * Runs perform later.\n   * @param {...ReturnType<typeof JSON.parse>} args - Job args.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLater(...args) {\n    const configuration = await configurationResolver()\n    const {jobArgs, jobOptions} = this._splitArgsAndOptions(args)\n    const producerProof = currentBackgroundJobProducerProof()\n\n    return await enqueueBackgroundJobForConfiguration({\n      configuration,\n      JobClass: this,\n      jobArgs,\n      jobOptions,\n      producerProof,\n      producerInvocationId: producerProof ? randomUUID() : undefined\n    })\n  }\n\n  /**\n   * Runs perform later with options.\n   * @param {object} args - Options.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Job id.\n   */\n  static async performLaterWithOptions({args, options}) {\n    const configuration = await configurationResolver()\n    const producerProof = currentBackgroundJobProducerProof()\n\n    return await enqueueBackgroundJobForConfiguration({\n      configuration,\n      JobClass: this,\n      jobArgs: args,\n      jobOptions: options,\n      producerProof,\n      producerInvocationId: producerProof ? randomUUID() : undefined\n    })\n  }\n\n  /**\n   * Atomically replaces this job class's queued owner for a stable schedule key.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job args.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  static async replaceScheduled({scheduleKey, args, options}) {\n    const configuration = await configurationResolver()\n\n    return await replaceScheduledBackgroundJobForConfiguration({configuration, JobClass: this, scheduleKey, jobArgs: args, jobOptions: options})\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  static async cancelScheduled(scheduleKey) {\n    const configuration = await configurationResolver()\n\n    return await cancelScheduledBackgroundJobForConfiguration({configuration, scheduleKey})\n  }\n\n  /**\n   * Reads current ownership and optional terminal history for a stable key.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized stable schedule jobs.\n   */\n  static async getScheduledJob(scheduleKey, options = {}) {\n    const configuration = await configurationResolver()\n\n    return await getScheduledBackgroundJobForConfiguration({configuration, scheduleKey, ...options})\n  }\n\n  /**\n   * Expedites a future queued owner without creating another job.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobWakeResult>} - Wake result.\n   */\n  static async wakeScheduled(scheduleKey) {\n    const configuration = await configurationResolver()\n\n    return await wakeScheduledBackgroundJobForConfiguration({configuration, scheduleKey})\n  }\n}\n"]}

package/build/src/background-jobs/local-adapter.d.ts

@@ -52,22 +52,37 @@ export default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {
         options?: import("./types.js").BackgroundJobOptions;
     }): Promise<string>;
     /**
-     * Rejects stable-key cancellation, which is outside the local adapter contract.
-     * @param {string} _scheduleKey - Unsupported stable key.
-     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Never resolves.
+     * Cancels or detaches the current owner of a stable schedule key.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
      */
-    cancelScheduled(_scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
+    cancelScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
     /**
-     * Rejects stable-key replacement, which is outside the local adapter contract.
-     * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import("./types.js").BackgroundJobOptions}} _args - Unsupported request.
-     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Never resolves.
+     * Replaces the current owner of a stable schedule key.
+     * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import("./types.js").BackgroundJobOptions}} args - Replacement request.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
      */
-    replaceScheduled(_args: {
+    replaceScheduled(args: {
         scheduleKey: string;
         jobName: string;
         args: Array<ReturnType<typeof JSON.parse>>;
         options?: import("./types.js").BackgroundJobOptions;
     }): Promise<import("./types.js").BackgroundJobReplacementResult>;
+    /**
+     * Reads stable ownership and optional terminal history.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized local jobs.
+     */
+    getScheduledJob(scheduleKey: string, options?: {
+        includeLatestTerminal?: boolean;
+    }): Promise<import("./types.js").BackgroundJobScheduledLookupResult>;
+    /**
+     * Makes a future queued stable owner due without replacing it.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Exact wake result.
+     */
+    wakeScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobWakeResult>;
     /**
      * Finds the next eligible local job.
      * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Next eligible job.

package/build/src/background-jobs/local-adapter.d.ts.map

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

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

@@ -59,17 +59,43 @@ export default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {
         return await this.store.enqueue(args);
     }
     /**
-     * Rejects stable-key cancellation, which is outside the local adapter contract.
-     * @param {string} _scheduleKey - Unsupported stable key.
-     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Never resolves.
+     * Cancels or detaches the current owner of a stable schedule key.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
      */
-    async cancelScheduled(_scheduleKey) { throw new Error("cancelScheduled is not supported by the local background-jobs adapter"); }
+    async cancelScheduled(scheduleKey) {
+        await this.ensureReady();
+        return await this.store.cancelScheduled(scheduleKey);
+    }
+    /**
+     * Replaces the current owner of a stable schedule key.
+     * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import("./types.js").BackgroundJobOptions}} args - Replacement request.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+     */
+    async replaceScheduled(args) {
+        await this.ensureReady();
+        this.registry.resolve(args.jobName);
+        return await this.store.replaceScheduled(args);
+    }
     /**
-     * Rejects stable-key replacement, which is outside the local adapter contract.
-     * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import("./types.js").BackgroundJobOptions}} _args - Unsupported request.
-     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Never resolves.
+     * Reads stable ownership and optional terminal history.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized local jobs.
      */
-    async replaceScheduled(_args) { throw new Error("replaceScheduled is not supported by the local background-jobs adapter"); }
+    async getScheduledJob(scheduleKey, options) {
+        await this.ensureReady();
+        return await this.store.getScheduledJob(scheduleKey, options);
+    }
+    /**
+     * Makes a future queued stable owner due without replacing it.
+     * @param {string} scheduleKey - Stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Exact wake result.
+     */
+    async wakeScheduled(scheduleKey) {
+        await this.ensureReady();
+        return await this.store.wakeScheduled(scheduleKey);
+    }
     /**
      * Finds the next eligible local job.
      * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Next eligible job.
@@ -144,4 +170,4 @@ export default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {
      */
     async waitForIdle() { await this.dispatcher.waitForIdle(); }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-adapter.js","sourceRoot":"","sources":["../../../src/background-jobs/local-adapter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BackgroundJobsAdapter from \"./adapter.js\"\nimport LocalBackgroundJobsDispatcher from \"./local-dispatcher.js\"\nimport LocalBackgroundJobRegistry from \"./local-job-registry.js\"\nimport LocalBackgroundJobsStore, {localBackgroundJobsClock} from \"./local-store.js\"\n\n/** Durable local SQLite adapter with an owned in-process dispatcher. */\nexport default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {\n  /**\n   * Creates a local adapter for one configuration and database.\n   * @param {object} args - Adapter options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {import(\"./types.js\").LocalBackgroundJobsClock} [args.clock] - Injectable clock.\n   * @param {string} [args.databaseIdentifier] - Local database identifier.\n   */\n  constructor({configuration, clock = localBackgroundJobsClock(), databaseIdentifier}) {\n    super()\n    this.clock = clock\n    this.configuration = configuration\n    this.registry = new LocalBackgroundJobRegistry({jobClasses: configuration.getBackgroundJobClasses()})\n    this.store = new LocalBackgroundJobsStore({\n      clock,\n      configuration,\n      databaseIdentifier,\n      onCommittedEnqueue: () => this.dispatcher.wake()\n    })\n    this.dispatcher = new LocalBackgroundJobsDispatcher({clock, configuration, registry: this.registry, store: this.store})\n  }\n\n  /**\n   * Ensures that local persistence and dispatch are ready.\n   * @returns {Promise<void>} - Resolves when local dispatch is ready.\n   */\n  async ensureReady() { await this.dispatcher.start() }\n\n  /**\n   * Stops local dispatch gracefully.\n   * @returns {Promise<void>} - Resolves after graceful local shutdown.\n   */\n  async close() {\n    await this.dispatcher.stop()\n    this.store.resetReadiness()\n  }\n\n  /**\n   * Reports local dispatcher health.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobsHealth>} - Local adapter health.\n   */\n  async health() { return {ready: this.dispatcher.isReady()} }\n\n  /**\n   * Reconciles configuration-derived queue concurrency caps.\n   * @returns {Promise<void>} - Resolves after queue cap reconciliation.\n   */\n  async reconcileQueueConcurrency() { await this.store.reconcileQueueConcurrency() }\n\n  /**\n   * Enqueues one statically registered local job.\n   * @param {{jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import(\"./types.js\").BackgroundJobOptions}} args - Enqueue request.\n   * @returns {Promise<string>} - Durable local job id.\n   */\n  async enqueue(args) {\n    await this.ensureReady()\n    this.registry.resolve(args.jobName)\n    return await this.store.enqueue(args)\n  }\n\n  /**\n   * Rejects stable-key cancellation, which is outside the local adapter contract.\n   * @param {string} _scheduleKey - Unsupported stable key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Never resolves.\n   */\n  async cancelScheduled(_scheduleKey) { throw new Error(\"cancelScheduled is not supported by the local background-jobs adapter\") }\n\n  /**\n   * Rejects stable-key replacement, which is outside the local adapter contract.\n   * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import(\"./types.js\").BackgroundJobOptions}} _args - Unsupported request.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Never resolves.\n   */\n  async replaceScheduled(_args) { throw new Error(\"replaceScheduled is not supported by the local background-jobs adapter\") }\n\n  /**\n   * Finds the next eligible local job.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next eligible job.\n   */\n  async nextAvailableJob() { return await this.store.nextAvailableJob() }\n\n  /**\n   * Finds the next future local job.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next future job.\n   */\n  async nextScheduledJob() { return await this.store.nextScheduledJob() }\n\n  /**\n   * Finds a local job by id.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Persisted job.\n   */\n  async getJob(jobId) { return await this.store.getJob(jobId) }\n\n  /**\n   * Lists local jobs in insertion order.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Local jobs.\n   */\n  async listJobs() { return await this.store.listJobs() }\n\n  /**\n   * Claims one queued local job.\n   * @param {import(\"./types.js\").BackgroundJobHandoffRequest} args - Claim request. A supplied handoff id is persisted exactly.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoff | null>} - Handoff.\n   */\n  async markHandedOff(args) { return await this.store.markHandedOff(args) }\n\n  /**\n   * Finds active local handoffs owned by one worker.\n   * @param {{workerId: string}} args - Worker identity.\n   * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active worker handoffs.\n   */\n  async handedOffJobsForWorker(args) { return await this.store.handedOffJobsForWorker(args) }\n\n  /**\n   * Returns an exact active local handoff to the queue.\n   * @param {{jobId: string, handoffId: string}} args - Handoff release.\n   * @returns {Promise<void>} - Resolves after the fenced release.\n   */\n  async markReturnedToQueue(args) { await this.store.markReturnedToQueue(args) }\n\n  /**\n   * Acknowledges successful local job completion.\n   * @param {{jobId: string, handoffId?: string}} args - Completion report.\n   * @returns {Promise<boolean>} - Whether accepted.\n   */\n  async markCompleted(args) { return await this.store.markCompleted(args) }\n\n  /**\n   * Records pooled-child acceptance evidence for a local handoff.\n   * @param {{jobId: string, handoffId?: string, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number}} args - Acceptance report.\n   * @returns {Promise<boolean>} - Whether accepted.\n   */\n  async markChildAccepted(args) { return await this.store.markChildAccepted(args) }\n\n  /**\n   * Acknowledges an explicit local reschedule.\n   * @param {{jobId: string, delayMs: number, handoffId?: string}} args - Reschedule report.\n   * @returns {Promise<boolean>} - Whether accepted.\n   */\n  async markRescheduled(args) { return await this.store.markRescheduled(args) }\n\n  /**\n   * Acknowledges a failed local performance.\n   * @param {{jobId: string, error: ReturnType<typeof JSON.parse>, handoffId?: string}} args - Failure report.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Transition.\n   */\n  async markFailed(args) { return await this.store.markFailed(args) }\n\n  /**\n   * Coalesces a dispatcher wake.\n   * @returns {void} - No return value.\n   */\n  wake() { this.dispatcher.wake() }\n\n  /**\n   * Waits until current local work has been acknowledged.\n   * @returns {Promise<void>} - Resolves after all current work is acknowledged.\n   */\n  async waitForIdle() { await this.dispatcher.waitForIdle() }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-adapter.js","sourceRoot":"","sources":["../../../src/background-jobs/local-adapter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport BackgroundJobsAdapter from \"./adapter.js\"\nimport LocalBackgroundJobsDispatcher from \"./local-dispatcher.js\"\nimport LocalBackgroundJobRegistry from \"./local-job-registry.js\"\nimport LocalBackgroundJobsStore, {localBackgroundJobsClock} from \"./local-store.js\"\n\n/** Durable local SQLite adapter with an owned in-process dispatcher. */\nexport default class LocalBackgroundJobsAdapter extends BackgroundJobsAdapter {\n  /**\n   * Creates a local adapter for one configuration and database.\n   * @param {object} args - Adapter options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {import(\"./types.js\").LocalBackgroundJobsClock} [args.clock] - Injectable clock.\n   * @param {string} [args.databaseIdentifier] - Local database identifier.\n   */\n  constructor({configuration, clock = localBackgroundJobsClock(), databaseIdentifier}) {\n    super()\n    this.clock = clock\n    this.configuration = configuration\n    this.registry = new LocalBackgroundJobRegistry({jobClasses: configuration.getBackgroundJobClasses()})\n    this.store = new LocalBackgroundJobsStore({\n      clock,\n      configuration,\n      databaseIdentifier,\n      onCommittedEnqueue: () => this.dispatcher.wake()\n    })\n    this.dispatcher = new LocalBackgroundJobsDispatcher({clock, configuration, registry: this.registry, store: this.store})\n  }\n\n  /**\n   * Ensures that local persistence and dispatch are ready.\n   * @returns {Promise<void>} - Resolves when local dispatch is ready.\n   */\n  async ensureReady() { await this.dispatcher.start() }\n\n  /**\n   * Stops local dispatch gracefully.\n   * @returns {Promise<void>} - Resolves after graceful local shutdown.\n   */\n  async close() {\n    await this.dispatcher.stop()\n    this.store.resetReadiness()\n  }\n\n  /**\n   * Reports local dispatcher health.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobsHealth>} - Local adapter health.\n   */\n  async health() { return {ready: this.dispatcher.isReady()} }\n\n  /**\n   * Reconciles configuration-derived queue concurrency caps.\n   * @returns {Promise<void>} - Resolves after queue cap reconciliation.\n   */\n  async reconcileQueueConcurrency() { await this.store.reconcileQueueConcurrency() }\n\n  /**\n   * Enqueues one statically registered local job.\n   * @param {{jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import(\"./types.js\").BackgroundJobOptions}} args - Enqueue request.\n   * @returns {Promise<string>} - Durable local job id.\n   */\n  async enqueue(args) {\n    await this.ensureReady()\n    this.registry.resolve(args.jobName)\n    return await this.store.enqueue(args)\n  }\n\n  /**\n   * Cancels or detaches the current owner of a stable schedule key.\n   * @param {string} scheduleKey - Stable schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  async cancelScheduled(scheduleKey) {\n    await this.ensureReady()\n    return await this.store.cancelScheduled(scheduleKey)\n  }\n\n  /**\n   * Replaces the current owner of a stable schedule key.\n   * @param {{scheduleKey: string, jobName: string, args: Array<ReturnType<typeof JSON.parse>>, options?: import(\"./types.js\").BackgroundJobOptions}} args - Replacement request.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  async replaceScheduled(args) {\n    await this.ensureReady()\n    this.registry.resolve(args.jobName)\n    return await this.store.replaceScheduled(args)\n  }\n\n  /**\n   * Reads stable ownership and optional terminal history.\n   * @param {string} scheduleKey - Stable schedule key.\n   * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized local jobs.\n   */\n  async getScheduledJob(scheduleKey, options) {\n    await this.ensureReady()\n    return await this.store.getScheduledJob(scheduleKey, options)\n  }\n\n  /**\n   * Makes a future queued stable owner due without replacing it.\n   * @param {string} scheduleKey - Stable schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobWakeResult>} - Exact wake result.\n   */\n  async wakeScheduled(scheduleKey) {\n    await this.ensureReady()\n    return await this.store.wakeScheduled(scheduleKey)\n  }\n\n  /**\n   * Finds the next eligible local job.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next eligible job.\n   */\n  async nextAvailableJob() { return await this.store.nextAvailableJob() }\n\n  /**\n   * Finds the next future local job.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next future job.\n   */\n  async nextScheduledJob() { return await this.store.nextScheduledJob() }\n\n  /**\n   * Finds a local job by id.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Persisted job.\n   */\n  async getJob(jobId) { return await this.store.getJob(jobId) }\n\n  /**\n   * Lists local jobs in insertion order.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Local jobs.\n   */\n  async listJobs() { return await this.store.listJobs() }\n\n  /**\n   * Claims one queued local job.\n   * @param {import(\"./types.js\").BackgroundJobHandoffRequest} args - Claim request. A supplied handoff id is persisted exactly.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoff | null>} - Handoff.\n   */\n  async markHandedOff(args) { return await this.store.markHandedOff(args) }\n\n  /**\n   * Finds active local handoffs owned by one worker.\n   * @param {{workerId: string}} args - Worker identity.\n   * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active worker handoffs.\n   */\n  async handedOffJobsForWorker(args) { return await this.store.handedOffJobsForWorker(args) }\n\n  /**\n   * Returns an exact active local handoff to the queue.\n   * @param {{jobId: string, handoffId: string}} args - Handoff release.\n   * @returns {Promise<void>} - Resolves after the fenced release.\n   */\n  async markReturnedToQueue(args) { await this.store.markReturnedToQueue(args) }\n\n  /**\n   * Acknowledges successful local job completion.\n   * @param {{jobId: string, handoffId?: string}} args - Completion report.\n   * @returns {Promise<boolean>} - Whether accepted.\n   */\n  async markCompleted(args) { return await this.store.markCompleted(args) }\n\n  /**\n   * Records pooled-child acceptance evidence for a local handoff.\n   * @param {{jobId: string, handoffId?: string, receivedAtMs?: number, startedAtMs?: number, childInstanceId?: string, childPid?: number}} args - Acceptance report.\n   * @returns {Promise<boolean>} - Whether accepted.\n   */\n  async markChildAccepted(args) { return await this.store.markChildAccepted(args) }\n\n  /**\n   * Acknowledges an explicit local reschedule.\n   * @param {{jobId: string, delayMs: number, handoffId?: string}} args - Reschedule report.\n   * @returns {Promise<boolean>} - Whether accepted.\n   */\n  async markRescheduled(args) { return await this.store.markRescheduled(args) }\n\n  /**\n   * Acknowledges a failed local performance.\n   * @param {{jobId: string, error: ReturnType<typeof JSON.parse>, handoffId?: string}} args - Failure report.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Transition.\n   */\n  async markFailed(args) { return await this.store.markFailed(args) }\n\n  /**\n   * Coalesces a dispatcher wake.\n   * @returns {void} - No return value.\n   */\n  wake() { this.dispatcher.wake() }\n\n  /**\n   * Waits until current local work has been acknowledged.\n   * @returns {Promise<void>} - Resolves after all current work is acknowledged.\n   */\n  async waitForIdle() { await this.dispatcher.waitForIdle() }\n}\n"]}

package/build/src/background-jobs/local-store.d.ts

@@ -1,7 +1,9 @@
 import TableData from "../database/table-data/index.js";
 export declare const LOCAL_BACKGROUND_JOBS_TABLE = "velocious_local_background_jobs";
 export declare const LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE = "velocious_local_background_job_concurrency";
+export declare const LOCAL_BACKGROUND_JOB_SCHEDULE_KEYS_TABLE = "velocious_local_background_job_schedule_keys";
 export declare const LOCAL_BACKGROUND_JOBS_INDEX_NAMES: string[];
+export declare const LOCAL_BACKGROUND_JOB_SCHEDULE_KEYS_INDEX_NAMES: string[];
 /**
  * Creates the production clock used by local dispatch.
  * @returns {import("./types.js").LocalBackgroundJobsClock} - Production clock.
@@ -57,7 +59,8 @@ export default class LocalBackgroundJobsStore {
      */
     _ensureReadyWithDb(db: import("../database/drivers/base.js").default): Promise<void>;
     /**
-     * Creates or repairs version-one tables and indexes.
+     * Creates or upgrades the versioned local tables and indexes without
+     * rebuilding persisted queue data.
      * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
      * @returns {Promise<boolean>} - Whether schema state changed.
      */
@@ -85,6 +88,11 @@ export default class LocalBackgroundJobsStore {
      * @returns {TableData} - Concurrency counter table definition.
      */
     _concurrencyTableData(): TableData;
+    /**
+     * Builds the stable schedule-owner table definition.
+     * @returns {TableData} - Stable owner table definition.
+     */
+    _scheduleKeysTableData(): TableData;
     /**
      * Rejects an incompatible current-version table rather than rebuilding data.
      * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
@@ -102,14 +110,23 @@ export default class LocalBackgroundJobsStore {
     /**
      * Checks whether the current local schema version is recorded.
      * @param {import("../database/drivers/base.js").default} db - Connection.
-     * @returns {Promise<boolean>} - Whether version one is recorded.
+     * @param {string} version - Local schema version.
+     * @returns {Promise<boolean>} - Whether the version is recorded.
      */
-    _hasMigration(db: import("../database/drivers/base.js").default): Promise<boolean>;
+    _hasMigration(db: import("../database/drivers/base.js").default, version: string): Promise<boolean>;
+    /**
+     * Records one local schema version after its additive changes are present.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {string} version - Local schema version.
+     * @returns {Promise<void>} - Resolves after recording.
+     */
+    _recordMigration(db: import("../database/drivers/base.js").default, version: string): Promise<void>;
     /**
      * Builds the scoped migration key.
+     * @param {string} version - Local schema version.
      * @returns {string} - Scoped migration key.
      */
-    _migrationKey(): string;
+    _migrationKey(version: string): string;
     /**
      * Enqueues a local job in the caller's active transaction when present.
      * @param {object} args - Enqueue request.
@@ -123,6 +140,43 @@ export default class LocalBackgroundJobsStore {
         args: Array<ReturnType<typeof JSON.parse>>;
         options?: import("./types.js").BackgroundJobOptions;
     }): Promise<string>;
+    /**
+     * Replaces the queued owner of a stable schedule key with a new local job.
+     * A handed-off owner remains runnable but is detached from future ownership.
+     * @param {object} args - Replacement request.
+     * @param {string} args.scheduleKey - Stable logical schedule key.
+     * @param {string} args.jobName - Registered job name.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Serialized job arguments.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<import("./types.js").BackgroundJobReplacementResult>} - Replacement result.
+     */
+    replaceScheduled({ scheduleKey, jobName, args, options }: {
+        scheduleKey: string;
+        jobName: string;
+        args: Array<ReturnType<typeof JSON.parse>>;
+        options?: import("./types.js").BackgroundJobOptions;
+    }): Promise<import("./types.js").BackgroundJobReplacementResult>;
+    /**
+     * Cancels a queued stable owner or detaches an active handoff truthfully.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobCancellationResult>} - Cancellation result.
+     */
+    cancelScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobCancellationResult>;
+    /**
+     * Reads stable ownership and optional latest terminal history in one transaction.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized local jobs.
+     */
+    getScheduledJob(scheduleKey: string, { includeLatestTerminal }?: {
+        includeLatestTerminal?: boolean;
+    }): Promise<import("./types.js").BackgroundJobScheduledLookupResult>;
+    /**
+     * Moves only a future queued stable owner to the current time.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Exact wake outcome.
+     */
+    wakeScheduled(scheduleKey: string): Promise<import("./types.js").BackgroundJobWakeResult>;
     /**
      * Serializes matching in-process deduplication checks through commit while
      * leaving unrelated job identities independent.
@@ -146,9 +200,11 @@ export default class LocalBackgroundJobsStore {
      * Inserts one prepared local job row and its concurrency metadata.
      * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
      * @param {import("./types.js").PreparedLocalBackgroundJob} preparedJob - Prepared row data.
+     * @param {string | null} [scheduleKey] - Stable schedule history key.
+     * @param {number | null} [scheduleOrder] - Monotonic stable ownership order.
      * @returns {Promise<void>} - Resolves after insertion.
      */
-    _insertPreparedJob(db: import("../database/drivers/base.js").default, preparedJob: import("./types.js").PreparedLocalBackgroundJob): Promise<void>;
+    _insertPreparedJob(db: import("../database/drivers/base.js").default, preparedJob: import("./types.js").PreparedLocalBackgroundJob, scheduleKey?: string | null, scheduleOrder?: number | null): Promise<void>;
     /**
      * Reconciles configured queue-derived caps and durable counters.
      * @returns {Promise<void>} - Resolves after reconciliation.
@@ -344,6 +400,65 @@ export default class LocalBackgroundJobsStore {
      * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Persisted row.
      */
     _getJob(db: import("../database/drivers/base.js").default, jobId: string): Promise<import("./types.js").BackgroundJobRow | null>;
+    /**
+     * Reads the job currently named by one stable owner row.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Normalized owner job.
+     */
+    _scheduledOwnerJob(db: import("../database/drivers/base.js").default, scheduleKey: string): Promise<import("./types.js").BackgroundJobRow | null>;
+    /**
+     * Assigns the next ownership order after SQLite write serialization is held.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<number>} - Next monotonic ownership order.
+     */
+    _nextScheduleOrder(db: import("../database/drivers/base.js").default, scheduleKey: string): Promise<number>;
+    /**
+     * Builds a stable-schedule lookup exclusively from normalized local jobs.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {object} args - Lookup options.
+     * @param {boolean} args.includeLatestTerminal - Whether terminal history is requested.
+     * @param {string} args.scheduleKey - Validated stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized local jobs.
+     */
+    _scheduledJobLookup(db: import("../database/drivers/base.js").default, { includeLatestTerminal, scheduleKey }: {
+        includeLatestTerminal: boolean;
+        scheduleKey: string;
+    }): Promise<import("./types.js").BackgroundJobScheduledLookupResult>;
+    /**
+     * Releases ownership only when the key still points at the expected job.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {object} args - Ownership identity.
+     * @param {string | null} args.jobId - Expected owner job id, or null for a dangling owner.
+     * @param {string} args.scheduleKey - Stable schedule key.
+     * @returns {Promise<void>} - Resolves when deleted or already superseded.
+     */
+    _releaseScheduleOwnership(db: import("../database/drivers/base.js").default, { jobId, scheduleKey }: {
+        jobId: string | null;
+        scheduleKey: string;
+    }): Promise<void>;
+    /**
+     * Releases a terminal job's stable ownership when still current.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {import("./types.js").BackgroundJobRow} job - Terminal job.
+     * @returns {Promise<void>} - Resolves when deleted or not applicable.
+     */
+    _releaseScheduleOwnershipForJob(db: import("../database/drivers/base.js").default, job: import("./types.js").BackgroundJobRow): Promise<void>;
+    /**
+     * Acquires SQLite's transaction write serialization before reading a stable
+     * owner. A zero-row update still establishes the write boundary for a new key.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<void>} - Resolves after write serialization is acquired.
+     */
+    _lockScheduleKey(db: import("../database/drivers/base.js").default, scheduleKey: string): Promise<void>;
+    /**
+     * Registers the local dispatch poke on the surrounding transaction commit.
+     * @param {import("../database/drivers/base.js").default} db - Transaction connection.
+     * @returns {Promise<void>} - Resolves after registration.
+     */
+    _wakeDispatcherAfterCommit(db: import("../database/drivers/base.js").default): Promise<void>;
     /**
      * Normalizes one raw local database row.
      * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw row.