@camunda8/orchestration-cluster-api 10.0.0-alpha.30 → 10.0.0-alpha.31

package/dist/effect/index.d.cts

@@ -0,0 +1,119 @@
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { Context, Effect, Duration, Layer } from 'effect';
+import { C as CamundaClient, a as CamundaOptions } from '../CamundaClient-esvUSLtB.cjs';
+import 'zod';
+import '../logger-D-p21VHo.cjs';
+
+declare const CamundaValidationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "CamundaValidationError";
+} & Readonly<A>;
+/** A request/response validation failure surfaced by the SDK. */
+declare class CamundaValidationError extends CamundaValidationError_base<{
+    readonly side: 'request' | 'response';
+    readonly operationId?: string;
+    readonly summary: string;
+    readonly issues: string[];
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const EventualConsistencyTimeout_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "EventualConsistencyTimeout";
+} & Readonly<A>;
+/** An eventual-consistency poll that did not converge within its budget. */
+declare class EventualConsistencyTimeout extends EventualConsistencyTimeout_base<{
+    readonly attempts?: number;
+    readonly elapsedMs?: number;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const HttpError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "HttpError";
+} & Readonly<A>;
+/** An HTTP-level failure (non-2xx / transport carrying a status). */
+declare class HttpError extends HttpError_base<{
+    readonly status?: number;
+    readonly body?: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const CamundaGenericError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "CamundaGenericError";
+} & Readonly<A>;
+/** Any other thrown value that does not map to a more specific tag. */
+declare class CamundaGenericError extends CamundaGenericError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+/** The typed error channel for every Effect the client produces. */
+type DomainError = CamundaValidationError | EventualConsistencyTimeout | HttpError | CamundaGenericError;
+/** The tag literals of the {@link DomainError} union. */
+type DomainErrorTag = DomainError['_tag'];
+/** Keys of `C` whose values are callable. */
+type FnKeys<C> = {
+    [K in keyof C]: C[K] extends (...a: any) => any ? K : never;
+}[keyof C];
+/** Maps every method of `C` to an Effect-returning method, preserving non-fn members. */
+type Effectify<C> = {
+    [K in FnKeys<C>]: C[K] extends (...a: infer A) => infer R ? (...a: A) => Effect.Effect<Awaited<R>, DomainError, never> : never;
+} & {
+    inner: C;
+} & {
+    [K in Exclude<keyof C, FnKeys<C>>]: C[K];
+};
+/** The Effect-flavoured Camunda client. Every operation returns an `Effect`. */
+type CamundaEffectClient = Effectify<CamundaClient>;
+/**
+ * Create an Effect-flavoured Camunda client.
+ *
+ * Every `CamundaClient` method becomes `(...args) => Effect.Effect<Awaited<R>,
+ * DomainError, never>`. Failures are narrowed into the tagged {@link DomainError}
+ * union so callers use `Effect.catchTag`/`catchTags`. The underlying throwing
+ * client is reachable via the `.inner` escape hatch.
+ *
+ * @description Camunda Effect Client. See the README and [this test](https://github.com/camunda/orchestration-cluster-api-js/blob/main/tests-integration/effect.test.ts) for example usage.
+ */
+declare function createCamundaEffectClient(options?: CamundaOptions): CamundaEffectClient;
+/**
+ * Retry an effect with exponential backoff (+ jitter), capped attempts, and an
+ * optional predicate over the error.
+ */
+declare function retryWithBackoff<A, E, R>(effect: Effect.Effect<A, E, R>, opts: {
+    max: number;
+    baseDelay?: Duration.Input;
+    while?: (e: E) => boolean;
+}): Effect.Effect<A, E, R>;
+/**
+ * Fail an effect with a real interruption if it does not settle within `duration`
+ * (true interruption, not a best-effort `Promise.race`).
+ */
+declare function withTimeout<A, E, R>(effect: Effect.Effect<A, E, R>, duration: Duration.Input, onTimeout?: () => E | EventualConsistencyTimeout): Effect.Effect<A, E | EventualConsistencyTimeout, R>;
+/**
+ * Poll `effect` on the Effect `Clock` until `predicate` holds, timing out to
+ * {@link EventualConsistencyTimeout} once `waitUpTo` elapses. Because it uses the
+ * Effect `Clock` (not `Date.now`/`setTimeout`), `TestClock.adjust` advances it
+ * deterministically in tests — no real-clock burn.
+ */
+declare function eventually<A, E, R>(effect: Effect.Effect<A, E, R>, predicate: (a: A) => boolean, opts: {
+    waitUpTo: Duration.Input;
+    interval?: Duration.Input;
+}): Effect.Effect<A, E | EventualConsistencyTimeout, R>;
+declare const CamundaEffect_base: Context.ServiceClass<CamundaEffect, "CamundaEffect", CamundaEffectClient>;
+/**
+ * `Context` service key for the Effect Camunda client. Compose worker/orchestration
+ * code against this tag and provide {@link layer} (or a test double) via `Layer`.
+ */
+declare class CamundaEffect extends CamundaEffect_base {
+}
+/**
+ * A `Layer` that constructs a {@link CamundaEffectClient} and provides it as the
+ * {@link CamundaEffect} service. Swap in a test double by providing a different
+ * `Layer` for the same tag.
+ */
+declare function layer(options?: CamundaOptions): Layer.Layer<CamundaEffect>;
+
+export { CamundaEffect, type CamundaEffectClient, CamundaGenericError, CamundaValidationError, type DomainError, type DomainErrorTag, type Effectify, EventualConsistencyTimeout, type FnKeys, HttpError, createCamundaEffectClient, eventually, layer, retryWithBackoff, withTimeout };

package/dist/effect/index.d.ts

@@ -0,0 +1,119 @@
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { Context, Effect, Duration, Layer } from 'effect';
+import { C as CamundaClient, a as CamundaOptions } from '../CamundaClient-D95Qr9pC.js';
+import 'zod';
+import '../logger-D-p21VHo.js';
+
+declare const CamundaValidationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "CamundaValidationError";
+} & Readonly<A>;
+/** A request/response validation failure surfaced by the SDK. */
+declare class CamundaValidationError extends CamundaValidationError_base<{
+    readonly side: 'request' | 'response';
+    readonly operationId?: string;
+    readonly summary: string;
+    readonly issues: string[];
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const EventualConsistencyTimeout_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "EventualConsistencyTimeout";
+} & Readonly<A>;
+/** An eventual-consistency poll that did not converge within its budget. */
+declare class EventualConsistencyTimeout extends EventualConsistencyTimeout_base<{
+    readonly attempts?: number;
+    readonly elapsedMs?: number;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const HttpError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "HttpError";
+} & Readonly<A>;
+/** An HTTP-level failure (non-2xx / transport carrying a status). */
+declare class HttpError extends HttpError_base<{
+    readonly status?: number;
+    readonly body?: unknown;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const CamundaGenericError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
+    readonly _tag: "CamundaGenericError";
+} & Readonly<A>;
+/** Any other thrown value that does not map to a more specific tag. */
+declare class CamundaGenericError extends CamundaGenericError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+/** The typed error channel for every Effect the client produces. */
+type DomainError = CamundaValidationError | EventualConsistencyTimeout | HttpError | CamundaGenericError;
+/** The tag literals of the {@link DomainError} union. */
+type DomainErrorTag = DomainError['_tag'];
+/** Keys of `C` whose values are callable. */
+type FnKeys<C> = {
+    [K in keyof C]: C[K] extends (...a: any) => any ? K : never;
+}[keyof C];
+/** Maps every method of `C` to an Effect-returning method, preserving non-fn members. */
+type Effectify<C> = {
+    [K in FnKeys<C>]: C[K] extends (...a: infer A) => infer R ? (...a: A) => Effect.Effect<Awaited<R>, DomainError, never> : never;
+} & {
+    inner: C;
+} & {
+    [K in Exclude<keyof C, FnKeys<C>>]: C[K];
+};
+/** The Effect-flavoured Camunda client. Every operation returns an `Effect`. */
+type CamundaEffectClient = Effectify<CamundaClient>;
+/**
+ * Create an Effect-flavoured Camunda client.
+ *
+ * Every `CamundaClient` method becomes `(...args) => Effect.Effect<Awaited<R>,
+ * DomainError, never>`. Failures are narrowed into the tagged {@link DomainError}
+ * union so callers use `Effect.catchTag`/`catchTags`. The underlying throwing
+ * client is reachable via the `.inner` escape hatch.
+ *
+ * @description Camunda Effect Client. See the README and [this test](https://github.com/camunda/orchestration-cluster-api-js/blob/main/tests-integration/effect.test.ts) for example usage.
+ */
+declare function createCamundaEffectClient(options?: CamundaOptions): CamundaEffectClient;
+/**
+ * Retry an effect with exponential backoff (+ jitter), capped attempts, and an
+ * optional predicate over the error.
+ */
+declare function retryWithBackoff<A, E, R>(effect: Effect.Effect<A, E, R>, opts: {
+    max: number;
+    baseDelay?: Duration.Input;
+    while?: (e: E) => boolean;
+}): Effect.Effect<A, E, R>;
+/**
+ * Fail an effect with a real interruption if it does not settle within `duration`
+ * (true interruption, not a best-effort `Promise.race`).
+ */
+declare function withTimeout<A, E, R>(effect: Effect.Effect<A, E, R>, duration: Duration.Input, onTimeout?: () => E | EventualConsistencyTimeout): Effect.Effect<A, E | EventualConsistencyTimeout, R>;
+/**
+ * Poll `effect` on the Effect `Clock` until `predicate` holds, timing out to
+ * {@link EventualConsistencyTimeout} once `waitUpTo` elapses. Because it uses the
+ * Effect `Clock` (not `Date.now`/`setTimeout`), `TestClock.adjust` advances it
+ * deterministically in tests — no real-clock burn.
+ */
+declare function eventually<A, E, R>(effect: Effect.Effect<A, E, R>, predicate: (a: A) => boolean, opts: {
+    waitUpTo: Duration.Input;
+    interval?: Duration.Input;
+}): Effect.Effect<A, E | EventualConsistencyTimeout, R>;
+declare const CamundaEffect_base: Context.ServiceClass<CamundaEffect, "CamundaEffect", CamundaEffectClient>;
+/**
+ * `Context` service key for the Effect Camunda client. Compose worker/orchestration
+ * code against this tag and provide {@link layer} (or a test double) via `Layer`.
+ */
+declare class CamundaEffect extends CamundaEffect_base {
+}
+/**
+ * A `Layer` that constructs a {@link CamundaEffectClient} and provides it as the
+ * {@link CamundaEffect} service. Swap in a test double by providing a different
+ * `Layer` for the same tag.
+ */
+declare function layer(options?: CamundaOptions): Layer.Layer<CamundaEffect>;
+
+export { CamundaEffect, type CamundaEffectClient, CamundaGenericError, CamundaValidationError, type DomainError, type DomainErrorTag, type Effectify, EventualConsistencyTimeout, type FnKeys, HttpError, createCamundaEffectClient, eventually, layer, retryWithBackoff, withTimeout };

package/dist/effect/index.js

@@ -0,0 +1,155 @@
+import {
+  CamundaValidationError,
+  EventualConsistencyTimeoutError,
+  createCamundaClient
+} from "../chunk-M5UHGQJ3.js";
+import "../chunk-KQ4UL2WX.js";
+import "../chunk-DGUM43GV.js";
+
+// src/effect.ts
+import { Context, Data, Duration, Effect, Layer, Schedule } from "effect";
+var CamundaValidationError2 = class extends Data.TaggedError("CamundaValidationError") {
+};
+var EventualConsistencyTimeout = class extends Data.TaggedError("EventualConsistencyTimeout") {
+};
+var HttpError = class extends Data.TaggedError("HttpError") {
+};
+var CamundaGenericError = class extends Data.TaggedError("CamundaGenericError") {
+};
+function toDomainError(err) {
+  if (err instanceof CamundaValidationError) {
+    return new CamundaValidationError2({
+      side: err.side,
+      operationId: err.operationId,
+      summary: err.summary,
+      issues: err.issues,
+      message: err.message,
+      cause: err
+    });
+  }
+  if (err instanceof EventualConsistencyTimeoutError) {
+    return new EventualConsistencyTimeout({
+      attempts: err.attempts,
+      elapsedMs: err.elapsedMs,
+      message: err.message,
+      cause: err
+    });
+  }
+  const anyErr = err;
+  if (anyErr && typeof anyErr === "object" && typeof anyErr.status === "number") {
+    return new HttpError({
+      status: anyErr.status,
+      body: anyErr.body,
+      message: typeof anyErr.message === "string" ? anyErr.message : `HTTP ${anyErr.status}`,
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    return new CamundaGenericError({ message: err.message, cause: err });
+  }
+  return new CamundaGenericError({ message: String(err), cause: err });
+}
+function isPromiseLike(v) {
+  return !!v && typeof v.then === "function";
+}
+function createCamundaEffectClient(options) {
+  const base = createCamundaClient(options);
+  const cache = /* @__PURE__ */ new Map();
+  function wrap(fn) {
+    return (...args) => Effect.suspend(() => {
+      let r;
+      try {
+        r = fn.apply(base, args);
+      } catch (e) {
+        return Effect.fail(toDomainError(e));
+      }
+      if (!isPromiseLike(r)) return Effect.succeed(r);
+      const promise = r;
+      return Effect.callback((resume) => {
+        promise.then(
+          (a) => resume(Effect.succeed(a)),
+          (e) => resume(Effect.fail(toDomainError(e)))
+        );
+        const cancel = r.cancel;
+        return typeof cancel === "function" ? Effect.sync(() => cancel.call(r)) : void 0;
+      });
+    });
+  }
+  const handler = {
+    get(_t, prop) {
+      if (prop === "inner") return base;
+      if (cache.has(prop)) return cache.get(prop);
+      const value = base[prop];
+      if (typeof value === "function") {
+        const w = wrap(value);
+        cache.set(prop, w);
+        return w;
+      }
+      cache.set(prop, value);
+      return value;
+    }
+  };
+  return new Proxy({}, handler);
+}
+function formatDuration(d) {
+  try {
+    return Duration.format(Duration.fromInputUnsafe(d));
+  } catch {
+    return String(d);
+  }
+}
+function retryWithBackoff(effect, opts) {
+  const backoff = Schedule.exponential(opts.baseDelay ?? "100 millis").pipe(Schedule.jittered);
+  return Effect.retry(effect, {
+    schedule: backoff,
+    times: Math.max(0, opts.max - 1),
+    while: opts.while
+  });
+}
+function withTimeout(effect, duration, onTimeout) {
+  return Effect.timeoutOrElse(effect, {
+    duration,
+    orElse: () => Effect.fail(
+      onTimeout ? onTimeout() : new EventualConsistencyTimeout({
+        message: `Timed out after ${formatDuration(duration)}`
+      })
+    )
+  });
+}
+function eventually(effect, predicate, opts) {
+  const interval = opts.interval ?? "500 millis";
+  const poll = Effect.suspend(
+    () => effect.pipe(
+      Effect.flatMap(
+        (a) => predicate(a) ? Effect.succeed(a) : Effect.sleep(interval).pipe(Effect.andThen(poll))
+      )
+    )
+  );
+  return withTimeout(
+    poll,
+    opts.waitUpTo,
+    () => new EventualConsistencyTimeout({
+      message: `Eventual consistency timeout after ${formatDuration(opts.waitUpTo)}`
+    })
+  );
+}
+var CamundaEffect = class extends Context.Service()(
+  "CamundaEffect"
+) {
+};
+function layer(options) {
+  return Layer.sync(CamundaEffect, () => createCamundaEffectClient(options));
+}
+export {
+  CamundaEffect,
+  CamundaGenericError,
+  CamundaValidationError2 as CamundaValidationError,
+  EventualConsistencyTimeout,
+  HttpError,
+  createCamundaEffectClient,
+  eventually,
+  layer,
+  retryWithBackoff,
+  withTimeout
+};
+//# sourceMappingURL=index.js.map

package/dist/effect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/effect.ts"],"sourcesContent":["// First-class Effect adapter for the Camunda client.\n//\n// Mirrors the Promise-based `CamundaClient` surface, mapping every method to an\n// `Effect.Effect<Awaited<R>, DomainError, never>` via the same `Proxy` +\n// method-memoization trick the former functional adapter used (it already handles\n// `CancelablePromise`/sync returns via `isPromiseLike`).\n//\n// `effect` is an OPTIONAL peer dependency: importing this module (the `./effect`\n// subpath) is the only way to pull `effect` into the runtime graph. The main `.`\n// entry never imports it, so Promise-first users are never forced to adopt Effect.\n\nimport { Context, Data, Duration, Effect, Layer, Schedule } from 'effect';\nimport { type CamundaClient, type CamundaOptions, createCamundaClient } from './gen/CamundaClient';\nimport {\n  EventualConsistencyTimeoutError as RuntimeEventualConsistencyTimeoutError,\n  CamundaValidationError as RuntimeValidationError,\n} from './runtime/errors';\n\n// --- Tagged domain errors -------------------------------------------------------\n//\n// Modeled as `Data.TaggedError` classes so callers discriminate with\n// `Effect.catchTag` / `Effect.catchTags` instead of a hand-rolled classification\n// switch. Each carries a stable `_tag` literal.\n\n/** A request/response validation failure surfaced by the SDK. */\nexport class CamundaValidationError extends Data.TaggedError('CamundaValidationError')<{\n  readonly side: 'request' | 'response';\n  readonly operationId?: string;\n  readonly summary: string;\n  readonly issues: string[];\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n/** An eventual-consistency poll that did not converge within its budget. */\nexport class EventualConsistencyTimeout extends Data.TaggedError('EventualConsistencyTimeout')<{\n  readonly attempts?: number;\n  readonly elapsedMs?: number;\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n/** An HTTP-level failure (non-2xx / transport carrying a status). */\nexport class HttpError extends Data.TaggedError('HttpError')<{\n  readonly status?: number;\n  readonly body?: unknown;\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n/** Any other thrown value that does not map to a more specific tag. */\nexport class CamundaGenericError extends Data.TaggedError('CamundaGenericError')<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n/** The typed error channel for every Effect the client produces. */\nexport type DomainError =\n  | CamundaValidationError\n  | EventualConsistencyTimeout\n  | HttpError\n  | CamundaGenericError;\n\n/** The tag literals of the {@link DomainError} union. */\nexport type DomainErrorTag = DomainError['_tag'];\n\n// Narrow an arbitrary thrown value into the tagged `DomainError` union.\nfunction toDomainError(err: unknown): DomainError {\n  if (err instanceof RuntimeValidationError) {\n    return new CamundaValidationError({\n      side: err.side,\n      operationId: err.operationId,\n      summary: err.summary,\n      issues: err.issues,\n      message: err.message,\n      cause: err,\n    });\n  }\n  if (err instanceof RuntimeEventualConsistencyTimeoutError) {\n    return new EventualConsistencyTimeout({\n      attempts: err.attempts,\n      elapsedMs: err.elapsedMs,\n      message: err.message,\n      cause: err,\n    });\n  }\n  const anyErr = err as { status?: unknown; body?: unknown; message?: unknown } | null | undefined;\n  if (anyErr && typeof anyErr === 'object' && typeof anyErr.status === 'number') {\n    return new HttpError({\n      status: anyErr.status,\n      body: anyErr.body,\n      message: typeof anyErr.message === 'string' ? anyErr.message : `HTTP ${anyErr.status}`,\n      cause: err,\n    });\n  }\n  if (err instanceof Error) {\n    return new CamundaGenericError({ message: err.message, cause: err });\n  }\n  return new CamundaGenericError({ message: String(err), cause: err });\n}\n\n// --- Client shape ---------------------------------------------------------------\n\n/** Keys of `C` whose values are callable. */\nexport type FnKeys<C> = { [K in keyof C]: C[K] extends (...a: any) => any ? K : never }[keyof C];\n\n/** Maps every method of `C` to an Effect-returning method, preserving non-fn members. */\nexport type Effectify<C> = {\n  [K in FnKeys<C>]: C[K] extends (...a: infer A) => infer R\n    ? (...a: A) => Effect.Effect<Awaited<R>, DomainError, never>\n    : never;\n} & { inner: C } & { [K in Exclude<keyof C, FnKeys<C>>]: C[K] };\n\n/** The Effect-flavoured Camunda client. Every operation returns an `Effect`. */\nexport type CamundaEffectClient = Effectify<CamundaClient>;\n\n// Runtime detection of promise-like (includes CancelablePromise).\nfunction isPromiseLike<T>(v: unknown): v is Promise<T> {\n  return !!v && typeof (v as { then?: unknown }).then === 'function';\n}\n\n/**\n * Create an Effect-flavoured Camunda client.\n *\n * Every `CamundaClient` method becomes `(...args) => Effect.Effect<Awaited<R>,\n * DomainError, never>`. Failures are narrowed into the tagged {@link DomainError}\n * union so callers use `Effect.catchTag`/`catchTags`. The underlying throwing\n * client is reachable via the `.inner` escape hatch.\n *\n * @description Camunda Effect Client. See the README and [this test](https://github.com/camunda/orchestration-cluster-api-js/blob/main/tests-integration/effect.test.ts) for example usage.\n */\nexport function createCamundaEffectClient(options?: CamundaOptions): CamundaEffectClient {\n  const base = createCamundaClient(options);\n  const cache = new Map<string | symbol, unknown>();\n\n  function wrap(fn: (...a: any[]) => any) {\n    return (...args: any[]) =>\n      Effect.suspend(() => {\n        // The generated client can throw *synchronously* (e.g. an eventual\n        // endpoint invoked without `consistencyManagement`). Map those to the\n        // tagged error channel too, rather than letting them escape as a defect.\n        let r: unknown;\n        try {\n          r = fn.apply(base, args);\n        } catch (e) {\n          return Effect.fail(toDomainError(e));\n        }\n        if (!isPromiseLike(r)) return Effect.succeed(r);\n        const promise = r;\n        return Effect.callback<any, DomainError>((resume) => {\n          promise.then(\n            (a: unknown) => resume(Effect.succeed(a)),\n            (e: unknown) => resume(Effect.fail(toDomainError(e)))\n          );\n          // Honour Effect interruption: if the fiber is interrupted (e.g. by\n          // `withTimeout` or a parent), cancel the underlying `CancelablePromise`\n          // so the in-flight HTTP request is aborted instead of leaking.\n          const cancel = (r as { cancel?: () => void }).cancel;\n          return typeof cancel === 'function' ? Effect.sync(() => cancel.call(r)) : undefined;\n        });\n      });\n  }\n\n  const handler: ProxyHandler<any> = {\n    get(_t, prop: string | symbol) {\n      if (prop === 'inner') return base;\n      if (cache.has(prop)) return cache.get(prop);\n      const value = (base as any)[prop];\n      if (typeof value === 'function') {\n        const w = wrap(value);\n        cache.set(prop, w);\n        return w;\n      }\n      cache.set(prop, value);\n      return value;\n    },\n  };\n\n  return new Proxy({}, handler) as CamundaEffectClient;\n}\n\n// --- Combinators (Effect-native) ------------------------------------------------\n\n/**\n * Human-readable rendering of a `Duration.Input` for error messages. `String()`\n * degrades to `[object Object]` for non-string inputs (millis-numbers, `Duration`\n * values, `[seconds, nanos]` tuples); this normalises them via `Duration.format`.\n */\nfunction formatDuration(d: Duration.Input): string {\n  // Only used to build error messages. `fromInputUnsafe` throws on a malformed\n  // (but statically typed) Duration.Input, so guard it — a formatting failure\n  // must never turn a typed timeout failure into an unexpected defect.\n  try {\n    return Duration.format(Duration.fromInputUnsafe(d));\n  } catch {\n    return String(d);\n  }\n}\n\n/**\n * Retry an effect with exponential backoff (+ jitter), capped attempts, and an\n * optional predicate over the error.\n */\nexport function retryWithBackoff<A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  opts: {\n    max: number;\n    baseDelay?: Duration.Input;\n    while?: (e: E) => boolean;\n  }\n): Effect.Effect<A, E, R> {\n  const backoff = Schedule.exponential(opts.baseDelay ?? '100 millis').pipe(Schedule.jittered);\n  // `times: n` caps at n retries after the initial attempt → n+1 total attempts.\n  // (v4 dropped `Schedule.intersect`; the retry options object composes the\n  // exponential-backoff schedule with the attempt cap and the error predicate.)\n  return Effect.retry(effect, {\n    schedule: backoff,\n    times: Math.max(0, opts.max - 1),\n    while: opts.while,\n  });\n}\n\n/**\n * Fail an effect with a real interruption if it does not settle within `duration`\n * (true interruption, not a best-effort `Promise.race`).\n */\nexport function withTimeout<A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  duration: Duration.Input,\n  onTimeout?: () => E | EventualConsistencyTimeout\n): Effect.Effect<A, E | EventualConsistencyTimeout, R> {\n  return Effect.timeoutOrElse(effect, {\n    duration,\n    orElse: () =>\n      Effect.fail(\n        onTimeout\n          ? onTimeout()\n          : new EventualConsistencyTimeout({\n              message: `Timed out after ${formatDuration(duration)}`,\n            })\n      ),\n  });\n}\n\n/**\n * Poll `effect` on the Effect `Clock` until `predicate` holds, timing out to\n * {@link EventualConsistencyTimeout} once `waitUpTo` elapses. Because it uses the\n * Effect `Clock` (not `Date.now`/`setTimeout`), `TestClock.adjust` advances it\n * deterministically in tests — no real-clock burn.\n */\nexport function eventually<A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  predicate: (a: A) => boolean,\n  opts: {\n    waitUpTo: Duration.Input;\n    interval?: Duration.Input;\n  }\n): Effect.Effect<A, E | EventualConsistencyTimeout, R> {\n  const interval = opts.interval ?? '500 millis';\n  // Poll on the Effect `Clock` (Effect.sleep), returning the value A once the\n  // predicate holds. Kept as an Effect-valued loop (not `Effect.repeat` with a\n  // schedule, whose success channel is the schedule output, not A).\n  const poll: Effect.Effect<A, E, R> = Effect.suspend(() =>\n    effect.pipe(\n      Effect.flatMap((a) =>\n        predicate(a) ? Effect.succeed(a) : Effect.sleep(interval).pipe(Effect.andThen(poll))\n      )\n    )\n  );\n  return withTimeout(\n    poll,\n    opts.waitUpTo,\n    () =>\n      new EventualConsistencyTimeout({\n        message: `Eventual consistency timeout after ${formatDuration(opts.waitUpTo)}`,\n      })\n  );\n}\n\n// --- Dependency injection -------------------------------------------------------\n\n/**\n * `Context` service key for the Effect Camunda client. Compose worker/orchestration\n * code against this tag and provide {@link layer} (or a test double) via `Layer`.\n */\nexport class CamundaEffect extends Context.Service<CamundaEffect, CamundaEffectClient>()(\n  'CamundaEffect'\n) {}\n\n/**\n * A `Layer` that constructs a {@link CamundaEffectClient} and provides it as the\n * {@link CamundaEffect} service. Swap in a test double by providing a different\n * `Layer` for the same tag.\n */\nexport function layer(options?: CamundaOptions): Layer.Layer<CamundaEffect> {\n  return Layer.sync(CamundaEffect, () => createCamundaEffectClient(options));\n}\n"],"mappings":"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","names":["CamundaValidationError"]}

package/dist/index.cjs

@@ -9316,13 +9316,10 @@ __export(index_exports, {
   collectTypedVariables: () => collectTypedVariables,
   createCamundaClient: () => createCamundaClient,
   createCamundaClientLoose: () => createCamundaClientLoose,
-  createCamundaFpClient: () => createCamundaFpClient,
   createCamundaResultClient: () => createCamundaResultClient,
   default: () => index_default,
   isErr: () => isErr,
-  isLeft: () => isLeft,
   isOk: () => isOk,
-  isRight: () => isRight,
   isSdkError: () => isSdkError,
   variableNamesFromSchema: () => variableNamesFromSchema
 });
@@ -13878,7 +13875,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.30";
+var packageVersion = "10.0.0-alpha.31";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -14334,18 +14331,18 @@ function unwrapForInspection(s) {
       continue;
     }
     if (t === "ZodIntersection") {
-      const left2 = cur._def.left;
-      const right2 = cur._def.right;
-      if (left2?._def?.typeName === "ZodObject" && right2?._def?.typeName === "ZodObject") {
+      const left = cur._def.left;
+      const right = cur._def.right;
+      if (left?._def?.typeName === "ZodObject" && right?._def?.typeName === "ZodObject") {
         try {
-          const leftShapeFn = left2._def.shape;
-          const rightShapeFn = right2._def.shape;
+          const leftShapeFn = left._def.shape;
+          const rightShapeFn = right._def.shape;
           const merged = { ...leftShapeFn(), ...rightShapeFn() };
           return import_zod.ZodObject.create(merged);
         } catch {
         }
       }
-      cur = left2;
+      cur = left;
       continue;
     }
     break;
@@ -30064,52 +30061,6 @@ function createCamundaClientLoose(...args) {
   return strict;
 }
 
-// src/fp-ts.ts
-var left = (e) => ({ _tag: "Left", left: e });
-var right = (a) => ({ _tag: "Right", right: a });
-var isLeft = (e) => e._tag === "Left";
-var isRight = (e) => e._tag === "Right";
-function toDomainError(err) {
-  if (err instanceof CamundaValidationError) return err;
-  if (err instanceof EventualConsistencyTimeoutError) return err;
-  if (err instanceof Error) return err;
-  if (typeof err === "object") return err;
-  return { message: String(err) };
-}
-function isPromiseLike(v) {
-  return v && typeof v.then === "function";
-}
-function createCamundaFpClient(options) {
-  const base = createCamundaClient(options);
-  const cache = /* @__PURE__ */ new Map();
-  function wrap(fn) {
-    return (...args) => async () => {
-      try {
-        const r = fn.apply(base, args);
-        const val = isPromiseLike(r) ? await r : r;
-        return right(val);
-      } catch (e) {
-        return left(toDomainError(e));
-      }
-    };
-  }
-  const handler = {
-    get(_t, prop) {
-      if (prop === "inner") return base;
-      if (cache.has(prop)) return cache.get(prop);
-      const value = base[prop];
-      if (typeof value === "function") {
-        const w = wrap(value);
-        cache.set(prop, w);
-        return w;
-      }
-      cache.set(prop, value);
-      return value;
-    }
-  };
-  return new Proxy({}, handler);
-}
-
 // src/gen/specHash.ts
 var SPEC_HASH = "sha256:4ba199d92d10b223190403430f33a7572fd43cd8c9c4005f90a8d225a981c1f0";
 
@@ -31464,12 +31415,9 @@ var index_default = createCamundaClient;
   collectTypedVariables,
   createCamundaClient,
   createCamundaClientLoose,
-  createCamundaFpClient,
   createCamundaResultClient,
   isErr,
-  isLeft,
   isOk,
-  isRight,
   isSdkError,
   variableNamesFromSchema
 });