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

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, Stream, Duration, Layer, Schedule, Cause, Scope } from 'effect';
-import { S as SearchPaginateOptions, P as Paginator, a as PaginationMode, C as ConsistencyOptions, b as SearchResponse, c as CamundaClient, d as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-HroU9acH.cjs';
+import { S as SearchPaginateOptions, P as Paginator, a as PaginationMode, C as ConsistencyOptions, b as SearchResponse, c as CamundaClient, d as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-BdWYcKHb.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, Stream, Duration, Layer, Schedule, Cause, Scope } from 'effect';
-import { S as SearchPaginateOptions, P as Paginator, a as PaginationMode, C as ConsistencyOptions, b as SearchResponse, c as CamundaClient, d as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-BlKXG8gE.js';
+import { S as SearchPaginateOptions, P as Paginator, a as PaginationMode, C as ConsistencyOptions, b as SearchResponse, c as CamundaClient, d as CamundaOptions, A as ActivatedJobResult } from '../CamundaClient-2kGcsFZx.js';
 import 'zod';
 import '../logger-D-p21VHo.js';
 

package/dist/effect/index.js

@@ -3,8 +3,8 @@ import {
   EventualConsistencyTimeoutError,
   createCamundaClient,
   nextPageRequest
-} from "../chunk-267HUCFY.js";
-import "../chunk-KQ4UL2WX.js";
+} from "../chunk-4F4DVIJW.js";
+import "../chunk-LXWPMQOS.js";
 import "../chunk-DGUM43GV.js";
 
 // src/effect.ts

package/dist/index.cjs

@@ -9609,6 +9609,7 @@ __export(index_exports, {
   createCamundaClientLoose: () => createCamundaClientLoose,
   createCamundaResultClient: () => createCamundaResultClient,
   createLiveClock: () => createLiveClock,
+  createTestClock: () => createTestClock,
   default: () => index_default,
   isErr: () => isErr,
   isOk: () => isOk,
@@ -12767,6 +12768,82 @@ function createLiveClock(source = () => Date.now()) {
   return { now, sleep, deadline };
 }
 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 nextTick = (fn) => {
+    setTimeout(fn, 0);
+  };
+  const now = () => {
+    nowCalls += 1;
+    return current;
+  };
+  const requireDuration = (ms, label) => {
+    if (!Number.isFinite(ms) || ms < 0) {
+      throw new RangeError(`${label} needs a finite, non-negative duration in ms, got ${ms}`);
+    }
+  };
+  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;
+    }
+  };
+}
 
 // src/runtime/auth.ts
 var CamundaAuthError = class extends Error {
@@ -12936,6 +13013,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,
@@ -12987,6 +13065,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,
@@ -13011,6 +13090,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),
@@ -13026,6 +13106,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,
@@ -14319,7 +14400,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.41";
+var packageVersion = "10.0.0-alpha.42";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -14965,6 +15046,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
         };
@@ -15136,8 +15218,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,
@@ -32517,6 +32599,7 @@ var index_default = createCamundaClient;
   createCamundaClientLoose,
   createCamundaResultClient,
   createLiveClock,
+  createTestClock,
   isErr,
   isOk,
   isSdkError,