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

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-DwHGY8e9.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-Dxa-jdNc.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-JKBNNUPT.js";
+import "../chunk-LXWPMQOS.js";
 import "../chunk-DGUM43GV.js";
 
 // src/effect.ts

package/dist/index.cjs

@@ -9608,7 +9608,9 @@ __export(index_exports, {
   createCamundaClient: () => createCamundaClient,
   createCamundaClientLoose: () => createCamundaClientLoose,
   createCamundaResultClient: () => createCamundaResultClient,
+  createEngineClock: () => createEngineClock,
   createLiveClock: () => createLiveClock,
+  createTestClock: () => createTestClock,
   default: () => index_default,
   isErr: () => isErr,
   isOk: () => isOk,
@@ -12766,7 +12768,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/auth.ts
 var CamundaAuthError = class extends Error {
@@ -12936,6 +13058,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 +13110,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 +13135,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 +13151,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 +14445,7 @@ function createLogger(opts = {}) {
 }
 
 // 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 {
@@ -14965,6 +15091,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 +15263,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,
@@ -32516,7 +32643,9 @@ var index_default = createCamundaClient;
   createCamundaClient,
   createCamundaClientLoose,
   createCamundaResultClient,
+  createEngineClock,
   createLiveClock,
+  createTestClock,
   isErr,
   isOk,
   isSdkError,