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

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [10.0.0-alpha.21](https://github.com/camunda/orchestration-cluster-api-js/compare/v10.0.0-alpha.20...v10.0.0-alpha.21) (2026-08-02)
+
+
+### Bug Fixes
+
+* **worker:** buffer start() until the transport is ready ([ad4d37f](https://github.com/camunda/orchestration-cluster-api-js/commit/ad4d37f6eeadffb89532af351bd80d404ffc2fde))
+* **worker:** buffer start() until the transport is ready ([708b544](https://github.com/camunda/orchestration-cluster-api-js/commit/708b544f79ffec9ef9060de0dea21ac8ecb2b207)), closes [#401](https://github.com/camunda/orchestration-cluster-api-js/issues/401)
+
 # [10.0.0-alpha.20](https://github.com/camunda/orchestration-cluster-api-js/compare/v10.0.0-alpha.19...v10.0.0-alpha.20) (2026-08-02)
 
 

package/dist/{chunk-QZDJRG7I.js → chunk-7SBI6PGB.js}

@@ -317,6 +317,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;
@@ -333,6 +377,7 @@ var JobWorker = class {
   _inFlightActivation = null;
   // CancelablePromise-like
   _log;
+  _startGate;
   constructor(client2, cfg) {
     this._client = client2;
     this._cfg = {
@@ -353,6 +398,10 @@ var JobWorker = class {
         { maxBackoffTimeMs: cfg.maxBackoffTimeMs }
       ]);
     }
+    this._startGate = new WorkerStartGate(
+      () => Promise.resolve(),
+      () => this._stopped
+    );
     if (this._cfg.autoStart) this.start();
   }
   get name() {
@@ -364,10 +413,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);
@@ -4783,7 +4847,7 @@ function installAuthInterceptor(client2, getStrategy, getAuthHeaders) {
 }
 
 // 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 {
@@ -5890,6 +5954,7 @@ var ThreadedJobWorker = class {
   _inFlightActivation = null;
   _log;
   _jobQueue = [];
+  _startGate;
   constructor(client2, pool, cfg) {
     this._client = client2;
     this._pool = pool;
@@ -5906,6 +5971,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() {
@@ -5929,10 +5998,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);
@@ -19103,4 +19187,4 @@ export {
   withTimeoutTE,
   eventuallyTE
 };
-//# sourceMappingURL=chunk-QZDJRG7I.js.map
+//# sourceMappingURL=chunk-7SBI6PGB.js.map