@ricsam/r5d-worker 0.0.108 → 0.0.109

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.108",
+  "version": "0.0.109",
   "type": "module"
 }

package/dist/mjs/recovery-output-window.mjs

@@ -0,0 +1,53 @@
+const keyOf = (runId, stream) => `${runId}:${stream}`;
+class WorkerOutputWindow {
+  constructor(windowBytes = 1024 * 1024) {
+    this.windowBytes = windowBytes;
+  }
+  windowBytes;
+  sent = /* @__PURE__ */ new Map();
+  acknowledged = /* @__PURE__ */ new Map();
+  outstanding = 0;
+  reset(cursors) {
+    this.sent.clear();
+    this.acknowledged.clear();
+    this.outstanding = 0;
+    for (const cursor of cursors) {
+      for (const stream of ["stdout", "stderr"]) {
+        const offset = stream === "stdout" ? cursor.stdoutBytes : cursor.stderrBytes;
+        this.sent.set(keyOf(cursor.runId, stream), offset);
+        this.acknowledged.set(keyOf(cursor.runId, stream), offset);
+      }
+    }
+  }
+  send(frame, send, bufferedAmount = 0) {
+    const key = keyOf(frame.runId, frame.stream);
+    const sent = this.sent.get(key) ?? 0;
+    const bytes = Buffer.from(frame.data, "utf8");
+    const end = frame.offset + bytes.length;
+    if (end <= sent) return true;
+    if (frame.offset > sent) return false;
+    let cursor = sent;
+    while (cursor < end) {
+      let count = Math.min(end - cursor, 64 * 1024, this.windowBytes - this.outstanding);
+      while (count > 0 && ((bytes[cursor - frame.offset + count] ?? 0) & 192) === 128) count -= 1;
+      if (count <= 0 || bufferedAmount >= this.windowBytes) return false;
+      const data = bytes.subarray(cursor - frame.offset, cursor - frame.offset + count).toString("utf8");
+      if (!send({ ...frame, offset: cursor, data })) return false;
+      cursor += count;
+      this.sent.set(key, cursor);
+      this.outstanding += count;
+    }
+    return true;
+  }
+  acknowledge(runId, stream, offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0) return;
+    const key = keyOf(runId, stream);
+    const previous = this.acknowledged.get(key) ?? 0;
+    const next = Math.max(previous, Math.min(this.sent.get(key) ?? 0, offset));
+    this.acknowledged.set(key, next);
+    this.outstanding = Math.max(0, this.outstanding - (next - previous));
+  }
+}
+export {
+  WorkerOutputWindow
+};

package/dist/mjs/recovery-protocol.mjs

@@ -0,0 +1,6 @@
+const WORKER_RESUMABLE_PROTOCOL = 1;
+const WORKER_RECOVERY_TIMEOUT_MS = 5 * 60 * 1e3;
+export {
+  WORKER_RECOVERY_TIMEOUT_MS,
+  WORKER_RESUMABLE_PROTOCOL
+};

package/dist/mjs/recovery-store.mjs

@@ -0,0 +1,194 @@
+import { Database } from "bun:sqlite";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+function workerOperationDigest(message) {
+  const canonical = (value) => {
+    if (Array.isArray(value)) return value.map(canonical);
+    if (value && typeof value === "object")
+      return Object.fromEntries(
+        Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)])
+      );
+    return value;
+  };
+  const { requestId: _requestId, ...identity } = message;
+  return createHash("sha256").update(JSON.stringify(canonical(identity))).digest("hex");
+}
+class WorkerRecoveryStore {
+  db;
+  ledgerId;
+  constructor(filename) {
+    fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 448 });
+    this.db = new Database(filename, { create: true });
+    fs.chmodSync(filename, 384);
+    this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;
+      CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS operations (request_id TEXT PRIMARY KEY, run_id TEXT, session_id TEXT, request_type TEXT NOT NULL, digest TEXT NOT NULL, state TEXT NOT NULL, response TEXT);
+      CREATE UNIQUE INDEX IF NOT EXISTS operation_run_start ON operations(run_id) WHERE request_type='exec_start';
+      CREATE TABLE IF NOT EXISTS aliases (request_id TEXT PRIMARY KEY, operation_id TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS streams (run_id TEXT NOT NULL, stream TEXT NOT NULL, bytes INTEGER NOT NULL DEFAULT 0, acknowledged INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(run_id, stream));
+      CREATE TABLE IF NOT EXISTS output (run_id TEXT NOT NULL, stream TEXT NOT NULL, offset INTEGER NOT NULL, bytes INTEGER NOT NULL, data TEXT NOT NULL, PRIMARY KEY(run_id, stream, offset));
+      CREATE TABLE IF NOT EXISTS terminals (run_id TEXT PRIMARY KEY, message TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS cancelled_requests (request_id TEXT PRIMARY KEY);
+    `);
+    this.db.run("INSERT OR IGNORE INTO metadata(key,value) VALUES ('ledgerId',?)", [crypto.randomUUID()]);
+    this.ledgerId = this.db.query("SELECT value FROM metadata WHERE key='ledgerId'").get().value;
+    this.db.run("UPDATE operations SET state='unknown' WHERE state IN ('accepted','preparing','running')");
+  }
+  close() {
+    this.db.close();
+  }
+  row(requestId) {
+    return this.db.query("SELECT * FROM operations WHERE request_id=? OR request_id=(SELECT operation_id FROM aliases WHERE request_id=?)").get(requestId, requestId);
+  }
+  admit(message) {
+    const digest = workerOperationDigest(message);
+    let existing = this.row(message.requestId);
+    if (!existing && message.type === "exec_start" && typeof message.runId === "string")
+      existing = this.db.query("SELECT * FROM operations WHERE run_id=? AND request_type='exec_start'").get(message.runId);
+    if (existing) {
+      if (existing.digest !== digest) return "conflict";
+      this.db.run("INSERT OR IGNORE INTO aliases(request_id, operation_id) VALUES (?,?)", [message.requestId, existing.request_id]);
+      return existing.state === "unknown" ? "unknown" : "duplicate";
+    }
+    this.db.run("INSERT INTO operations(request_id, run_id, session_id, request_type, digest, state) VALUES (?,?,?,?,?,'accepted')", [
+      message.requestId,
+      typeof message.runId === "string" ? message.runId : null,
+      typeof message.sessionId === "string" ? message.sessionId : null,
+      message.type,
+      digest
+    ]);
+    return "new";
+  }
+  isUnknown(requestId) {
+    return this.row(requestId)?.state === "unknown";
+  }
+  unknown(requestId) {
+    const row = this.row(requestId);
+    if (row) this.db.run("UPDATE operations SET state='unknown' WHERE request_id=?", [row.request_id]);
+  }
+  unknownRun(runId) {
+    this.db.run("UPDATE operations SET state='unknown' WHERE run_id=? AND request_type IN ('exec_start','exec')", [runId]);
+  }
+  record(message) {
+    if (message.type === "exec_output" && typeof message.runId === "string" && (message.stream === "stdout" || message.stream === "stderr") && typeof message.data === "string") {
+      const runId = message.runId, stream = message.stream, data = message.data;
+      const offset = this.db.transaction(() => {
+        this.db.run("INSERT OR IGNORE INTO streams(run_id, stream) VALUES (?,?)", [runId, stream]);
+        const offset2 = this.db.query("SELECT bytes FROM streams WHERE run_id=? AND stream=?").get(runId, stream).bytes;
+        const bytes = Buffer.byteLength(data);
+        if (bytes) {
+          this.db.run("INSERT INTO output(run_id, stream, offset, bytes, data) VALUES (?,?,?,?,?)", [runId, stream, offset2, bytes, data]);
+          this.db.run("UPDATE streams SET bytes=bytes+? WHERE run_id=? AND stream=?", [bytes, runId, stream]);
+        }
+        return offset2;
+      })();
+      return { ...message, offset };
+    }
+    if ((message.type === "exec_exit" || message.type === "exec_error") && typeof message.runId === "string") {
+      const terminal = { ...message, ...this.lengths(message.runId) };
+      this.db.transaction(() => {
+        this.db.run("INSERT OR REPLACE INTO terminals(run_id,message) VALUES (?,?)", [message.runId, JSON.stringify(terminal)]);
+        this.db.run("UPDATE operations SET state='completed' WHERE run_id=? AND request_type='exec_start'", [message.runId]);
+      })();
+      return terminal;
+    }
+    if (typeof message.requestId === "string") {
+      const row = this.row(message.requestId);
+      if (row) {
+        const state = message.type === "exec_accepted" || message.type === "operation_queued" ? "preparing" : message.type === "exec_started" ? "running" : message.type === "operation_received" ? "accepted" : "completed";
+        if (message.type !== "operation_received")
+          this.db.run("UPDATE operations SET state=?, response=? WHERE request_id=?", [state, JSON.stringify(message), row.request_id]);
+      }
+    }
+    return message;
+  }
+  operations() {
+    return this.db.query(
+      "SELECT * FROM operations WHERE response IS NOT NULL OR state!='completed' UNION ALL SELECT aliases.request_id,operations.run_id,operations.session_id,operations.request_type,operations.digest,operations.state,operations.response FROM aliases JOIN operations ON operations.request_id=aliases.operation_id WHERE aliases.request_id!=operations.request_id AND (response IS NOT NULL OR state!='completed')"
+    ).all().map((row) => ({
+      requestId: row.request_id,
+      requestType: row.request_type,
+      state: row.state,
+      ...row.run_id ? { runId: row.run_id } : {},
+      ...row.session_id ? { sessionId: row.session_id } : {}
+    }));
+  }
+  response(requestId) {
+    const row = this.row(requestId);
+    return row?.response && row.state !== "unknown" ? { ...JSON.parse(row.response), requestId } : void 0;
+  }
+  responses(requestIds) {
+    const ids = /* @__PURE__ */ new Set([...requestIds, ...this.operations().map((operation) => operation.requestId)]);
+    return [...ids].flatMap((requestId) => {
+      const response = this.response(requestId);
+      return response ? [response] : [];
+    });
+  }
+  lengths(runId) {
+    const result = { stdoutBytes: 0, stderrBytes: 0 };
+    for (const row of this.db.query("SELECT stream,bytes FROM streams WHERE run_id=?").all(runId))
+      result[row.stream === "stdout" ? "stdoutBytes" : "stderrBytes"] = row.bytes;
+    return result;
+  }
+  outputCursors() {
+    const cursors = /* @__PURE__ */ new Map();
+    for (const stream of this.db.query("SELECT run_id,stream,acknowledged FROM streams").all()) {
+      const cursor = cursors.get(stream.run_id) ?? { runId: stream.run_id, stdoutBytes: 0, stderrBytes: 0 };
+      cursor[stream.stream === "stdout" ? "stdoutBytes" : "stderrBytes"] = stream.acknowledged;
+      cursors.set(stream.run_id, cursor);
+    }
+    return [...cursors.values()];
+  }
+  *output(offsets = []) {
+    const cursors = new Map(offsets.map((offset) => [offset.runId, offset]));
+    for (const stream of this.db.query("SELECT * FROM streams WHERE NOT EXISTS (SELECT 1 FROM operations WHERE operations.run_id=streams.run_id AND operations.state='unknown') ORDER BY rowid").all()) {
+      const supplied = cursors.get(stream.run_id);
+      const cursor = supplied ? stream.stream === "stdout" ? supplied.stdoutBytes : supplied.stderrBytes : stream.acknowledged;
+      if (cursor >= stream.bytes) continue;
+      const firstOffset = this.db.query("SELECT MAX(offset) AS offset FROM output WHERE run_id=? AND stream=? AND offset<=?").get(stream.run_id, stream.stream, cursor)?.offset ?? 0;
+      let nextChunk = firstOffset;
+      while (true) {
+        const row = this.db.query("SELECT offset,data FROM output WHERE run_id=? AND stream=? AND offset>=? AND offset<? AND offset+bytes>? ORDER BY offset LIMIT 1").get(stream.run_id, stream.stream, nextChunk, stream.bytes, cursor);
+        if (!row) break;
+        nextChunk = row.offset + 1;
+        yield { type: "exec_output", runId: stream.run_id, stream: stream.stream, offset: row.offset, data: row.data };
+      }
+    }
+  }
+  terminals() {
+    return this.db.query(
+      "SELECT message FROM terminals WHERE NOT EXISTS (SELECT 1 FROM operations WHERE operations.run_id=terminals.run_id AND operations.state='unknown')"
+    ).all().map((row) => JSON.parse(row.message));
+  }
+  acknowledgeOutput(runId, stream, offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0) return;
+    this.db.run("UPDATE streams SET acknowledged=MAX(acknowledged,MIN(bytes,?)) WHERE run_id=? AND stream=?", [offset, runId, stream]);
+  }
+  acknowledgeResult(requestId) {
+    const row = this.row(requestId);
+    if (row && row.request_type !== "exec_start")
+      this.db.run("UPDATE operations SET response=NULL WHERE request_id=? AND state='completed'", [row.request_id]);
+  }
+  acknowledgeTerminal(runId) {
+    this.db.transaction(() => {
+      this.db.run("DELETE FROM terminals WHERE run_id=?", [runId]);
+      this.db.run("DELETE FROM output WHERE run_id=?", [runId]);
+      this.db.run("UPDATE streams SET acknowledged=bytes WHERE run_id=?", [runId]);
+      this.db.run("UPDATE operations SET response=NULL WHERE run_id=? AND request_type='exec_start' AND state='completed'", [runId]);
+    })();
+  }
+  cancelSession(sessionId) {
+    this.db.run("INSERT OR IGNORE INTO cancelled_requests SELECT request_id FROM operations WHERE session_id=? AND state!='completed'", [
+      sessionId
+    ]);
+  }
+  isRequestCancelled(requestId) {
+    const row = this.row(requestId);
+    return !!row && this.db.query("SELECT request_id FROM cancelled_requests WHERE request_id=?").get(row.request_id) !== null;
+  }
+}
+export {
+  WorkerRecoveryStore,
+  workerOperationDigest
+};

package/dist/mjs/supervisor.mjs

@@ -6,6 +6,7 @@ const WORKER_RECONNECT_EXIT_CODE = 76;
 const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
 const WORKER_RECONNECT_DELAY_MS = 2e3;
 const WORKER_RECONNECT_JITTER_MS = 3e3;
+const WORKER_RECONNECT_MAX_DELAY_MS = 3e4;
 const SUPERVISOR_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 function defaultRuntimeSpawner(argv, options) {
   return Bun.spawn(argv, options);
@@ -13,9 +14,12 @@ function defaultRuntimeSpawner(argv, options) {
 function defaultRuntimeDelay(delayMs) {
   return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
-function workerReconnectDelayMs(random = Math.random) {
+function workerReconnectDelayMs(random = Math.random, attempt = 0) {
   const sample = Math.max(0, Math.min(1, random()));
-  return WORKER_RECONNECT_DELAY_MS + Math.floor(sample * WORKER_RECONNECT_JITTER_MS);
+  const exponent = Math.min(20, Math.max(0, Math.floor(attempt)));
+  const ceiling = Math.min(WORKER_RECONNECT_MAX_DELAY_MS, (WORKER_RECONNECT_DELAY_MS + WORKER_RECONNECT_JITTER_MS) * 2 ** exponent);
+  const floor = Math.min(WORKER_RECONNECT_DELAY_MS * 2 ** exponent, ceiling * 0.4);
+  return floor + Math.floor(sample * (ceiling - floor));
 }
 async function defaultRuntimeReaper(runtime) {
   await terminateProcessTree(runtime);
@@ -29,10 +33,11 @@ function signalExitCode(signal) {
 function osSignalNumber(signal) {
   return osConstants.signals[signal];
 }
-async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = defaultRuntimeSpawner, waitBeforeReconnect = defaultRuntimeDelay, reapCredentialRuntime = defaultRuntimeReaper, reconnectDelay = workerReconnectDelayMs) {
+async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = defaultRuntimeSpawner, waitBeforeReconnect = defaultRuntimeDelay, reapCredentialRuntime = defaultRuntimeReaper, reconnectDelay) {
   if (!process.argv[1]) {
     throw new Error("Cannot locate the r5d-worker entrypoint");
   }
+  let reconnectAttempt = 0;
   while (true) {
     const runtime = spawnRuntime([process.execPath, process.argv[1], ...argv], {
       stdin: "inherit",
@@ -81,7 +86,7 @@ async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = de
         continue;
       }
       if (exitCode === WORKER_RECONNECT_EXIT_CODE) {
-        const reconnectDelayMs = reconnectDelay();
+        const reconnectDelayMs = reconnectDelay?.() ?? workerReconnectDelayMs(Math.random, reconnectAttempt++);
         process.stderr.write(`[r5d-worker] reconnecting in ${reconnectDelayMs}ms
 `);
         await waitBeforeReconnect(reconnectDelayMs);
@@ -100,6 +105,7 @@ export {
   WORKER_RECONNECT_DELAY_MS,
   WORKER_RECONNECT_EXIT_CODE,
   WORKER_RECONNECT_JITTER_MS,
+  WORKER_RECONNECT_MAX_DELAY_MS,
   WORKER_RELOAD_EXIT_CODE,
   WORKER_RUNTIME_ENV,
   isRetryableWorkerServerStatus,

package/dist/types/main.d.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import type { WorkerLintPlansResult, WorkerUpdatePlanTaskResult } from "./plan-paths";
+import { WORKER_RESUMABLE_PROTOCOL, type WorkerRecoveryClientMessage, type WorkerRecoveryServerMessage } from "./recovery-protocol";
 import { Database } from "bun:sqlite";
 import type { WorkerGitIdentity } from "./git-identity";
 import { configureGitHubRegistryAuthFiles, type PreparedPrivateAuthFileGeneration } from "./registry-auth";
@@ -135,8 +136,11 @@ export type WorkerSessionTarget = {
     ownerUserId: string;
     rootProfile: "visible_projects" | "canonical_sync";
 };
-type WorkerClientMessage = {
+type WorkerClientMessage = WorkerRecoveryClientMessage | {
     type: "hello";
+    resumableProtocol: typeof WORKER_RESUMABLE_PROTOCOL;
+    runtimeId: string;
+    ledgerId: string;
     hostInfo?: Record<string, unknown>;
     startupReady?: boolean;
 } | {
@@ -278,7 +282,7 @@ type WorkerClientMessage = {
     installedR5dctlVersion?: string;
     error?: string;
 };
-type WorkerServerMessage = {
+type WorkerServerMessage = WorkerRecoveryServerMessage | {
     type: "connected";
     label: string;
     workerId: string;
@@ -415,15 +419,18 @@ type WorkerServerMessage = {
     }>;
 } | {
     type: "pty_input";
+    requestId: string;
     ptyId: string;
     data: string;
 } | {
     type: "pty_resize";
+    requestId: string;
     ptyId: string;
     cols: number;
     rows: number;
 } | {
     type: "pty_close";
+    requestId: string;
     ptyId: string;
 } | {
     type: "read_plan";

package/dist/types/recovery-output-window.d.ts

@@ -0,0 +1,19 @@
+import type { WorkerOutputOffsets } from "./recovery-protocol";
+export type WorkerOutputFrame = {
+    type: "exec_output";
+    runId: string;
+    stream: "stdout" | "stderr";
+    offset: number;
+    data: string;
+};
+/** Bound outstanding application bytes, including data already buffered by the server's socket. */
+export declare class WorkerOutputWindow {
+    private readonly windowBytes;
+    private sent;
+    private acknowledged;
+    private outstanding;
+    constructor(windowBytes?: number);
+    reset(cursors: WorkerOutputOffsets[]): void;
+    send(frame: WorkerOutputFrame, send: (frame: WorkerOutputFrame) => boolean, bufferedAmount?: number): boolean;
+    acknowledge(runId: string, stream: "stdout" | "stderr", offset: number): void;
+}

package/dist/types/recovery-protocol.d.ts

@@ -0,0 +1,59 @@
+/** The application protocol survives replacement of its WebSocket transport. */
+export declare const WORKER_RESUMABLE_PROTOCOL: 1;
+export declare const WORKER_RECOVERY_TIMEOUT_MS: number;
+export type WorkerOperationRecovery = {
+    requestId: string;
+    runId?: string;
+    sessionId?: string;
+    requestType?: string;
+    state: "accepted" | "preparing" | "running" | "completed" | "unknown";
+};
+export type WorkerOutputOffsets = {
+    runId: string;
+    stdoutBytes: number;
+    stderrBytes: number;
+};
+export type WorkerRecoveryServerMessage = {
+    type: "recovery_request";
+    recoveryId: string;
+    requests: string[];
+    outputOffsets: WorkerOutputOffsets[];
+} | {
+    type: "recovery_ready";
+    recoveryId: string;
+    leaseMs: number;
+} | {
+    type: "operation_result_ack";
+    requestId: string;
+} | {
+    type: "exec_output_ack";
+    runId: string;
+    stream: "stdout" | "stderr";
+    nextOffset: number;
+} | {
+    type: "worker_execution_lease";
+    leaseMs: number;
+} | {
+    type: "cancel_session";
+    sessionId: string;
+    cancellationId: string;
+};
+export type WorkerRecoveryClientMessage = {
+    type: "recovery_state";
+    recoveryId: string;
+    runtimeId: string;
+    ledgerId: string;
+    operations: WorkerOperationRecovery[];
+} | {
+    type: "recovery_complete";
+    recoveryId: string;
+} | {
+    type: "operation_received";
+    requestId: string;
+} | {
+    type: "operation_completed";
+    requestId: string;
+} | {
+    type: "cancel_session_ack";
+    cancellationId: string;
+};

package/dist/types/recovery-store.d.ts

@@ -0,0 +1,38 @@
+import type { WorkerOperationRecovery, WorkerOutputOffsets } from "./recovery-protocol";
+type Message = {
+    type: string;
+    [key: string]: unknown;
+};
+/** Stable semantic identity, independent of JSON key order and transport request aliases. */
+export declare function workerOperationDigest(message: Message): string;
+/** The receipt is committed before a handler can mutate anything. Unknown crash outcomes never replay effects. */
+export declare class WorkerRecoveryStore {
+    private readonly db;
+    readonly ledgerId: string;
+    constructor(filename: string);
+    close(): void;
+    private row;
+    admit(message: Message & {
+        requestId: string;
+    }): "new" | "duplicate" | "unknown" | "conflict";
+    isUnknown(requestId: string): boolean;
+    unknown(requestId: string): void;
+    unknownRun(runId: string): void;
+    record(message: Message): Message;
+    operations(): WorkerOperationRecovery[];
+    response(requestId: string): Message | undefined;
+    responses(requestIds: string[]): Message[];
+    lengths(runId: string): {
+        stdoutBytes: number;
+        stderrBytes: number;
+    };
+    outputCursors(): WorkerOutputOffsets[];
+    output(offsets?: WorkerOutputOffsets[]): Generator<Message>;
+    terminals(): Message[];
+    acknowledgeOutput(runId: string, stream: "stdout" | "stderr", offset: number): void;
+    acknowledgeResult(requestId: string): void;
+    acknowledgeTerminal(runId: string): void;
+    cancelSession(sessionId: string): void;
+    isRequestCancelled(requestId: string): boolean;
+}
+export {};

package/dist/types/supervisor.d.ts

@@ -5,6 +5,7 @@ export declare const WORKER_RECONNECT_EXIT_CODE = 76;
 export declare const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
 export declare const WORKER_RECONNECT_DELAY_MS = 2000;
 export declare const WORKER_RECONNECT_JITTER_MS = 3000;
+export declare const WORKER_RECONNECT_MAX_DELAY_MS = 30000;
 type RuntimeProcess = KillableSubprocess;
 export type RuntimeSpawner = (argv: string[], options: {
     stdin: "inherit";
@@ -16,7 +17,7 @@ export type RuntimeSpawner = (argv: string[], options: {
 export type RuntimeDelay = (delayMs: number) => Promise<void>;
 export type RuntimeReaper = (runtime: RuntimeProcess) => Promise<void>;
 export type RuntimeReconnectDelay = () => number;
-export declare function workerReconnectDelayMs(random?: () => number): number;
+export declare function workerReconnectDelayMs(random?: () => number, attempt?: number): number;
 export declare function isRetryableWorkerServerStatus(status: number): boolean;
 export declare function superviseWorkerRuntime(argv: string[], env?: Record<string, string | undefined>, spawnRuntime?: RuntimeSpawner, waitBeforeReconnect?: RuntimeDelay, reapCredentialRuntime?: RuntimeReaper, reconnectDelay?: RuntimeReconnectDelay): Promise<number>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.108",
+  "version": "0.0.109",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",