@camunda8/orchestration-cluster-api 10.0.0-alpha.41 → 10.0.0-alpha.43

package/dist/{chunk-267HUCFY.js → chunk-JKBNNUPT.js}

@@ -1,6 +1,6 @@
 import {
   createLogger
-} from "./chunk-KQ4UL2WX.js";
+} from "./chunk-LXWPMQOS.js";
 import {
   __require
 } from "./chunk-DGUM43GV.js";
@@ -63,7 +63,127 @@ function createLiveClock(source = () => Date.now()) {
   };
   return { now, sleep, deadline };
 }
+function nextTick(fn) {
+  setTimeout(fn, 0);
+}
+function requireDuration(ms, label) {
+  if (!Number.isFinite(ms) || ms < 0) {
+    throw new RangeError(`${label} needs a finite, non-negative duration in ms, got ${ms}`);
+  }
+}
 var liveClock = createLiveClock();
+function createTestClock(options = {}) {
+  const { start = 0, autoAdvance = true } = options;
+  let current = start;
+  let nowCalls = 0;
+  const sleeps = [];
+  let waiters = [];
+  const settleDue = () => {
+    const due = waiters.filter((w) => w.at <= current);
+    waiters = waiters.filter((w) => w.at > current);
+    for (const w of due) {
+      w.detach();
+      w.resolve();
+    }
+  };
+  const now = () => {
+    nowCalls += 1;
+    return current;
+  };
+  const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    requireDuration(ms, "clock.sleep");
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    sleeps.push(ms);
+    const waiter = { at: current + ms, resolve, detach: () => {
+    } };
+    if (signal) {
+      const onAbort = () => {
+        waiters = waiters.filter((w) => w !== waiter);
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      waiter.detach = () => signal.removeEventListener("abort", onAbort);
+    }
+    waiters.push(waiter);
+    if (autoAdvance) {
+      nextTick(() => {
+        if (!waiters.includes(waiter)) return;
+        current = Math.max(current, waiter.at);
+        settleDue();
+      });
+    }
+  });
+  const advance = async (ms) => {
+    requireDuration(ms, "clock.advance");
+    current += ms;
+    settleDue();
+    await new Promise((resolve) => nextTick(resolve));
+  };
+  return {
+    now,
+    sleep,
+    advance,
+    // A deadline bounds liveness rather than pacing cadence: it stays on real time even
+    // here, because code guarded by one should time out rather than hang on a pinned clock.
+    deadline: (ms) => liveClock.deadline(ms),
+    get sleeps() {
+      return sleeps;
+    },
+    get nowCalls() {
+      return nowCalls;
+    },
+    get pending() {
+      return waiters.length;
+    }
+  };
+}
+function createEngineClock(target, options = {}) {
+  const { start = Date.now() } = options;
+  let current = start;
+  const sleeps = [];
+  let queue = Promise.resolve();
+  const enqueue = (fn) => {
+    const run = queue.then(fn, fn);
+    queue = run.catch(() => {
+    });
+    return run;
+  };
+  const pinTo = (epochMs) => enqueue(async () => {
+    if (epochMs <= current) return;
+    await target.pinClock({ timestamp: epochMs });
+    current = epochMs;
+  });
+  const sleep = async (ms, signal) => {
+    requireDuration(ms, "clock.sleep");
+    if (signal?.aborted) throw signal.reason;
+    sleeps.push(ms);
+    await pinTo(current + ms);
+    await new Promise((resolve) => nextTick(resolve));
+    if (signal?.aborted) throw signal.reason;
+  };
+  return {
+    now: () => current,
+    sleep,
+    async pin(epochMs) {
+      if (!Number.isFinite(epochMs)) {
+        throw new RangeError(`clock.pin needs a finite epoch-ms instant, got ${epochMs}`);
+      }
+      await pinTo(epochMs);
+    },
+    async reset() {
+      await target.resetClock();
+    },
+    // A deadline bounds liveness, so it stays on real time: a request timeout must fire even
+    // though engine time only moves when something asks it to.
+    deadline: (ms) => liveClock.deadline(ms),
+    get sleeps() {
+      return sleeps;
+    }
+  };
+}
 
 // src/runtime/errors.ts
 function isSdkError(e) {
@@ -4081,6 +4201,7 @@ var OAuthManager = class {
         if (attempt === 0) {
           const evt = {
             type: "auth.start",
+            // biome-ignore lint/plugin: telemetry event timestamp: must be real wall-clock so emitted events correlate with external logs, and never drives cadence
             ts: Date.now(),
             audience: this.cfg.tokenAudience,
             endpoint: this.cfg.oauth.oauthUrl,
@@ -4132,6 +4253,7 @@ var OAuthManager = class {
         try {
           const evt = {
             type: "auth.success",
+            // biome-ignore lint/plugin: telemetry event timestamp: must be real wall-clock so emitted events correlate with external logs, and never drives cadence
             ts: Date.now(),
             audience: this.cfg.tokenAudience,
             endpoint: this.cfg.oauth.oauthUrl,
@@ -4156,6 +4278,7 @@ var OAuthManager = class {
         try {
           this.tHooks?.retry?.({
             type: "retry",
+            // biome-ignore lint/plugin: telemetry event timestamp: must be real wall-clock so emitted events correlate with external logs, and never drives cadence
             ts: Date.now(),
             attempt,
             nextDelayMs: Math.round(sleep),
@@ -4171,6 +4294,7 @@ var OAuthManager = class {
     try {
       const evt = {
         type: "auth.error",
+        // biome-ignore lint/plugin: telemetry event timestamp: must be real wall-clock so emitted events correlate with external logs, and never drives cadence
         ts: Date.now(),
         audience: this.cfg.tokenAudience,
         endpoint: this.cfg.oauth.oauthUrl,
@@ -5285,7 +5409,7 @@ function installAuthInterceptor(client2, getStrategy, getAuthHeaders) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.41";
+var packageVersion = "10.0.0-alpha.43";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -5933,6 +6057,7 @@ function detectExtrasAndMaybeThrow(opts) {
         const payload = {
           operationId,
           extras,
+          // biome-ignore lint/plugin: capture-artifact timestamp: records when the capture was written, not cadence
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           sample: value
         };
@@ -6104,8 +6229,8 @@ var BackpressureManager = class {
   // current backoff delay in ms (0 = no backoff)
   constructor(opts = {}) {
     this.logger = opts.logger;
-    this.now = opts.now || (() => Date.now());
-    this.sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.now = opts.now || (() => liveClock.now());
+    this.sleep = opts.sleep || ((ms) => liveClock.sleep(ms));
     this.cfg = {
       enabled: true,
       initialMaxConcurrency: null,
@@ -21471,6 +21596,8 @@ var CamundaClient = CamundaClientBase;
 export {
   createLiveClock,
   liveClock,
+  createTestClock,
+  createEngineClock,
   isSdkError,
   CamundaValidationError,
   EventualConsistencyTimeoutError,
@@ -21488,4 +21615,4 @@ export {
   createCamundaClient,
   CamundaClient
 };
-//# sourceMappingURL=chunk-267HUCFY.js.map
+//# sourceMappingURL=chunk-JKBNNUPT.js.map