@blokjs/trigger-worker 0.6.17 → 0.6.19

package/dist/WorkerTrigger.d.ts

@@ -19,8 +19,22 @@
  *    - Ack on success, retry or DLQ on failure
  */
 import { type HelperResponse, type WorkerTriggerOpts } from "@blokjs/helper";
-import { type BlokService, DefaultLogger, type GlobalOptions, TriggerBase, type TriggerResponse } from "@blokjs/runner";
+import { type BlokService, Configuration, DefaultLogger, type GlobalOptions, TriggerBase, type TriggerResponse } from "@blokjs/runner";
 import type { Context } from "@blokjs/shared";
+/**
+ * F4 / F24 — thrown by `executeWithTimeout` when a worker job exceeds its
+ * trigger-level `config.timeout`. A dedicated type (instead of a plain
+ * `Error`) lets `handleJob`'s catch discriminate the timeout: it aborts the
+ * detached run via `ctx.signal` and flips the run record to `timedOut`
+ * (matching the per-step `maxDuration` taxonomy) rather than routing the
+ * timeout through the generic retry/DLQ path.
+ */
+export declare class WorkerTimeoutError extends Error {
+    readonly timeoutMs: number;
+    /** Run id of the aborted run, when known — used to flip status to `timedOut`. */
+    readonly runId?: string;
+    constructor(timeoutMs: number, runId?: string);
+}
 /**
  * Job received from worker queue
  */
@@ -220,9 +234,19 @@ export declare abstract class WorkerTrigger extends TriggerBase {
      */
     protected handleJob(job: WorkerJob, workflow: WorkerWorkflowModel, config: WorkerTriggerOpts): Promise<void>;
     /**
-     * Execute workflow with a timeout
+     * Execute workflow with a timeout.
+     *
+     * F4 — on timeout, fire the ctx AbortController so the detached `run`
+     * unwinds cooperatively (it throws `RunCancelledError` at the next
+     * between-step check; long uninterruptible nodes should still poll
+     * `ctx.signal.aborted`). The promise rejects with a dedicated
+     * {@link WorkerTimeoutError} carrying the run id so `handleJob`'s catch can
+     * flip the run record to `timedOut` (F24). The second `run` (broker
+     * redelivery) is prevented because we ACK without requeue on timeout.
+     *
+     * F2 — `configuration` is the per-job Configuration; threaded into `run`.
      */
-    protected executeWithTimeout(ctx: Context, timeoutMs: number): Promise<TriggerResponse>;
+    protected executeWithTimeout(ctx: Context, timeoutMs: number, configuration?: Configuration): Promise<TriggerResponse>;
     /**
      * Calculate exponential backoff delay
      * Formula: min(baseDelay * 2^attempt, 30000) + jitter