@camunda8/orchestration-cluster-api 8.9.0-alpha.2 → 8.9.0-alpha.20

package/CHANGELOG.md

@@ -1,3 +1,111 @@
+# [8.9.0-alpha.20](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.19...v8.9.0-alpha.20) (2026-03-24)
+
+
+### Bug Fixes
+
+* remove unused p-retry dependency ([4065fa2](https://github.com/camunda/orchestration-cluster-api-js/commit/4065fa2dcd7074c457c2b1cf2b349177e9b26780))
+
+# [8.9.0-alpha.19](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.18...v8.9.0-alpha.19) (2026-03-23)
+
+### Bug Fixes
+
+- address PR review comments ([028f361](https://github.com/camunda/orchestration-cluster-api-js/commit/028f361e31a6b84e0446eda095f67c0c9b9b68eb))
+- address review feedback for Node 20 compat and type imports ([de1000c](https://github.com/camunda/orchestration-cluster-api-js/commit/de1000cde930a4bd0f55d5d538a1622a6800c824))
+- correct type errors in readme examples ([ddea9ad](https://github.com/camunda/orchestration-cluster-api-js/commit/ddea9ad241cdce0bbe99917319dd2c9d9722645e))
+
+### Features
+
+- add compilable README examples with snippet sync ([a687a47](https://github.com/camunda/orchestration-cluster-api-js/commit/a687a47bf628c5da9f2a94677cdf79b5fcaf0671))
+
+# [8.9.0-alpha.18](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.17...v8.9.0-alpha.18) (2026-03-21)
+
+### Bug Fixes
+
+- prevent fetch wrapper accumulation and abort listener leak ([b5658d6](https://github.com/camunda/orchestration-cluster-api-js/commit/b5658d6ec8567d4dc5215400a3d154b9caa47f7f))
+
+# [8.9.0-alpha.17](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.16...v8.9.0-alpha.17) (2026-03-20)
+
+### Features
+
+- lazy-load zod validation schemas to reduce baseline memory footprint ([3d598ef](https://github.com/camunda/orchestration-cluster-api-js/commit/3d598effb41fa31a25eaf743160858f9eee18d83))
+
+# [8.9.0-alpha.16](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.15...v8.9.0-alpha.16) (2026-03-19)
+
+### Bug Fixes
+
+- threaded worker performance regression fix ([dad2fa8](https://github.com/camunda/orchestration-cluster-api-js/commit/dad2fa88f5598bc9530745e44628fefa417e6e23))
+- use correct default port in docker-compose ([3cb1641](https://github.com/camunda/orchestration-cluster-api-js/commit/3cb16417f97bb3f64f646bc85857ae4ed38708c1))
+
+# [8.9.0-alpha.15](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.14...v8.9.0-alpha.15) (2026-03-19)
+
+### Bug Fixes
+
+- respawn worker threads after error/exit ([0155eff](https://github.com/camunda/orchestration-cluster-api-js/commit/0155eff714ba0fb6c7b81e3883977da87008972a))
+
+# [8.9.0-alpha.14](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.13...v8.9.0-alpha.14) (2026-03-18)
+
+### Bug Fixes
+
+- address PR review comments for threaded worker ([3eabf5d](https://github.com/camunda/orchestration-cluster-api-js/commit/3eabf5dfc2424a875a498978acec7a865a0d151b))
+- emit threadWorkerEntry to dist and resolve path in ESM ([3f00041](https://github.com/camunda/orchestration-cluster-api-js/commit/3f0004199040fbc904426520efccdd9528b2afcd))
+- fix constraint validation for unicode regex ([8347376](https://github.com/camunda/orchestration-cluster-api-js/commit/834737664db9a76177cd9f7c652141bc20a45ddb))
+
+### Features
+
+- add performance test, rebuild latest ([1984ad3](https://github.com/camunda/orchestration-cluster-api-js/commit/1984ad38a83f1c652e1f30b2e9751e9800b8cf2e))
+- add threadedJobWorker ([1e6b049](https://github.com/camunda/orchestration-cluster-api-js/commit/1e6b049c09cd7078c70b020cc4f9370f527a444d))
+- build from latest stable/8.9 ([2798004](https://github.com/camunda/orchestration-cluster-api-js/commit/279800491c202f46b0fea7efc8a7a3ced328a339))
+- rebuild from latest stable/8.9 ([e2c8d04](https://github.com/camunda/orchestration-cluster-api-js/commit/e2c8d04280f4991eb5e2564688bc9dbce3c748a8))
+
+# [8.9.0-alpha.13](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.12...v8.9.0-alpha.13) (2026-03-09)
+
+### Features
+
+- add backoff-at-floor to backpressure algorithm ([a0504bc](https://github.com/camunda/orchestration-cluster-api-js/commit/a0504bcdfd3e24c47e168cddc59aeae957bfc8dd))
+
+# [8.9.0-alpha.12](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.11...v8.9.0-alpha.12) (2026-03-08)
+
+### Features
+
+- build from hardened contract in 8.9 ([03ef35a](https://github.com/camunda/orchestration-cluster-api-js/commit/03ef35a9cda1913bf11bd42b07ae95829d4118cc))
+
+# [8.9.0-alpha.11](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.10...v8.9.0-alpha.11) (2026-03-06)
+
+### Features
+
+- add per-operation retry config. New tuning for backpressure ([9dd921a](https://github.com/camunda/orchestration-cluster-api-js/commit/9dd921a0eae67d56d0e8a7d6423ac7d8a3edd3b4))
+
+# [8.9.0-alpha.10](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.9...v8.9.0-alpha.10) (2026-03-05)
+
+### Features
+
+- tune backpressure ([b64c6f1](https://github.com/camunda/orchestration-cluster-api-js/commit/b64c6f14a5b4755881cb1c79c804a5cd8403145f))
+
+# [8.9.0-alpha.9](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.8...v8.9.0-alpha.9) (2026-03-05)
+
+### Features
+
+- add startup jitter for workers ([95b431d](https://github.com/camunda/orchestration-cluster-api-js/commit/95b431d97fc42aaddfde0b744a8ad94bf82ce401))
+- regenerate from stable/8.9 ([390a04e](https://github.com/camunda/orchestration-cluster-api-js/commit/390a04e6ea06b462ffd6d77d4ed10a3bf31dffda))
+
+# [8.9.0-alpha.8](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.7...v8.9.0-alpha.8) (2026-03-02)
+
+### Features
+
+- support deprecated enums ([a1a2290](https://github.com/camunda/orchestration-cluster-api-js/commit/a1a22908fef6ca75ce353b851d4b6aabd7aa4522))
+
+# [8.9.0-alpha.7](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.6...v8.9.0-alpha.7) (2026-03-02)
+
+### Bug Fixes
+
+- rebuild from upstream spec ([efd13cb](https://github.com/camunda/orchestration-cluster-api-js/commit/efd13cbaec2e3fa2c0a8c0578f5d5b0fa0101715))
+
+# [8.9.0-alpha.6](https://github.com/camunda/orchestration-cluster-api-js/compare/v8.9.0-alpha.5...v8.9.0-alpha.6) (2026-02-17)
+
+### Features
+
+- regenerate from latest schema ([c2d9dff](https://github.com/camunda/orchestration-cluster-api-js/commit/c2d9dffe96f645d2043f62335ef97bdc381b37b1))
+
 ## [1.2.4-alpha.1](https://github.com/camunda/orchestration-cluster-api-js/compare/v1.2.3...v1.2.4-alpha.1) (2026-01-22)
 
 ### Bug Fixes

package/README.md

@@ -1,5 +1,7 @@
 # Camunda 8 Orchestration Cluster TypeScript SDK
 
+<!-- WARNING: The content and specific structure of this file drives Docusaurus generation in camunda-docs. Also, code examples are injected during build. Please refer to MAINTAINER.md before editing. -->
+
 Type‑safe, promise‑based client for the Camunda 8 Orchestration Cluster REST API.
 
 ## Highlights
@@ -13,7 +15,8 @@ Type‑safe, promise‑based client for the Camunda 8 Orchestration Cluster REST
 - Eventual consistency helper for polling endpoints
 - Immutable, deep‑frozen configuration accessible through a factory‑created client instance
 - Automatic body-level tenantId defaulting: if a request body supports an optional tenantId and you omit it, the SDK fills it from CAMUNDA_DEFAULT_TENANT_ID (path params are never auto-filled)
-- Automatic transient HTTP retry (429, 503, network) with exponential backoff + full jitter (configurable via CAMUNDA_SDK_HTTP_RETRY\*). Non-retryable 500s fail fast. Pluggable strategy surface (default uses p-retry when available, internal fallback otherwise).
+- Automatic transient HTTP retry (429, 503, network) with exponential backoff + full jitter (configurable via CAMUNDA_SDK_HTTP_RETRY\*). Non-retryable 500s fail fast.
+- Per-method retry override: disable or customize retry policy on any individual API call without changing global settings
 
 ## Install
 
@@ -28,10 +31,31 @@ Runtime support:
 
 For older Node versions supply a fetch ponyfill AND a `File` shim (or upgrade). For legacy browsers, add a fetch polyfill (e.g. `whatwg-fetch`).
 
+### Versioning
+
+This SDK has a different release cadence from the Camunda server. Features and fixes land in the SDK during a server release.
+
+The major version of the SDK signals a 1:1 type coherence with the server API for a Camunda minor release.
+
+SDK version `n.y.z` -> server version `8.n`, so the type surface of SDK version 9.y.z matches the API surface of Camunda 8.9.
+
+Using a later SDK version, for example: SDK version 10.y.z with Camunda 8.9, means that the SDK contains additive surfaces that are not guaranteed at runtime, and the compiler cannot warn of unsupported operations.
+
+Using an earlier SDK version, for example: SDK version 9.y.z with Camunda 8.10, results in slightly degraded compiler reasoning: exhaustiveness checks cannot be guaranteed by the compiler for any extended surfaces (principally, enums with added members).
+
+In the vast majority of use-cases, this will not be an issue; but you should be aware that using the matching SDK major version for the server minor version provides the strongest compiler guarantees about runtime reliability.
+
+**Recommended approach**:
+
+- Check the [CHANGELOG](https://github.com/camunda/orchestration-cluster-api-js/releases).
+- As a sanity check during server version upgrade, rebuild applications with the matching SDK major version to identify any affected runtime surfaces.
+
 ## Quick Start (Zero‑Config – Recommended)
 
 Keep configuration out of application code. Let the factory read `CAMUNDA_*` variables from the environment (12‑factor style). This makes rotation, secret management, and environment promotion safer & simpler.
 
+<!-- snippet:ReadmeDefaultImport+ReadmeQuickStart -->
+
 ```ts
 import createCamundaClient from '@camunda8/orchestration-cluster-api';
 
@@ -72,6 +96,8 @@ CAMUNDA_SDK_HTTP_RETRY_MAX_DELAY_MS=2000  # optional: cap (ms)
 
 Use only when you must supply or mutate configuration dynamically (e.g. multi‑tenant routing, tests, ephemeral preview environments) or in the browser. Keys mirror their `CAMUNDA_*` env names.
 
+<!-- snippet:ReadmeOverrides -->
+
 ```ts
 const camunda = createCamundaClient({
   config: {
@@ -87,6 +113,8 @@ const camunda = createCamundaClient({
 
 Inject a custom `fetch` to add tracing, mock responses, instrumentation, circuit breakers, etc.
 
+<!-- snippet:ReadmeCustomFetch -->
+
 ```ts
 const camunda = createCamundaClient({
   fetch: (input, init) => {
@@ -132,15 +160,63 @@ Behavior:
 - `strict` - fail on type mismatch or missing required fields
 - `fanatical` - fail on type mismatch, missing required fields, or unknown additional fields
 
+## Per-Method Retry Override
+
+Every API method accepts an optional trailing `options` parameter that lets you override or disable the global retry policy for that single call.
+
+### Disable Retry for a Single Call
+
+<!-- snippet:ReadmeDisableRetry -->
+
+```ts
+// This call will not retry on transient errors
+await camunda.completeJob({ jobKey }, { retry: false });
+```
+
+### Override Specific Retry Settings
+
+Pass a partial `HttpRetryPolicy` to override individual fields. Unspecified fields inherit from the global configuration.
+
+<!-- snippet:ReadmeRetryOverride -->
+
+```ts
+// More aggressive retry for this operation only
+await camunda.createProcessInstance(
+  { processDefinitionId: ProcessDefinitionId.assumeExists('payment-process') },
+  { retry: { maxAttempts: 8, maxDelayMs: 5000 } }
+);
+
+// Minimal retry: single retry with short backoff
+await camunda.getTopology({ retry: { maxAttempts: 2, baseDelayMs: 50 } });
+```
+
+### How It Works
+
+| `options.retry` value | Behavior                                                             |
+| --------------------- | -------------------------------------------------------------------- |
+| omitted / `undefined` | Uses global policy (`CAMUNDA_SDK_HTTP_RETRY_*` env vars)             |
+| `false`               | Disables retry entirely (single attempt, no backoff)                 |
+| `{ maxAttempts: 5 }`  | Merges with global policy — only the specified fields are overridden |
+
+The `HttpRetryPolicy` fields available for override:
+
+| Field         | Type     | Description                             |
+| ------------- | -------- | --------------------------------------- |
+| `maxAttempts` | `number` | Total attempts (initial + retries)      |
+| `baseDelayMs` | `number` | Base delay for exponential backoff (ms) |
+| `maxDelayMs`  | `number` | Maximum delay cap (ms)                  |
+
 ## Advanced HTTP Retry: Cockatiel Adapter (Optional)
 
-The SDK includes built‑in transient HTTP retry (429, 503, network errors) using a p‑retry based engine plus a fallback implementation. For advanced resilience patterns (circuit breakers, timeouts, custom classification, combining policies) you can integrate [cockatiel](https://github.com/connor4312/cockatiel).
+For advanced resilience patterns beyond per-method overrides — circuit breakers, timeouts, custom classification, combining policies — you can integrate [cockatiel](https://github.com/connor4312/cockatiel).
+
+> **Tip:** For most use cases, per-method retry override (above) is sufficient. Reach for Cockatiel when you need circuit breaking, hedging, or bulkhead controls.
 
 ### When To Use Cockatiel
 
-- You need different retry policies per operation (e.g. idempotent GET vs mutating POST)
 - You want circuit breaking, hedging, timeout, or bulkhead controls
 - You want to add custom classification (e.g. retry certain 5xx only on safe verbs)
+- You need to compose multiple resilience policies together
 
 ### Disable Built‑In HTTP Retries
 
@@ -275,7 +351,7 @@ const policy = retry(classify, {
 - Keep SDK retries disabled to prevent duplicate layers.
 - SDK synthesizes `Error` objects with a `status` for retry-significant HTTP responses (429, 503, 500), enabling classification.
 - You can tag errors (e.g. assign `err.__opVerb`) in a wrapper if verb-level logic is needed.
-- Future improvement: an official `retryStrategy` injection hook—current approach is non-invasive.
+- For per-operation retry customization without external dependencies, use the built-in [per-method retry override](#per-method-retry-override) instead.
 
 > Combine cockatiel retry with a circuit breaker, timeout, or bulkhead policy for more robust behavior in partial outages.
 
@@ -377,12 +453,29 @@ Factors use integer percentages to avoid floating point drift in env parsing; th
 
 If you have concrete tuning needs, open an issue describing workload patterns (operation mix, baseline concurrency, observed broker limits) to help prioritize which knobs to surface.
 
+### What Should I Set?
+
+If you're unsure about your workload shape, **don't set anything**. The default BALANCED profile activates automatically and outperforms no-gating (LEGACY) in most scenarios — on raw throughput alone, not just error reduction.
+
+Benchmark results against a single-node local cluster with multiple independent clients (no shared state between them):
+
+| Scenario                      | BALANCED        | LEGACY (no gating) |
+| ----------------------------- | --------------- | ------------------ |
+| Single-client (1K processes)  | **80.1 ops/s**  | 67.8 ops/s         |
+| Single-client sustained (10K) | **119.6 ops/s** | 87.8 ops/s         |
+| Multi-client 3+2 spike        | **86.3 ops/s**  | 48.0 ops/s         |
+| Stress 8 clients ×1000        | 76.3 ops/s      | **106.4 ops/s**    |
+
+BALANCED wins 3 of 4 on pure throughput. The only scenario where LEGACY is faster is extreme overload (800 concurrent requests against a single broker) — and in that case LEGACY accumulates 44,505 errors vs BALANCED's 15,527. The default just works.
+
 ## Job Workers (Polling API)
 
 The SDK provides a lightweight polling job worker for service task job types using `createJobWorker`. It activates jobs in batches (respecting a concurrency limit), validates variables (optional), and offers action helpers on each job.
 
 ### Minimal Example
 
+<!-- snippet:ReadmeJobWorkerImport+ReadmeJobWorkerMinimal -->
+
 ```ts
 import createCamundaClient from '@camunda8/orchestration-cluster-api';
 import { z } from 'zod';
@@ -396,7 +489,7 @@ const Output = z.object({ processed: z.boolean() });
 const worker = client.createJobWorker({
   jobType: 'process-order',
   maxParallelJobs: 10,
-  timeoutMs: 15_000, // long‑poll timeout (server side requestTimeout)
+  jobTimeoutMs: 15_000, // long‑poll timeout (server side requestTimeout)
   pollIntervalMs: 100, // delay between polls when no jobs / at capacity
   // Optional: only fetch specific variables during activation
   fetchVariables: ['orderId'],
@@ -404,9 +497,11 @@ const worker = client.createJobWorker({
   outputSchema: Output, // validates variables passed to complete(...)
   validateSchemas: true, // set false for max throughput (skip Zod)
   autoStart: true, // default true; start polling immediately
+  startupJitterMaxSeconds: 5, // random delay up to 5s before first poll (default 0)
   jobHandler: (job) => {
     // Access typed variables
     const vars = job.variables; // inferred from Input schema
+    console.log(`Processing order: ${vars.orderId}`);
     // Do work...
     return job.complete({ variables: { processed: true } });
   },
@@ -426,6 +521,8 @@ TypeScript inference:
 
 - When you provide `inputSchema`, the type of `fetchVariables` is constrained to the keys of the inferred `variables` type from that schema. Example:
 
+<!-- snippet:ReadmeJobWorkerInference -->
+
 ```ts
 const Input = z.object({ orderId: z.string(), amount: z.number() });
 client.createJobWorker({
@@ -503,6 +600,8 @@ If `validateSchemas` is true:
 
 Use `await worker.stopGracefully({ waitUpToMs?, checkIntervalMs? })` to drain without force‑cancelling the current activation request.
 
+<!-- snippet:ReadmeJobWorkerGraceful -->
+
 ```ts
 // Attempt graceful drain for up to 8 seconds
 const { remainingJobs, timedOut } = await worker.stopGracefully({ waitUpToMs: 8000 });
@@ -526,12 +625,33 @@ Activation cancellations during stop are logged at debug (`activation.cancelled`
 
 You can register multiple workers on a single client instance—one per job type is typical. The client exposes `client.getWorkers()` for inspection and `client.stopAllWorkers()` for coordinated shutdown.
 
+### Startup Jitter
+
+When deploying multiple application instances simultaneously (e.g. a rolling restart or scale-up), all workers start polling at the same time and can saturate the server with activation requests. Set `startupJitterMaxSeconds` to spread out the initial poll across a random window:
+
+<!-- snippet:ReadmeJobWorkerJitter -->
+
+```ts
+client.createJobWorker({
+  jobType: 'process-order',
+  maxParallelJobs: 10,
+  jobTimeoutMs: 30_000,
+  startupJitterMaxSeconds: 5, // each instance delays 0–5s before first poll
+  jobHandler: async (job) => job.complete(),
+});
+```
+
+A value of `0` (the default) means no delay.
+
 ### Receipt Type (Unique Symbol)
 
 Action methods return a unique symbol (not a string) to avoid accidental misuse and allow internal metrics. If you store the receipt, annotate its type as `JobActionReceipt` to preserve uniqueness:
 
+<!-- snippet:ReadmeReceiptImport+ReadmeReceipt -->
+
 ```ts
-import { JobActionReceipt } from '@camunda8/orchestration-cluster-api';
+import type { JobActionReceipt } from '@camunda8/orchestration-cluster-api';
+
 const receipt: JobActionReceipt = await job.complete({ variables: { processed: true } });
 ```
 
@@ -575,6 +695,110 @@ Call `client.getBackpressureState()` to obtain:
 }
 ```
 
+### Threaded Job Workers (Node.js Only)
+
+For CPU-intensive job handlers, `createThreadedJobWorker` offloads handler execution to a pool of Node.js `worker_threads`. Polling and I/O remain on the main event loop, while handler logic runs in parallel threads — dramatically improving throughput when the handler does CPU-bound work (JSON processing, validation, transformation, cryptography).
+
+#### When to use
+
+- Your handler spends significant time on CPU work (not just waiting for HTTP responses)
+- You observe that a single-threaded worker saturates one CPU core while throughput plateaus
+- You need to process more jobs per second without deploying additional instances
+
+If your handler is mostly I/O-bound (HTTP calls, database queries), the standard `createJobWorker` is sufficient.
+
+#### Handler module
+
+The handler must be a **separate file** (not an inline function) that exports a default async function:
+
+```ts
+// my-handler.ts (or my-handler.js)
+import type { ThreadedJobHandler } from '@camunda8/orchestration-cluster-api';
+
+const handler: ThreadedJobHandler = async (job, client) => {
+  const { orderId } = job.variables;
+  // CPU-intensive work here...
+  const result = heavyComputation(orderId);
+  return job.complete({ result });
+};
+export default handler;
+```
+
+Typing your handler as `ThreadedJobHandler` gives full intellisense for `job` (variables, action methods like `complete()`, `fail()`, `error()`) and `client` (every `CamundaClient` API method).
+
+The handler receives two arguments:
+
+1. **`job`** — a proxy with the same shape as a regular job worker job (`variables`, `customHeaders`, `jobKey`, plus action methods: `complete()`, `fail()`, `error()`, `cancelWorkflow()`, `ignore()`)
+2. **`client`** — a proxy to the `CamundaClient` on the main thread. You can call any SDK method (e.g. `client.publishMessage(...)`, `client.createProcessInstance(...)`) and it will be forwarded to the main thread and executed there.
+
+#### Minimal example
+
+<!-- snippet:ReadmeThreadedWorkerImport+ReadmeThreadedWorker -->
+
+```ts
+import createCamundaClient from '@camunda8/orchestration-cluster-api';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const client = createCamundaClient();
+
+const worker = client.createThreadedJobWorker({
+  jobType: 'cpu-heavy-task',
+  handlerModule: path.join(path.dirname(fileURLToPath(import.meta.url)), 'my-handler.js'),
+  maxParallelJobs: 32,
+  jobTimeoutMs: 30_000,
+});
+```
+
+#### Configuration
+
+`createThreadedJobWorker` accepts all the same options as `createJobWorker` (except `jobHandler`), plus:
+
+| Option           | Type     | Default                     | Description                                                      |
+| ---------------- | -------- | --------------------------- | ---------------------------------------------------------------- |
+| `handlerModule`  | `string` | (required)                  | Path to handler module (absolute or relative to `process.cwd()`) |
+| `threadPoolSize` | `number` | `os.availableParallelism()` | Number of worker threads in the pool                             |
+
+Other familiar options: `jobType`, `maxParallelJobs`, `jobTimeoutMs`, `pollIntervalMs`, `pollTimeoutMs`, `fetchVariables`, `inputSchema`, `outputSchema`, `customHeadersSchema`, `validateSchemas`, `autoStart`, `startupJitterMaxSeconds`, `workerName`.
+
+#### Lifecycle
+
+Threaded workers integrate with the same lifecycle as regular workers:
+
+```ts
+// Returned by getWorkers()
+const allWorkers = client.getWorkers();
+
+// Stopped by stopAllWorkers()
+client.stopAllWorkers();
+
+// Graceful shutdown (waits for in-flight jobs to finish)
+const { timedOut, remainingJobs } = await worker.stopGracefully({ waitUpToMs: 10_000 });
+```
+
+#### Pool stats
+
+```ts
+worker.poolSize; // number of threads
+worker.busyThreads; // threads currently processing a job
+worker.activeJobs; // total jobs dispatched but not yet completed
+```
+
+#### How it works
+
+1. The main thread polls `activateJobs` using the same mechanism as `createJobWorker`
+2. Activated jobs are serialized and dispatched to an idle thread via `MessageChannel`
+3. The thread loads the handler module (lazy, on first job), creates a proxy for `job` action methods and `client` API calls
+4. Action methods (`job.complete()`, `job.fail()`, etc.) and client calls are forwarded back to the main thread over the `MessagePort` and executed there
+5. The result is relayed back, and the thread is marked idle for the next job
+
+#### Constraints
+
+- **Node.js only**: `worker_threads` is not available in browsers or Deno
+- **Handler must be a file module**: Inline functions cannot be transferred to threads
+- **Job variables must be JSON-serializable**: Functions and class instances on the job are stripped during transfer
+- **Client calls are async round-trips**: Each `client.xyz()` call crosses a thread boundary, adding a small amount of latency per call
+
 ---
 
 ## Authentication
@@ -661,8 +885,10 @@ If both cert & key are available an https.Agent is attached to all outbound call
 
 Import branded key helpers directly:
 
+<!-- snippet:ReadmeBrandedKeysImport+ReadmeBrandedKeys -->
+
 ```ts
-import { ProcessDefinitionKey, ProcessInstanceKey } from '@camunda8/orchestration-cluster';
+import { ProcessDefinitionKey, ProcessInstanceKey } from '@camunda8/orchestration-cluster-api';
 
 const defKey = ProcessDefinitionKey.assumeExists('2251799813686749');
 // @ts-expect-error – cannot assign def key to instance key
@@ -675,8 +901,13 @@ They are zero‑cost runtime strings with compile‑time separation.
 
 All methods return a `CancelablePromise<T>`:
 
+<!-- snippet:ReadmeCancelable -->
+
 ```ts
-const p = camunda.searchProcessInstances({ filter: { processDefinitionKey: defKey } });
+const p = camunda.searchProcessInstances(
+  { filter: { processDefinitionKey: defKey } },
+  { consistency: { waitUpToMs: 0 } }
+);
 setTimeout(() => p.cancel(), 100); // best‑effort cancel
 try {
   await p; // resolves if not cancelled
@@ -774,16 +1005,22 @@ Use this to understand convergence speed and data shape evolution during tests o
 
 ### Example
 
+<!-- snippet:ReadmeEventualConsistency -->
+
 ```ts
-const jobs = await camunda.searchJobs({
-  filter: { type: 'payment' },
-  consistency: {
-    waitUpToMs: 5000,
-    pollIntervalMs: 200,
-    trace: true,
-    predicate: (r) => Array.isArray(r.items) && r.items.some((j) => j.state === 'CREATED'),
+const jobs = await camunda.searchJobs(
+  {
+    filter: { type: 'payment' },
   },
-});
+  {
+    consistency: {
+      waitUpToMs: 5000,
+      pollIntervalMs: 200,
+      trace: true,
+      predicate: (r) => Array.isArray(r.items) && r.items.some((j) => j.state === 'CREATED'),
+    },
+  }
+);
 ```
 
 On timeout an `EventualConsistencyTimeoutError` includes diagnostic fields: `{ attempts, elapsedMs, lastStatus, lastResponse, operationId }`.
@@ -792,6 +1029,8 @@ On timeout an `EventualConsistencyTimeoutError` includes diagnostic fields: `{ a
 
 Per‑client logger; no global singleton. The level defaults from `CAMUNDA_SDK_LOG_LEVEL` (default `error`).
 
+<!-- snippet:ReadmeLogging -->
+
 ```ts
 const client = createCamundaClient({
   log: {
@@ -929,9 +1168,10 @@ May throw:
 
 All SDK-thrown operational errors normalize to a discriminated union (`SdkError`) when they originate from HTTP, network, auth, or validation layers. Use the guard `isSdkError` to narrow inside a catch:
 
+<!-- snippet:ReadmeErrorHandlingImport+ReadmeErrorHandling -->
+
 ```ts
-import { createCamundaClient } from '@camunda8/orchestration-cluster-api';
-import { isSdkError } from '@camunda8/orchestration-cluster-api/dist/runtime/errors';
+import { createCamundaClient, isSdkError } from '@camunda8/orchestration-cluster-api';
 
 const client = createCamundaClient();
 
@@ -978,13 +1218,15 @@ _Note that this feature is experimental and subject to change._
 
 If you prefer FP‑style explicit error handling instead of exceptions, use the result client wrapper:
 
+<!-- snippet:ReadmeResultClientImport+ReadmeResultClient -->
+
 ```ts
-import { createCamundaResultClient, isOk } from '@camunda8/orchestration-cluster';
+import { createCamundaResultClient, isOk } from '@camunda8/orchestration-cluster-api';
 
 const camundaR = createCamundaResultClient();
 const res = await camundaR.createDeployment({ resources: [file] });
 if (isOk(res)) {
-  console.log('Deployment key', res.value.deployments[0].deploymentKey);
+  console.log('Deployment key', res.value.deploymentKey);
 } else {
   console.error('Deployment failed', res.error);
 }
@@ -1063,6 +1305,8 @@ The deployment endpoint requires each resource to have a filename (extension use
 
 ### Browser
 
+<!-- snippet:ReadmeDeployBrowser -->
+
 ```ts
 const bpmnXml = `<definitions id="process" xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL">...</definitions>`;
 const file = new File([bpmnXml], 'order-process.bpmn', { type: 'application/xml' });
@@ -1082,6 +1326,8 @@ await camunda.createDeployment({ resources: [file] });
 
 Use the built-in helper `deployResourcesFromFiles(...)` to read local files and create `File` objects automatically. It returns the enriched `ExtendedDeploymentResult` (adds typed arrays: `processes`, `decisions`, `decisionRequirements`, `forms`, `resources`).
 
+<!-- snippet:ReadmeDeployNode -->
+
 ```ts
 const result = await camunda.deployResourcesFromFiles([
   './bpmn/order-process.bpmn',
@@ -1132,6 +1378,8 @@ Empty arrays are rejected. Always use correct extensions so the server can class
 
 Create isolated clients per test file:
 
+<!-- snippet:ReadmeTestingClient -->
+
 ```ts
 const client = createCamundaClient({
   config: { CAMUNDA_REST_ADDRESS: 'http://localhost:8080', CAMUNDA_AUTH_STRATEGY: 'NONE' },
@@ -1140,6 +1388,8 @@ const client = createCamundaClient({
 
 Inject a mock fetch:
 
+<!-- snippet:ReadmeTestingMock -->
+
 ```ts
 const client = createCamundaClient({
   fetch: async (input, init) => new Response(JSON.stringify({ ok: true }), { status: 200 }),

package/dist/{chunk-W6JB7JZH.js → chunk-2N2LUTZ2.js}

@@ -1,15 +1,3 @@
-var __defProp = Object.defineProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/runtime/logger.ts
 var ORDER = {
   silent: 0,
@@ -84,8 +72,6 @@ function createLogger(opts = {}) {
 }
 
 export {
-  __require,
-  __export,
   createLogger
 };
-//# sourceMappingURL=chunk-W6JB7JZH.js.map
+//# sourceMappingURL=chunk-2N2LUTZ2.js.map

package/dist/{chunk-W6JB7JZH.js.map → chunk-2N2LUTZ2.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/runtime/logger.ts"],"sourcesContent":["// Per-client logger (no global singleton). Construct via createLogger.\n\n// Added 'silly' for deep diagnostics (unsafe: logs HTTP bodies when enabled elsewhere)\nexport type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silly';\nexport interface LogEvent {\n  level: LogLevel;\n  scope: string;\n  ts: number;\n  args: any[];\n  code?: string;\n  data?: any;\n}\nexport type LogTransport = (e: LogEvent) => void;\nconst ORDER: Record<LogLevel, number> = {\n  silent: 0,\n  error: 1,\n  warn: 2,\n  info: 3,\n  debug: 4,\n  trace: 5,\n  silly: 6,\n};\n\nexport interface Logger {\n  level(): LogLevel;\n  setLevel(level: LogLevel): void; // internal use\n  setTransport(t?: LogTransport): void; // internal use\n  error(...a: any[]): void;\n  warn(...a: any[]): void;\n  info(...a: any[]): void;\n  debug(...a: any[]): void;\n  trace(...a: any[]): void;\n  silly(...a: any[]): void;\n  scope(child: string): Logger;\n  code(level: LogLevel, code: string, msg: string, data?: any): void;\n}\n\nexport interface CreateLoggerOptions {\n  level?: LogLevel;\n  transport?: LogTransport;\n  scope?: string;\n}\n\nexport function createLogger(opts: CreateLoggerOptions = {}): Logger {\n  let currentLevel: LogLevel = opts.level || 'error';\n  let transport: LogTransport | undefined = opts.transport;\n  const baseScope = opts.scope || '';\n\n  function isEnabled(need: LogLevel) {\n    return ORDER[currentLevel] >= ORDER[need];\n  }\n  function evalArgs(args: any[]): any[] {\n    // Support lazy function args: if an arg is a function with zero arity, call it.\n    return args.map((a) => (typeof a === 'function' && a.length === 0 ? a() : a)).flat();\n  }\n  function emit(level: LogLevel, scope: string, rawArgs: any[]) {\n    if (!isEnabled(level)) return;\n    const args = evalArgs(rawArgs);\n    const evt: LogEvent = { level, scope, ts: Date.now(), args };\n    if (transport) {\n      try {\n        transport(evt);\n      } catch {\n        /* ignore transport errors */\n      }\n    } else {\n      const tag = `[camunda-sdk][${level}]${scope ? `[${scope}]` : ''}`;\n      const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : 'log';\n      // eslint-disable-next-line no-console\n      console[method](tag, ...args);\n    }\n  }\n  function emitCode(level: LogLevel, scope: string, code: string, msg: string, data?: any) {\n    if (!isEnabled(level)) return;\n    const evt: LogEvent = { level, scope, ts: Date.now(), args: [msg], code, data };\n    if (transport) {\n      try {\n        transport(evt);\n        // eslint-disable-next-line no-empty\n      } catch {}\n    } else {\n      const tag = `[camunda-sdk][${level}]${scope ? `[${scope}]` : ''}`;\n      const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : 'log';\n      // eslint-disable-next-line no-console\n      console[method](tag, code + ':', msg, data ?? '');\n    }\n  }\n  const make = (scope: string): Logger => ({\n    level: () => currentLevel,\n    setLevel(l: LogLevel) {\n      currentLevel = l;\n    },\n    setTransport(t?: LogTransport) {\n      transport = t;\n    },\n    error: (...a: any[]) => emit('error', scope, a),\n    warn: (...a: any[]) => emit('warn', scope, a),\n    info: (...a: any[]) => emit('info', scope, a),\n    debug: (...a: any[]) => emit('debug', scope, a),\n    trace: (...a: any[]) => emit('trace', scope, a),\n    silly: (...a: any[]) => emit('silly', scope, a),\n    scope(child: string) {\n      return make(scope ? `${scope}:${child}` : child);\n    },\n    code(l: LogLevel, code: string, msg: string, data?: any) {\n      emitCode(l, scope, code, msg, data);\n    },\n  });\n  return make(baseScope);\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAM,QAAkC;AAAA,EACtC,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AACT;AAsBO,SAAS,aAAa,OAA4B,CAAC,GAAW;AACnE,MAAI,eAAyB,KAAK,SAAS;AAC3C,MAAI,YAAsC,KAAK;AAC/C,QAAM,YAAY,KAAK,SAAS;AAEhC,WAAS,UAAU,MAAgB;AACjC,WAAO,MAAM,YAAY,KAAK,MAAM,IAAI;AAAA,EAC1C;AACA,WAAS,SAAS,MAAoB;AAEpC,WAAO,KAAK,IAAI,CAAC,MAAO,OAAO,MAAM,cAAc,EAAE,WAAW,IAAI,EAAE,IAAI,CAAE,EAAE,KAAK;AAAA,EACrF;AACA,WAAS,KAAK,OAAiB,OAAe,SAAgB;AAC5D,QAAI,CAAC,UAAU,KAAK,EAAG;AACvB,UAAM,OAAO,SAAS,OAAO;AAC7B,UAAM,MAAgB,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,GAAG,KAAK;AAC3D,QAAI,WAAW;AACb,UAAI;AACF,kBAAU,GAAG;AAAA,MACf,QAAQ;AAAA,MAER;AAAA,IACF,OAAO;AACL,YAAM,MAAM,iBAAiB,KAAK,IAAI,QAAQ,IAAI,KAAK,MAAM,EAAE;AAC/D,YAAM,SAAS,UAAU,UAAU,UAAU,UAAU,SAAS,SAAS;AAEzE,cAAQ,MAAM,EAAE,KAAK,GAAG,IAAI;AAAA,IAC9B;AAAA,EACF;AACA,WAAS,SAAS,OAAiB,OAAe,MAAc,KAAa,MAAY;AACvF,QAAI,CAAC,UAAU,KAAK,EAAG;AACvB,UAAM,MAAgB,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,GAAG,MAAM,CAAC,GAAG,GAAG,MAAM,KAAK;AAC9E,QAAI,WAAW;AACb,UAAI;AACF,kBAAU,GAAG;AAAA,MAEf,QAAQ;AAAA,MAAC;AAAA,IACX,OAAO;AACL,YAAM,MAAM,iBAAiB,KAAK,IAAI,QAAQ,IAAI,KAAK,MAAM,EAAE;AAC/D,YAAM,SAAS,UAAU,UAAU,UAAU,UAAU,SAAS,SAAS;AAEzE,cAAQ,MAAM,EAAE,KAAK,OAAO,KAAK,KAAK,QAAQ,EAAE;AAAA,IAClD;AAAA,EACF;AACA,QAAM,OAAO,CAAC,WAA2B;AAAA,IACvC,OAAO,MAAM;AAAA,IACb,SAAS,GAAa;AACpB,qBAAe;AAAA,IACjB;AAAA,IACA,aAAa,GAAkB;AAC7B,kBAAY;AAAA,IACd;AAAA,IACA,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,MAAM,IAAI,MAAa,KAAK,QAAQ,OAAO,CAAC;AAAA,IAC5C,MAAM,IAAI,MAAa,KAAK,QAAQ,OAAO,CAAC;AAAA,IAC5C,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,MAAM,OAAe;AACnB,aAAO,KAAK,QAAQ,GAAG,KAAK,IAAI,KAAK,KAAK,KAAK;AAAA,IACjD;AAAA,IACA,KAAK,GAAa,MAAc,KAAa,MAAY;AACvD,eAAS,GAAG,OAAO,MAAM,KAAK,IAAI;AAAA,IACpC;AAAA,EACF;AACA,SAAO,KAAK,SAAS;AACvB;","names":[]}
+{"version":3,"sources":["../src/runtime/logger.ts"],"sourcesContent":["// Per-client logger (no global singleton). Construct via createLogger.\n\n// Added 'silly' for deep diagnostics (unsafe: logs HTTP bodies when enabled elsewhere)\nexport type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silly';\nexport interface LogEvent {\n  level: LogLevel;\n  scope: string;\n  ts: number;\n  args: any[];\n  code?: string;\n  data?: any;\n}\nexport type LogTransport = (e: LogEvent) => void;\nconst ORDER: Record<LogLevel, number> = {\n  silent: 0,\n  error: 1,\n  warn: 2,\n  info: 3,\n  debug: 4,\n  trace: 5,\n  silly: 6,\n};\n\nexport interface Logger {\n  level(): LogLevel;\n  setLevel(level: LogLevel): void; // internal use\n  setTransport(t?: LogTransport): void; // internal use\n  error(...a: any[]): void;\n  warn(...a: any[]): void;\n  info(...a: any[]): void;\n  debug(...a: any[]): void;\n  trace(...a: any[]): void;\n  silly(...a: any[]): void;\n  scope(child: string): Logger;\n  code(level: LogLevel, code: string, msg: string, data?: any): void;\n}\n\nexport interface CreateLoggerOptions {\n  level?: LogLevel;\n  transport?: LogTransport;\n  scope?: string;\n}\n\nexport function createLogger(opts: CreateLoggerOptions = {}): Logger {\n  let currentLevel: LogLevel = opts.level || 'error';\n  let transport: LogTransport | undefined = opts.transport;\n  const baseScope = opts.scope || '';\n\n  function isEnabled(need: LogLevel) {\n    return ORDER[currentLevel] >= ORDER[need];\n  }\n  function evalArgs(args: any[]): any[] {\n    // Support lazy function args: if an arg is a function with zero arity, call it.\n    return args.map((a) => (typeof a === 'function' && a.length === 0 ? a() : a)).flat();\n  }\n  function emit(level: LogLevel, scope: string, rawArgs: any[]) {\n    if (!isEnabled(level)) return;\n    const args = evalArgs(rawArgs);\n    const evt: LogEvent = { level, scope, ts: Date.now(), args };\n    if (transport) {\n      try {\n        transport(evt);\n      } catch {\n        /* ignore transport errors */\n      }\n    } else {\n      const tag = `[camunda-sdk][${level}]${scope ? `[${scope}]` : ''}`;\n      const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : 'log';\n      // eslint-disable-next-line no-console\n      console[method](tag, ...args);\n    }\n  }\n  function emitCode(level: LogLevel, scope: string, code: string, msg: string, data?: any) {\n    if (!isEnabled(level)) return;\n    const evt: LogEvent = { level, scope, ts: Date.now(), args: [msg], code, data };\n    if (transport) {\n      try {\n        transport(evt);\n        // eslint-disable-next-line no-empty\n      } catch {}\n    } else {\n      const tag = `[camunda-sdk][${level}]${scope ? `[${scope}]` : ''}`;\n      const method = level === 'error' ? 'error' : level === 'warn' ? 'warn' : 'log';\n      // eslint-disable-next-line no-console\n      console[method](tag, code + ':', msg, data ?? '');\n    }\n  }\n  const make = (scope: string): Logger => ({\n    level: () => currentLevel,\n    setLevel(l: LogLevel) {\n      currentLevel = l;\n    },\n    setTransport(t?: LogTransport) {\n      transport = t;\n    },\n    error: (...a: any[]) => emit('error', scope, a),\n    warn: (...a: any[]) => emit('warn', scope, a),\n    info: (...a: any[]) => emit('info', scope, a),\n    debug: (...a: any[]) => emit('debug', scope, a),\n    trace: (...a: any[]) => emit('trace', scope, a),\n    silly: (...a: any[]) => emit('silly', scope, a),\n    scope(child: string) {\n      return make(scope ? `${scope}:${child}` : child);\n    },\n    code(l: LogLevel, code: string, msg: string, data?: any) {\n      emitCode(l, scope, code, msg, data);\n    },\n  });\n  return make(baseScope);\n}\n"],"mappings":";AAaA,IAAM,QAAkC;AAAA,EACtC,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AACT;AAsBO,SAAS,aAAa,OAA4B,CAAC,GAAW;AACnE,MAAI,eAAyB,KAAK,SAAS;AAC3C,MAAI,YAAsC,KAAK;AAC/C,QAAM,YAAY,KAAK,SAAS;AAEhC,WAAS,UAAU,MAAgB;AACjC,WAAO,MAAM,YAAY,KAAK,MAAM,IAAI;AAAA,EAC1C;AACA,WAAS,SAAS,MAAoB;AAEpC,WAAO,KAAK,IAAI,CAAC,MAAO,OAAO,MAAM,cAAc,EAAE,WAAW,IAAI,EAAE,IAAI,CAAE,EAAE,KAAK;AAAA,EACrF;AACA,WAAS,KAAK,OAAiB,OAAe,SAAgB;AAC5D,QAAI,CAAC,UAAU,KAAK,EAAG;AACvB,UAAM,OAAO,SAAS,OAAO;AAC7B,UAAM,MAAgB,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,GAAG,KAAK;AAC3D,QAAI,WAAW;AACb,UAAI;AACF,kBAAU,GAAG;AAAA,MACf,QAAQ;AAAA,MAER;AAAA,IACF,OAAO;AACL,YAAM,MAAM,iBAAiB,KAAK,IAAI,QAAQ,IAAI,KAAK,MAAM,EAAE;AAC/D,YAAM,SAAS,UAAU,UAAU,UAAU,UAAU,SAAS,SAAS;AAEzE,cAAQ,MAAM,EAAE,KAAK,GAAG,IAAI;AAAA,IAC9B;AAAA,EACF;AACA,WAAS,SAAS,OAAiB,OAAe,MAAc,KAAa,MAAY;AACvF,QAAI,CAAC,UAAU,KAAK,EAAG;AACvB,UAAM,MAAgB,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,GAAG,MAAM,CAAC,GAAG,GAAG,MAAM,KAAK;AAC9E,QAAI,WAAW;AACb,UAAI;AACF,kBAAU,GAAG;AAAA,MAEf,QAAQ;AAAA,MAAC;AAAA,IACX,OAAO;AACL,YAAM,MAAM,iBAAiB,KAAK,IAAI,QAAQ,IAAI,KAAK,MAAM,EAAE;AAC/D,YAAM,SAAS,UAAU,UAAU,UAAU,UAAU,SAAS,SAAS;AAEzE,cAAQ,MAAM,EAAE,KAAK,OAAO,KAAK,KAAK,QAAQ,EAAE;AAAA,IAClD;AAAA,EACF;AACA,QAAM,OAAO,CAAC,WAA2B;AAAA,IACvC,OAAO,MAAM;AAAA,IACb,SAAS,GAAa;AACpB,qBAAe;AAAA,IACjB;AAAA,IACA,aAAa,GAAkB;AAC7B,kBAAY;AAAA,IACd;AAAA,IACA,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,MAAM,IAAI,MAAa,KAAK,QAAQ,OAAO,CAAC;AAAA,IAC5C,MAAM,IAAI,MAAa,KAAK,QAAQ,OAAO,CAAC;AAAA,IAC5C,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,OAAO,IAAI,MAAa,KAAK,SAAS,OAAO,CAAC;AAAA,IAC9C,MAAM,OAAe;AACnB,aAAO,KAAK,QAAQ,GAAG,KAAK,IAAI,KAAK,KAAK,KAAK;AAAA,IACjD;AAAA,IACA,KAAK,GAAa,MAAc,KAAa,MAAY;AACvD,eAAS,GAAG,OAAO,MAAM,KAAK,IAAI;AAAA,IACpC;AAAA,EACF;AACA,SAAO,KAAK,SAAS;AACvB;","names":[]}

package/dist/chunk-DGUM43GV.js

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=chunk-DGUM43GV.js.map

package/dist/chunk-DGUM43GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}