@nanobpm/urban 0.36.0 → 0.37.0

package/dist/toolkit/scaffold/workers.d.ts

@@ -26,7 +26,7 @@ export interface WorkerStubPlan {
     stub: string;
     manifestEntry: StubManifestEntry;
 }
-export type SkipReason = "already-wired" | "orchestrator" | "duplicate";
+export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external";
 export interface SkippedWorker {
     taskType: string;
     reason: SkipReason;
@@ -41,8 +41,10 @@ export declare function slugifyTaskType(taskType: string): string;
 export declare function renderWorkerStub(taskType: string, typedIn: boolean, typedOut: boolean): string;
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
- * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, and
- * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
- * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
+ * declared external (serviced by an out-of-process worker), and not a duplicate of one already
+ * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
+ * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
+ * declared external task types, which the app owns the model for but deliberately does not host.
  */
-export declare function planWorkerScaffold(models: ModelSource[], workers?: ScaffoldWorker[], declaredTypeIds?: Iterable<string>): WorkerScaffoldPlan;
+export declare function planWorkerScaffold(models: ModelSource[], workers?: ScaffoldWorker[], declaredTypeIds?: Iterable<string>, externalTaskTypes?: Iterable<string>): WorkerScaffoldPlan;

package/dist/toolkit/scaffold/workers.js

@@ -57,15 +57,18 @@ export function renderWorkerStub(taskType, typedIn, typedOut) {
 }
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
- * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, and
- * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
- * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
+ * declared external (serviced by an out-of-process worker), and not a duplicate of one already
+ * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
+ * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
+ * declared external task types, which the app owns the model for but deliberately does not host.
  */
-export function planWorkerScaffold(models, workers = [], declaredTypeIds = []) {
+export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], externalTaskTypes = []) {
     const wired = new Set(workers
         .map((w) => w?.taskType)
         .filter((t) => typeof t === "string" && t.length > 0));
     const declared = new Set(declaredTypeIds);
+    const external = new Set(externalTaskTypes);
     const plans = [];
     const skipped = [];
     const seenTaskTypes = new Set();
@@ -77,6 +80,10 @@ export function planWorkerScaffold(models, workers = [], declaredTypeIds = []) {
                 skipped.push({ taskType, reason: "orchestrator" });
                 continue;
             }
+            if (external.has(taskType)) {
+                skipped.push({ taskType, reason: "external" });
+                continue;
+            }
             if (wired.has(taskType)) {
                 skipped.push({ taskType, reason: "already-wired" });
                 continue;

package/dist/toolkit/scaffold.js

@@ -15,7 +15,7 @@ export async function scaffoldWorkers(opts) {
     const manifest = JSON.parse(await io.readText(manifestPath));
     const models = await readModels(root, io, manifest);
     const declaredTypeIds = Object.keys(manifest.types ?? {});
-    const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds);
+    const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds, manifest.externalTaskTypes ?? []);
     const outcomes = [];
     const wired = [];
     for (const plan of plans) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nanobpm/urban",
-	"version": "0.36.0",
+	"version": "0.37.0",
 	"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",
@@ -62,7 +62,7 @@
 		"test:deno": "deno test -A --no-check src/"
 	},
 	"dependencies": {
-		"@nanobpm/nano-app-schema": "^0.4.0",
+		"@nanobpm/nano-app-schema": "^0.5.0",
 		"@nanobpm/nano-sdk": "^1.2.3",
 		"@nanobpm/workflow": "^0.8.0",
 		"bpmn-auto-layout": "^2.0.0-alpha.2",

package/src/toolkit/scaffold/workers.test.ts

@@ -99,6 +99,16 @@ test("planWorkerScaffold: skips already-wired, orchestrator, and duplicates", ()
   assert.equal(reasons["t.new"], "duplicate");
 });
 
+test("planWorkerScaffold: skips a task type declared external (out-of-process worker)", () => {
+  const models = [
+    model("a.bpmn", "p1", serviceTask("A", "senior:review"), serviceTask("B", "t.new")),
+  ];
+  const { plans, skipped } = planWorkerScaffold(models, [], [], ["senior:review"]);
+  assert.deepEqual(plans.map((p) => p.taskType), ["t.new"]);
+  const reasons = Object.fromEntries(skipped.map((s) => [s.taskType, s.reason]));
+  assert.equal(reasons["senior:review"], "external");
+});
+
 test("planWorkerScaffold: colliding slugs get a numeric suffix", () => {
   const m = model("a.bpmn", "p", serviceTask("A", "orders.charge"), serviceTask("B", "orders-charge"));
   const { plans } = planWorkerScaffold([m], [], []);
@@ -195,3 +205,28 @@ test("scaffoldWorkers is idempotent: a second --write run is a no-op", async ()
   assert.equal(run2.manifestPatched, false, "no new wiring on the second run");
   assert.equal(JSON.stringify(io.files), snapshot, "files unchanged on re-run");
 });
+
+test("scaffoldWorkers reads manifest.externalTaskTypes and skips those (never scaffolds/wires)", async () => {
+  const files = {
+    "/app/nano.app.json": JSON.stringify({
+      id: "demo",
+      models: { processes: ["processes/*.bpmn"] },
+      externalTaskTypes: ["senior:review"],
+    }),
+    "/app/processes/p.bpmn": model("p.bpmn", "p",
+      serviceTask("A", "senior:review"),
+      serviceTask("B", "t.new"),
+    ).xml,
+  };
+  const io = memIO(files);
+  const run = await scaffoldWorkers({ root: "/app", io, write: true });
+  // Only the app-hosted task is scaffolded; the external one is skipped.
+  assert.deepEqual(run.outcomes.map((o) => o.taskType), ["t.new"]);
+  assert.ok(run.skipped.some((s) => s.taskType === "senior:review" && s.reason === "external"));
+  assert.equal(io.files["/app/workers/senior-review/worker.ts"], undefined, "external task gets no stub");
+  const manifest = JSON.parse(io.files["/app/nano.app.json"]);
+  assert.ok(
+    !manifest.workers?.some((w: { taskType: string }) => w.taskType === "senior:review"),
+    "external task is never wired into workers[]",
+  );
+});

package/src/toolkit/scaffold/workers.ts

@@ -39,7 +39,7 @@ export interface WorkerStubPlan {
   manifestEntry: StubManifestEntry;
 }
 
-export type SkipReason = "already-wired" | "orchestrator" | "duplicate";
+export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external";
 
 export interface SkippedWorker {
   taskType: string;
@@ -110,14 +110,17 @@ export function renderWorkerStub(
 
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
- * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, and
- * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
- * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
+ * declared external (serviced by an out-of-process worker), and not a duplicate of one already
+ * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
+ * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
+ * declared external task types, which the app owns the model for but deliberately does not host.
  */
 export function planWorkerScaffold(
   models: ModelSource[],
   workers: ScaffoldWorker[] = [],
   declaredTypeIds: Iterable<string> = [],
+  externalTaskTypes: Iterable<string> = [],
 ): WorkerScaffoldPlan {
   const wired = new Set(
     workers
@@ -125,6 +128,7 @@ export function planWorkerScaffold(
       .filter((t): t is string => typeof t === "string" && t.length > 0),
   );
   const declared = new Set(declaredTypeIds);
+  const external = new Set(externalTaskTypes);
 
   const plans: WorkerStubPlan[] = [];
   const skipped: SkippedWorker[] = [];
@@ -138,6 +142,10 @@ export function planWorkerScaffold(
         skipped.push({ taskType, reason: "orchestrator" });
         continue;
       }
+      if (external.has(taskType)) {
+        skipped.push({ taskType, reason: "external" });
+        continue;
+      }
       if (wired.has(taskType)) {
         skipped.push({ taskType, reason: "already-wired" });
         continue;

package/src/toolkit/scaffold.ts

@@ -19,6 +19,7 @@ interface ScaffoldManifest {
   types?: Record<string, unknown>;
   models?: { processes?: string[] };
   workers?: ScaffoldWorker[];
+  externalTaskTypes?: string[];
   api?: { spec?: string; dir?: string };
 }
 
@@ -64,7 +65,12 @@ export async function scaffoldWorkers(opts: ScaffoldOptions): Promise<ScaffoldRu
   const models = await readModels(root, io, manifest);
   const declaredTypeIds = Object.keys(manifest.types ?? {});
 
-  const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds);
+  const { plans, skipped } = planWorkerScaffold(
+    models,
+    manifest.workers ?? [],
+    declaredTypeIds,
+    manifest.externalTaskTypes ?? [],
+  );
 
   const outcomes: StubOutcome[] = [];
   const wired: StubManifestEntry[] = [];