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

package/dist/effect/index.cjs

@@ -14156,7 +14156,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.37";
+var packageVersion = "10.0.0-alpha.38";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -15188,6 +15188,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) {
@@ -16607,6 +16667,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). */
@@ -16621,6 +16682,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({
@@ -16693,6 +16755,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,
@@ -16895,6 +16959,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 {