@camunda8/orchestration-cluster-api 10.0.0-alpha.37 → 10.0.0-alpha.39

package/dist/index.cjs

@@ -9612,10 +9612,12 @@ __export(index_exports, {
   createCamundaClient: () => createCamundaClient,
   createCamundaClientLoose: () => createCamundaClientLoose,
   createCamundaResultClient: () => createCamundaResultClient,
+  createLiveClock: () => createLiveClock,
   default: () => index_default,
   isErr: () => isErr,
   isOk: () => isOk,
   isSdkError: () => isSdkError,
+  liveClock: () => liveClock,
   nextPageRequest: () => nextPageRequest,
   paginate: () => paginate,
   variableNamesFromSchema: () => variableNamesFromSchema
@@ -14239,7 +14241,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.37";
+var packageVersion = "10.0.0-alpha.39";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -15271,6 +15273,66 @@ var BackpressureManager = class {
   }
 };
 
+// src/runtime/clock.ts
+var SLEW_DIVISOR = 16;
+var MAX_TIMER_MS = 2147483647;
+function scheduleLong(ms, onElapsed) {
+  let remaining = Math.max(0, ms);
+  let timer;
+  const step = () => {
+    const slice = Math.min(remaining, MAX_TIMER_MS);
+    remaining -= slice;
+    timer = setTimeout(remaining > 0 ? step : onElapsed, slice);
+  };
+  step();
+  return () => clearTimeout(timer);
+}
+function createLiveClock(source = Date.now) {
+  let lastSource = source();
+  let offsetMs = 0;
+  let slewCreditMs = 0;
+  const now2 = () => {
+    const observed = source();
+    if (observed < lastSource) {
+      offsetMs += lastSource - observed;
+    } else if (offsetMs > 0) {
+      slewCreditMs += observed - lastSource;
+      const repay = Math.floor(slewCreditMs / SLEW_DIVISOR);
+      if (repay > 0) {
+        slewCreditMs -= repay * SLEW_DIVISOR;
+        offsetMs -= Math.min(offsetMs, repay);
+      }
+    }
+    lastSource = observed;
+    return observed + offsetMs;
+  };
+  const sleep2 = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const cancel = scheduleLong(ms, () => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    });
+    function onAbort() {
+      cancel();
+      reject(signal?.reason);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  const deadline = (ms) => {
+    const controller = new AbortController();
+    const cancel = scheduleLong(
+      ms,
+      () => controller.abort(new DOMException(`Timed out after ${ms}ms`, "TimeoutError"))
+    );
+    return { signal: controller.signal, dispose: cancel };
+  };
+  return { now: now2, sleep: sleep2, deadline };
+}
+var liveClock = createLiveClock();
+
 // src/runtime/typedVariables.ts
 var TypedVariablesError = class extends Error {
   constructor(message, options) {
@@ -15504,6 +15566,51 @@ function nextActivationRetryDelayMs(attempt, cfg, rng) {
   return Number.isFinite(cfg.pollIntervalMs) ? Math.max(0, Math.round(cfg.pollIntervalMs)) : 0;
 }
 
+// src/runtime/workerGracefulStop.ts
+async function stopWorkerGracefully(deps, opts) {
+  const waitUpToMs = opts?.waitUpToMs ?? 5e3;
+  const checkIntervalMs = opts?.checkIntervalMs ?? 10;
+  deps.haltPolling();
+  const start = liveClock.now();
+  const inFlight = deps.inFlightActivation();
+  if (inFlight) {
+    const budget = liveClock.deadline(waitUpToMs);
+    try {
+      await Promise.race([
+        inFlight,
+        new Promise((_, rej) => {
+          const reject = () => rej(new Error("activation.wait.timeout"));
+          if (budget.signal.aborted) reject();
+          else budget.signal.addEventListener("abort", reject, { once: true });
+        })
+      ]);
+    } catch (e) {
+      if (e && e.message === "activation.wait.timeout") {
+        deps.log.debug("worker.gracefulStop.activationTimeout");
+      }
+    } finally {
+      budget.dispose();
+    }
+  }
+  while (deps.activeJobs() > 0 && liveClock.now() - start < waitUpToMs) {
+    await liveClock.sleep(checkIntervalMs);
+  }
+  const timedOut = deps.activeJobs() > 0;
+  if (timedOut) {
+    const pending = deps.inFlightActivation();
+    if (pending?.cancel) {
+      try {
+        pending.cancel();
+      } catch {
+      }
+    }
+    deps.log.debug("worker.gracefulStop.timeout", { remaining: deps.activeJobs() });
+  } else {
+    deps.log.debug("worker.gracefulStop.done");
+  }
+  return { remainingJobs: deps.activeJobs(), timedOut };
+}
+
 // src/runtime/workerStartGate.ts
 var WorkerStartGate = class {
   /**
@@ -15650,42 +15757,19 @@ var JobWorker = class {
    * If timeout is reached, falls back to hard stop logic (cancels activation if still pending).
    */
   async stopGracefully(opts) {
-    const waitUpToMs = opts?.waitUpToMs ?? 5e3;
-    const checkIntervalMs = opts?.checkIntervalMs ?? 10;
-    this._stopped = true;
-    if (this._pollTimer) clearTimeout(this._pollTimer);
-    this._pollTimer = null;
-    const start = Date.now();
-    if (this._inFlightActivation) {
-      try {
-        await Promise.race([
-          this._inFlightActivation,
-          new Promise(
-            (_, rej) => setTimeout(() => rej(new Error("activation.wait.timeout")), waitUpToMs)
-          )
-        ]);
-      } catch (e) {
-        if (e && e.message === "activation.wait.timeout") {
-          this._log.debug("worker.gracefulStop.activationTimeout");
-        }
-      }
-    }
-    while (this._activeJobs > 0 && Date.now() - start < waitUpToMs) {
-      await new Promise((r) => setTimeout(r, checkIntervalMs));
-    }
-    const timedOut = this._activeJobs > 0;
-    if (timedOut) {
-      if (this._inFlightActivation?.cancel) {
-        try {
-          this._inFlightActivation.cancel();
-        } catch {
-        }
-      }
-      this._log.debug("worker.gracefulStop.timeout", { remaining: this._activeJobs });
-    } else {
-      this._log.debug("worker.gracefulStop.done");
-    }
-    return { remainingJobs: this._activeJobs, timedOut };
+    return stopWorkerGracefully(
+      {
+        haltPolling: () => {
+          this._stopped = true;
+          if (this._pollTimer) clearTimeout(this._pollTimer);
+          this._pollTimer = null;
+        },
+        activeJobs: () => this._activeJobs,
+        inFlightActivation: () => this._inFlightActivation,
+        log: this._log
+      },
+      opts
+    );
   }
   _scheduleNext(delayMs) {
     if (this._stopped) return;
@@ -15978,42 +16062,19 @@ var ThreadedJobWorker = class {
     this._log.info("worker.stop");
   }
   async stopGracefully(opts) {
-    const waitUpToMs = opts?.waitUpToMs ?? 5e3;
-    const checkIntervalMs = opts?.checkIntervalMs ?? 10;
-    this._stopped = true;
-    if (this._pollTimer) clearTimeout(this._pollTimer);
-    this._pollTimer = null;
-    const start = Date.now();
-    if (this._inFlightActivation) {
-      try {
-        await Promise.race([
-          this._inFlightActivation,
-          new Promise(
-            (_, rej) => setTimeout(() => rej(new Error("activation.wait.timeout")), waitUpToMs)
-          )
-        ]);
-      } catch (e) {
-        if (e && e.message === "activation.wait.timeout") {
-          this._log.debug("worker.gracefulStop.activationTimeout");
-        }
-      }
-    }
-    while (this._activeJobs > 0 && Date.now() - start < waitUpToMs) {
-      await new Promise((r) => setTimeout(r, checkIntervalMs));
-    }
-    const timedOut = this._activeJobs > 0;
-    if (timedOut) {
-      if (this._inFlightActivation?.cancel) {
-        try {
-          this._inFlightActivation.cancel();
-        } catch {
-        }
-      }
-      this._log.debug("worker.gracefulStop.timeout", { remaining: this._activeJobs });
-    } else {
-      this._log.debug("worker.gracefulStop.done");
-    }
-    return { remainingJobs: this._activeJobs, timedOut };
+    return stopWorkerGracefully(
+      {
+        haltPolling: () => {
+          this._stopped = true;
+          if (this._pollTimer) clearTimeout(this._pollTimer);
+          this._pollTimer = null;
+        },
+        activeJobs: () => this._activeJobs,
+        inFlightActivation: () => this._inFlightActivation,
+        log: this._log
+      },
+      opts
+    );
   }
   // ─── Job dispatch ───
   _drainQueue() {
@@ -16696,6 +16757,7 @@ var CamundaClientBase = class {
   _validation = new ValidationManager({ req: "none", res: "none" });
   _log = createLogger();
   _bp;
+  _clock = liveClock;
   /** Registered job workers created via createJobWorker (lifecycle managed by user). */
   _workers = [];
   /** Shared thread pool for all threaded job workers (lazy-initialised on first use). */
@@ -16710,6 +16772,7 @@ var CamundaClientBase = class {
   _overrides = {};
   constructor(opts = {}) {
     if (opts.config) this._overrides = { ...opts.config };
+    this._clock = opts.clock ?? liveClock;
     const { config } = hydrateConfig({ overrides: this._overrides, env: opts.env });
     this._config = deepFreeze2(config);
     this._log = createLogger({
@@ -16782,6 +16845,8 @@ var CamundaClientBase = class {
     this.emitSupportLogPreamble();
     this._bp = new BackpressureManager({
       logger: this._log.scope("bp"),
+      now: () => this._clock.now(),
+      sleep: (ms) => this._clock.sleep(ms),
       config: {
         enabled: this._config.backpressure.enabled,
         observeOnly: this._config.backpressure.observeOnly,
@@ -16984,6 +17049,10 @@ var CamundaClientBase = class {
   _evaluateResponse(raw, opId, buildBackpressureError) {
     return evaluateSdkResponse(raw, { opId, buildBackpressureError });
   }
+  /** Clock backing SDK-internal cadence. The injected one when supplied, else the live clock. */
+  get clock() {
+    return this._clock;
+  }
   /** Public accessor for current backpressure adaptive limiter state (stable) */
   getBackpressureState() {
     try {
@@ -32407,9 +32476,11 @@ var index_default = createCamundaClient;
   createCamundaClient,
   createCamundaClientLoose,
   createCamundaResultClient,
+  createLiveClock,
   isErr,
   isOk,
   isSdkError,
+  liveClock,
   nextPageRequest,
   paginate,
   variableNamesFromSchema