@nanobpm/urban 0.11.0 → 0.11.1

package/dist/runtime/engine/nanosdk.d.ts

@@ -26,7 +26,8 @@ export interface NanoSdkJobWorkerConfig {
     jobTimeoutMs?: number;
     pollTimeoutMs?: number;
     fetchVariables?: string[];
-    /** Start polling immediately. This adapter sets it false and starts explicitly. */
+    /** Start polling immediately (the SDK default). The adapter leaves this unset so the
+     * SDK owns the start lifecycle after its async Nano/Falcon transport detection. */
     autoStart?: boolean;
 }
 /** The handle returned by `createJobWorker`. */
@@ -69,6 +70,10 @@ export interface NanoSdkClient {
         variables?: Record<string, unknown>;
     }, options?: unknown): Promise<unknown>;
     createJobWorker(cfg: NanoSdkJobWorkerConfig): NanoSdkJobWorker;
+    /** Stop every worker created on this client. Used on teardown to also drain a
+     * REST-fallback worker, whose handle the `createJobWorker` proxy starts internally
+     * and does not hand back. Optional: not every injected client implements it. */
+    stopAllWorkers?(): void | Promise<void>;
     close?(): void | Promise<void>;
 }
 type Log = (level: "info" | "warn" | "error", msg: string, fields?: Record<string, unknown>) => void;

package/dist/runtime/engine/nanosdk.js

@@ -103,9 +103,6 @@ export class SdkEngineClient {
             workerName: options?.workerName ?? `urban:${jobType}`,
             maxParallelJobs: options?.maxParallelJobs ?? 8,
             fetchVariables: options?.fetchVariables,
-            // Own the poll lifecycle here rather than leaving it to the SDK's auto-start
-            // default, so nothing polls until `start()` is called below.
-            autoStart: false,
             jobHandler: async (job) => {
                 const rawKey = job.jobKey;
                 if (rawKey == null || rawKey === "") {
@@ -138,7 +135,11 @@ export class SdkEngineClient {
                 }
             },
         });
-        await worker.start();
+        // The nano-sdk job worker owns its own start lifecycle: `createJobWorker` runs
+        // async Nano/Falcon detection and, once the transport is bound, starts polling
+        // itself (Falcon) or hands off to an auto-started REST worker. Calling `start()`
+        // here would race that detection and dereference a still-null transport, so we
+        // don't — the worker autostarts.
         this.workers.add(worker);
         return {
             jobType,
@@ -162,6 +163,14 @@ export class SdkEngineClient {
         for (const w of this.workers)
             await this.stopWorker(w);
         this.workers.clear();
+        try {
+            // Also drain any REST-fallback worker the SDK started internally (its handle is
+            // not the one we hold), which `stopWorker` above cannot reach.
+            await this.client.stopAllWorkers?.();
+        }
+        catch {
+            /* no workers running / already stopped */
+        }
         try {
             await this.client.close?.();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
   "license": "Apache-2.0",
   "type": "module",

package/src/runtime/engine/nanosdk.test.ts

@@ -81,6 +81,9 @@ function fakeSdkClient(overrides: Partial<NanoSdkClient> = {}): NanoSdkClient &
           rec.stopped++;
         },
       };
+      // The real nano-sdk starts the worker itself after async transport detection
+      // (autoStart defaults on). Model that here so the adapter must NOT call start().
+      if (cfg.autoStart !== false) worker.start();
       return worker;
     },
     close() {
@@ -198,7 +201,7 @@ test("completeUserTask routes through the SDK", async () => {
   assert.deepEqual(seen, { userTaskKey: "utk", variables: { done: true } });
 });
 
-test("registerWorker creates a worker (autoStart false), starts it, and dispatches + completes", async () => {
+test("registerWorker creates a worker the SDK auto-starts, and dispatches + completes", async () => {
   const client = fakeSdkClient();
   const engine = new SdkEngineClient(client);
   const handled: Record<string, unknown>[] = [];
@@ -212,7 +215,9 @@ test("registerWorker creates a worker (autoStart false), starts it, and dispatch
   );
   assert.equal(sub.jobType, "svc");
   const rec = client.workers[0];
-  assert.equal(rec.cfg.autoStart, false);
+  // The adapter must not force autoStart off or call start() itself (that races the
+  // SDK's async transport detection); the SDK owns the start lifecycle.
+  assert.equal(rec.cfg.autoStart, undefined);
   assert.equal(rec.cfg.workerName, "urban:svc");
   assert.equal(rec.cfg.maxParallelJobs, 4);
   assert.equal(rec.started, 1);
@@ -272,6 +277,31 @@ test("close stops every worker and closes the SDK client", async () => {
   assert.equal(client.closed, 1);
 });
 
+test("close drains the REST-fallback worker via the SDK's stopAllWorkers", async () => {
+  let stopAllCalls = 0;
+  const client = fakeSdkClient({
+    async stopAllWorkers() {
+      stopAllCalls++;
+    },
+  });
+  const engine = new SdkEngineClient(client);
+  await engine.registerWorker("a", async () => ({}));
+  await engine.close();
+  // The SDK may start a REST-fallback worker whose handle we never receive;
+  // close() must reach it through the client's stopAllWorkers().
+  assert.equal(stopAllCalls, 1, "close awaits client.stopAllWorkers exactly once");
+  assert.equal(client.closed, 1);
+});
+
+test("close tolerates a client without stopAllWorkers", async () => {
+  const client = fakeSdkClient();
+  delete (client as { stopAllWorkers?: unknown }).stopAllWorkers;
+  const engine = new SdkEngineClient(client);
+  await engine.registerWorker("a", async () => ({}));
+  await engine.close();
+  assert.equal(client.closed, 1);
+});
+
 test("exposes the underlying nano-sdk client as .sdk", () => {
   const client = fakeSdkClient();
   const engine = new SdkEngineClient(client);

package/src/runtime/engine/nanosdk.ts

@@ -49,7 +49,8 @@ export interface NanoSdkJobWorkerConfig {
   jobTimeoutMs?: number;
   pollTimeoutMs?: number;
   fetchVariables?: string[];
-  /** Start polling immediately. This adapter sets it false and starts explicitly. */
+  /** Start polling immediately (the SDK default). The adapter leaves this unset so the
+   * SDK owns the start lifecycle after its async Nano/Falcon transport detection. */
   autoStart?: boolean;
 }
 
@@ -97,6 +98,10 @@ export interface NanoSdkClient {
     options?: unknown,
   ): Promise<unknown>;
   createJobWorker(cfg: NanoSdkJobWorkerConfig): NanoSdkJobWorker;
+  /** Stop every worker created on this client. Used on teardown to also drain a
+   * REST-fallback worker, whose handle the `createJobWorker` proxy starts internally
+   * and does not hand back. Optional: not every injected client implements it. */
+  stopAllWorkers?(): void | Promise<void>;
   close?(): void | Promise<void>;
 }
 
@@ -210,9 +215,6 @@ export class SdkEngineClient implements EngineClient {
       workerName: options?.workerName ?? `urban:${jobType}`,
       maxParallelJobs: options?.maxParallelJobs ?? 8,
       fetchVariables: options?.fetchVariables,
-      // Own the poll lifecycle here rather than leaving it to the SDK's auto-start
-      // default, so nothing polls until `start()` is called below.
-      autoStart: false,
       jobHandler: async (job) => {
         const rawKey = job.jobKey;
         if (rawKey == null || rawKey === "") {
@@ -244,7 +246,11 @@ export class SdkEngineClient implements EngineClient {
         }
       },
     });
-    await worker.start();
+    // The nano-sdk job worker owns its own start lifecycle: `createJobWorker` runs
+    // async Nano/Falcon detection and, once the transport is bound, starts polling
+    // itself (Falcon) or hands off to an auto-started REST worker. Calling `start()`
+    // here would race that detection and dereference a still-null transport, so we
+    // don't — the worker autostarts.
     this.workers.add(worker);
 
     return {
@@ -269,6 +275,13 @@ export class SdkEngineClient implements EngineClient {
   async close(): Promise<void> {
     for (const w of this.workers) await this.stopWorker(w);
     this.workers.clear();
+    try {
+      // Also drain any REST-fallback worker the SDK started internally (its handle is
+      // not the one we hold), which `stopWorker` above cannot reach.
+      await this.client.stopAllWorkers?.();
+    } catch {
+      /* no workers running / already stopped */
+    }
     try {
       await this.client.close?.();
     } catch {