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

package/dist/effect/index.d.cts

@@ -1,7 +1,7 @@
 import * as effect_Cause from 'effect/Cause';
 import * as effect_Types from 'effect/Types';
 import { Context, Effect, Duration, Layer, Schedule, Cause, Stream, Scope } from 'effect';
-import { C as CamundaClient, a as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-DKCeKUmK.cjs';
+import { C as CamundaClient, a as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-CvdIL8uM.cjs';
 import 'zod';
 import '../logger-D-p21VHo.cjs';
 

package/dist/effect/index.d.ts

@@ -1,7 +1,7 @@
 import * as effect_Cause from 'effect/Cause';
 import * as effect_Types from 'effect/Types';
 import { Context, Effect, Duration, Layer, Schedule, Cause, Stream, Scope } from 'effect';
-import { C as CamundaClient, a as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-BdKNRD2i.js';
+import { C as CamundaClient, a as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-BMOpGKIo.js';
 import 'zod';
 import '../logger-D-p21VHo.js';
 

package/dist/effect/index.js

@@ -2,7 +2,7 @@ import {
   CamundaValidationError,
   EventualConsistencyTimeoutError,
   createCamundaClient
-} from "../chunk-QMVXOINT.js";
+} from "../chunk-LPNUMNEM.js";
 import "../chunk-KQ4UL2WX.js";
 import "../chunk-DGUM43GV.js";
 

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.38";
 
 // 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) {
@@ -16696,6 +16758,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 +16773,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 +16846,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 +17050,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 +32477,11 @@ var index_default = createCamundaClient;
   createCamundaClient,
   createCamundaClientLoose,
   createCamundaResultClient,
+  createLiveClock,
   isErr,
   isOk,
   isSdkError,
+  liveClock,
   nextPageRequest,
   paginate,
   variableNamesFromSchema