@camunda8/orchestration-cluster-api 10.0.0-alpha.20 → 10.0.0-alpha.21

package/dist/fp/index.d.cts

@@ -1,3 +1,3 @@
-export { dr as CamundaFpClient, Hx as DomainError, Hy as DomainErrorTag, iI as Either, Hz as FnKeys, HA as Fpify, HB as HttpError, HC as Left, HD as Right, HE as TaskEither, HF as classifyDomainError, D3 as createCamundaFpClient, HG as eventuallyTE, HH as foldDomainError, Fe as isLeft, Ff as isRight, HI as retryTE, HJ as withTimeoutTE } from '../index-B-TWQXn0.cjs';
+export { dr as CamundaFpClient, Hx as DomainError, Hy as DomainErrorTag, iI as Either, Hz as FnKeys, HA as Fpify, HB as HttpError, HC as Left, HD as Right, HE as TaskEither, HF as classifyDomainError, D3 as createCamundaFpClient, HG as eventuallyTE, HH as foldDomainError, Fe as isLeft, Ff as isRight, HI as retryTE, HJ as withTimeoutTE } from '../index-DPNy4KLk.cjs';
 import 'zod';
 import '../logger-D-p21VHo.cjs';

package/dist/fp/index.d.ts

@@ -1,3 +1,3 @@
-export { dr as CamundaFpClient, Hx as DomainError, Hy as DomainErrorTag, iI as Either, Hz as FnKeys, HA as Fpify, HB as HttpError, HC as Left, HD as Right, HE as TaskEither, HF as classifyDomainError, D3 as createCamundaFpClient, HG as eventuallyTE, HH as foldDomainError, Fe as isLeft, Ff as isRight, HI as retryTE, HJ as withTimeoutTE } from '../index-CLUX1eAN.js';
+export { dr as CamundaFpClient, Hx as DomainError, Hy as DomainErrorTag, iI as Either, Hz as FnKeys, HA as Fpify, HB as HttpError, HC as Left, HD as Right, HE as TaskEither, HF as classifyDomainError, D3 as createCamundaFpClient, HG as eventuallyTE, HH as foldDomainError, Fe as isLeft, Ff as isRight, HI as retryTE, HJ as withTimeoutTE } from '../index-CE5WmteM.js';
 import 'zod';
 import '../logger-D-p21VHo.js';

package/dist/fp/index.js

@@ -7,7 +7,7 @@ import {
   isRight,
   retryTE,
   withTimeoutTE
-} from "../chunk-QZDJRG7I.js";
+} from "../chunk-7SBI6PGB.js";
 import "../chunk-KQ4UL2WX.js";
 import "../chunk-DGUM43GV.js";
 export {

package/dist/{index-CLUX1eAN.d.ts → index-CE5WmteM.d.ts}

@@ -22326,11 +22326,19 @@ declare class JobWorker {
     private _pollTimer;
     private _inFlightActivation;
     private _log;
+    private _startGate;
     constructor(client: CamundaClient, cfg: JobWorkerConfig);
     get name(): string;
     get activeJobs(): number;
     get stopped(): boolean;
+    /**
+     * Begin polling for jobs. Safe to call at any point: the request is buffered
+     * until the transport is ready, and redundant calls (including an explicit
+     * call on an `autoStart` worker) are dropped rather than starting a second
+     * poll loop. Once the worker is stopped, `start()` is a no-op.
+     */
     start(): void;
+    private _beginPolling;
     stop(): void;
     /**
      * Gracefully stop the worker: prevent new polls, allow any in-flight activation to finish
@@ -22524,6 +22532,7 @@ declare class ThreadedJobWorker {
     private _inFlightActivation;
     private _log;
     private _jobQueue;
+    private _startGate;
     constructor(client: CamundaClient, pool: ThreadPool, cfg: ThreadedJobWorkerConfig);
     get name(): string;
     get activeJobs(): number;
@@ -22534,7 +22543,14 @@ declare class ThreadedJobWorker {
     get busyThreads(): number;
     /** Resolves when the shared thread pool has finished initialising. */
     get ready(): Promise<void>;
+    /**
+     * Begin polling for jobs. Safe to call at any point: the request is buffered
+     * until the shared thread pool is ready, and redundant calls (including an
+     * explicit call on an `autoStart` worker) are dropped rather than starting a
+     * second poll loop. Once the worker is stopped, `start()` is a no-op.
+     */
     start(): void;
+    private _beginPolling;
     stop(): void;
     stopGracefully(opts?: {
         waitUpToMs?: number;

package/dist/{index-B-TWQXn0.d.cts → index-DPNy4KLk.d.cts}

@@ -22326,11 +22326,19 @@ declare class JobWorker {
     private _pollTimer;
     private _inFlightActivation;
     private _log;
+    private _startGate;
     constructor(client: CamundaClient, cfg: JobWorkerConfig);
     get name(): string;
     get activeJobs(): number;
     get stopped(): boolean;
+    /**
+     * Begin polling for jobs. Safe to call at any point: the request is buffered
+     * until the transport is ready, and redundant calls (including an explicit
+     * call on an `autoStart` worker) are dropped rather than starting a second
+     * poll loop. Once the worker is stopped, `start()` is a no-op.
+     */
     start(): void;
+    private _beginPolling;
     stop(): void;
     /**
      * Gracefully stop the worker: prevent new polls, allow any in-flight activation to finish
@@ -22524,6 +22532,7 @@ declare class ThreadedJobWorker {
     private _inFlightActivation;
     private _log;
     private _jobQueue;
+    private _startGate;
     constructor(client: CamundaClient, pool: ThreadPool, cfg: ThreadedJobWorkerConfig);
     get name(): string;
     get activeJobs(): number;
@@ -22534,7 +22543,14 @@ declare class ThreadedJobWorker {
     get busyThreads(): number;
     /** Resolves when the shared thread pool has finished initialising. */
     get ready(): Promise<void>;
+    /**
+     * Begin polling for jobs. Safe to call at any point: the request is buffered
+     * until the shared thread pool is ready, and redundant calls (including an
+     * explicit call on an `autoStart` worker) are dropped rather than starting a
+     * second poll loop. Once the worker is stopped, `start()` is a no-op.
+     */
     start(): void;
+    private _beginPolling;
     stop(): void;
     stopGracefully(opts?: {
         waitUpToMs?: number;

package/dist/index.cjs

@@ -13060,7 +13060,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.20";
+var packageVersion = "10.0.0-alpha.21";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -14298,6 +14298,50 @@ function createVariableSearchFetchPage(params) {
   };
 }
 
+// src/runtime/workerStartGate.ts
+var WorkerStartGate = class {
+  /**
+   * @param transportReady Resolves when the worker's transport can service polls.
+   * @param isStopped Reports whether the worker was stopped while the gate was buffering.
+   */
+  constructor(_transportReady, _isStopped) {
+    this._transportReady = _transportReady;
+    this._isStopped = _isStopped;
+  }
+  _transportReady;
+  _isStopped;
+  _requested = false;
+  /** True once a start request has been accepted and not since released. */
+  get requested() {
+    return this._requested;
+  }
+  /**
+   * Record a start request.
+   *
+   * The first accepted request invokes `onReady` once the transport resolves,
+   * and only if the worker has not been stopped in the meantime. If the
+   * transport fails to come up, `onError` is invoked and the gate is released so
+   * a later `start()` can retry.
+   *
+   * @returns `false` when the request was dropped as redundant.
+   */
+  request(onReady, onError) {
+    if (this._requested) return false;
+    this._requested = true;
+    void this._transportReady().then(
+      () => {
+        if (this._isStopped()) return;
+        onReady();
+      },
+      (err) => {
+        this._requested = false;
+        onError(err);
+      }
+    );
+    return true;
+  }
+};
+
 // src/runtime/jobWorker.ts
 var JobActionReceipt = "JOB_ACTION_RECEIPT";
 var _workerCounter = 0;
@@ -14314,6 +14358,7 @@ var JobWorker = class {
   _inFlightActivation = null;
   // CancelablePromise-like
   _log;
+  _startGate;
   constructor(client2, cfg) {
     this._client = client2;
     this._cfg = {
@@ -14334,6 +14379,10 @@ var JobWorker = class {
         { maxBackoffTimeMs: cfg.maxBackoffTimeMs }
       ]);
     }
+    this._startGate = new WorkerStartGate(
+      () => Promise.resolve(),
+      () => this._stopped
+    );
     if (this._cfg.autoStart) this.start();
   }
   get name() {
@@ -14345,10 +14394,25 @@ var JobWorker = class {
   get stopped() {
     return this._stopped;
   }
+  /**
+   * Begin polling for jobs. Safe to call at any point: the request is buffered
+   * until the transport is ready, and redundant calls (including an explicit
+   * call on an `autoStart` worker) are dropped rather than starting a second
+   * poll loop. Once the worker is stopped, `start()` is a no-op.
+   */
   start() {
     if (this._stopped) return;
-    if (this._pollTimer) return;
+    const accepted = this._startGate.request(
+      () => this._beginPolling(),
+      (err) => this._log.error("worker.start.transportError", err)
+    );
+    if (!accepted) {
+      this._log.debug("worker.start.alreadyRequested");
+      return;
+    }
     this._log.info("worker.start");
+  }
+  _beginPolling() {
     const jitterMax = this._cfg.startupJitterMaxSeconds ?? 0;
     if (jitterMax > 0) {
       const jitterMs = Math.floor(Math.random() * jitterMax * 1e3);
@@ -14607,6 +14671,7 @@ var ThreadedJobWorker = class {
   _inFlightActivation = null;
   _log;
   _jobQueue = [];
+  _startGate;
   constructor(client2, pool, cfg) {
     this._client = client2;
     this._pool = pool;
@@ -14623,6 +14688,10 @@ var ThreadedJobWorker = class {
     this._name = cfg.workerName || `threaded-worker-${cfg.jobType}-${++_workerCounter2}`;
     this._log = this._client.logger().scope(`worker:${this._name}`);
     this._pool.onThreadReady = () => this._drainQueue();
+    this._startGate = new WorkerStartGate(
+      () => this._pool.ready,
+      () => this._stopped
+    );
     if (this._cfg.autoStart) this.start();
   }
   get name() {
@@ -14646,10 +14715,25 @@ var ThreadedJobWorker = class {
   get ready() {
     return this._pool.ready;
   }
+  /**
+   * Begin polling for jobs. Safe to call at any point: the request is buffered
+   * until the shared thread pool is ready, and redundant calls (including an
+   * explicit call on an `autoStart` worker) are dropped rather than starting a
+   * second poll loop. Once the worker is stopped, `start()` is a no-op.
+   */
   start() {
     if (this._stopped) return;
-    if (this._pollTimer) return;
+    const accepted = this._startGate.request(
+      () => this._beginPolling(),
+      (err) => this._log.error("worker.start.transportError", err)
+    );
+    if (!accepted) {
+      this._log.debug("worker.start.alreadyRequested");
+      return;
+    }
     this._log.info("worker.start");
+  }
+  _beginPolling() {
     const jitterMax = this._cfg.startupJitterMaxSeconds ?? 0;
     if (jitterMax > 0) {
       const jitterMs = Math.floor(Math.random() * jitterMax * 1e3);