@nanobpm/urban 0.96.1 → 0.96.3

package/dist/cli.js

@@ -11,11 +11,15 @@
 //
 // Global flags: --root <dir> (default "."), --manifest <file> (default nano.app.json),
 //               --port <n>, -h/--help, -v/--version.
-import { collectManifestIssues, installSignalHandlers, loadManifest, runDataOp, runDev, runFromEnv, selectHost, } from "./runtime/index.js";
+//
+// Module-load laziness (nano-ide#592): only argument parsing, the stdio/guard helpers and the
+// dispatcher load eagerly. Every command's modules are dynamically imported inside its handler —
+// a top-level import of the toolkit, the scaffold package or the runtime barrel made EVERY
+// command (including the per-data-op `urban data` gateway) pay the full ~2s load on small
+// hosts before dispatching. `urban data` loads only the host detector and the data-op runner.
+// Guarded by cli-lazy.test.ts, which records the URLs each command resolves.
 import { denoGlobal, processGlobal } from "./runtime/adapters/globals.js";
 import { errorMessage, isRecord } from "./runtime/core/guards.js";
-import { scaffold, slugify } from "create-urban-app";
-import { addConnector, createNodeGenIO, previewModels, generate, runGen } from "./toolkit/index.js";
 import { pathToFileURL } from "node:url";
 import { readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
@@ -119,6 +123,9 @@ Global flags:
 Engine address: $CAMUNDA_REST_ADDRESS (default http://localhost:8080/v2).
 `;
 async function cmdCheck(f) {
+    const { selectHost } = await import("./runtime/adapters/detect.js");
+    const { loadManifest } = await import("./runtime/core/manifest.js");
+    const { collectManifestIssues } = await import("./runtime/core/validate.js");
     // The host is anchored at f.root, so manifest paths are already root-relative —
     // pass the bare manifest filename (prefixing root again would double it).
     const host = selectHost({ cwd: f.root });
@@ -134,6 +141,7 @@ async function cmdCheck(f) {
     return 1;
 }
 async function cmdGen(f) {
+    const { createNodeGenIO, generate } = await import("./toolkit/index.js");
     const io = createNodeGenIO();
     const res = await generate({ root: f.root, io, manifestFile: f.manifest, check: f.check, emitModels: f.models });
     if (res.incomplete) {
@@ -198,6 +206,7 @@ async function cmdDerive(f) {
         console.error("✖ `urban derive` derives models — `--no-models` is contradictory. Use `urban gen --no-models` for type-contracts only.");
         return 2;
     }
+    const { createNodeGenIO, previewModels, runGen } = await import("./toolkit/index.js");
     const io = createNodeGenIO();
     // Non-writing preview: emit `{ models: [{ id, kind, xml }], incomplete }` to stdout for the
     // console's read-only model viewer (never touches `processes/`).
@@ -238,6 +247,7 @@ async function cmdDerive(f) {
     return 0;
 }
 async function cmdRun(f, mount) {
+    const { runFromEnv } = await import("./runtime/run.js");
     const app = await runFromEnv({
         root: f.root,
         manifestPath: f.manifest,
@@ -249,11 +259,14 @@ async function cmdRun(f, mount) {
     return -1; // keep the process alive; signal handlers stop it
 }
 async function cmdDev(f) {
+    const { runDev } = await import("./runtime/devserver.js");
+    const { installSignalHandlers } = await import("./runtime/run.js");
     const dev = await runDev({ root: f.root, manifestPath: f.manifest, port: f.port });
     installSignalHandlers(() => dev.stop());
     return -1; // keep the process alive; signal handlers stop the dev server
 }
 async function cmdDeploy(f) {
+    const { runFromEnv } = await import("./runtime/run.js");
     const app = await runFromEnv({
         root: f.root,
         manifestPath: f.manifest,
@@ -306,6 +319,12 @@ export async function cmdData(f, readInput = readStdin) {
         }));
         return 0;
     }
+    // Lazily the only modules `urban data` loads (nano-ide#592): the host detector (both
+    // adapters, no toolkit) and the data-op runner (gateway + SQLite adapter; the toolkit
+    // derivers behind the `domaintypes` op load only when that op is dispatched). Imported
+    // directly rather than via the runtime barrel, which would pull in the whole runtime.
+    const { selectHost } = await import("./runtime/adapters/detect.js");
+    const { runDataOp } = await import("./runtime/core/modules/dataops.js");
     const host = selectHost({ cwd: f.root });
     try {
         // Mirror runFromEnv: the host is anchored at f.root, so pass root "." to avoid
@@ -324,6 +343,7 @@ async function cmdNew(f) {
         console.error("usage: urban new <name> [--root <path>] [--deno] [--style model|code] (or --code-first)");
         return 1;
     }
+    const { scaffold, slugify } = await import("create-urban-app");
     const dir = f.root !== "." ? f.root : `./${slugify(name)}`;
     const res = await scaffold({ name, dir, deno: f.deno, style: f.style });
     console.log(`✔ scaffolded "${res.id}" in ${res.dir} (${res.files.length} files)`);
@@ -362,6 +382,7 @@ async function cmdAdd(f) {
         }
     }
     try {
+        const { addConnector, createNodeGenIO } = await import("./toolkit/index.js");
         const result = await addConnector({
             root: f.root,
             pkg,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./runtime/index.ts";
 export { createCamundaClient } from "@nanobpm/nano-sdk";
 export * from "./toolkit/index.ts";
-export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";
+export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, inlineJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";
 export type { FlowBuilder, TimerStart, Envelope, EnvelopeType, EnvelopeField, FieldSpec, ScalarType, WorkflowClientOptions, NanoSdkClient, NanoJobWorker, JobWorkerConfig, ActivatedJob, WorkerOptions, ActivityEvent, } from "@nanobpm/workflow";

package/dist/index.js

@@ -22,4 +22,4 @@ export { createCamundaClient } from "@nanobpm/nano-sdk";
 // Toolkit — derivation library (`urban gen`)
 export * from "./toolkit/index.js";
 // Code-first process surface (re-exported from @nanobpm/workflow)
-export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";
+export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, inlineJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";

package/dist/runtime/core/modules/dataops.d.ts

@@ -1,9 +1,9 @@
 import type { HostContext } from "../host.ts";
 import type { AppManifest } from "../manifest.ts";
-import { type ShapeDecl } from "../../../toolkit/derivers/shapes.ts";
-import { type WorkerBindingDecl } from "../../../toolkit/derivers/worker-io.ts";
-import { type MessageBindingDecl } from "../../../toolkit/derivers/messages.ts";
-import { type MetaDecl } from "../../../toolkit/derivers/meta.ts";
+import type { ShapeDecl } from "../../../toolkit/derivers/shapes.ts";
+import type { WorkerBindingDecl } from "../../../toolkit/derivers/worker-io.ts";
+import type { MessageBindingDecl } from "../../../toolkit/derivers/messages.ts";
+import type { MetaDecl } from "../../../toolkit/derivers/meta.ts";
 /** The DB-manager op protocol's known op set — every op (including `domaintypes`) is dispatched by
  * `runDataOp`. Typing `op` as this union (instead of `string`) gives SDK/console callers type-safety
  * and catches typos at compile time. */

package/dist/runtime/core/modules/dataops.js

@@ -23,16 +23,6 @@ import { loadManifest } from "../manifest.js";
 import { validateManifest } from "../validate.js";
 import { makeGateway } from "./gateway.js";
 import { applyMigrations, MIGRATIONS_TABLE, openSqliteSource, resolveAppPath } from "./datasource.js";
-// The `domaintypes` op composes the domain reifier from the pure toolkit derivers (single source of
-// truth for the IDE's codegen, host dry-out nano-bpm#576). Imported directly from the deriver files
-// (not the `toolkit/` barrel, which pulls the Node fs IO) so core stays free of `node:*`/Deno; the
-// derivers' only core dependency is the gateway's `TableMeta`/`ColumnMeta` *types*, which erase.
-import { GENERATED_DIR } from "../../../toolkit/artifact.js";
-import { DOMAIN_BINDINGS, emitDomainBindings, emitDomainModel, registryFromManifest, } from "../../../toolkit/derivers/domain.js";
-import { DOMAIN_MODEL_JSON, emitDomainModelJson, resolveShapes, } from "../../../toolkit/derivers/shapes.js";
-import { DOMAIN_DTS, emitWorkerBindings, emitWorkerBindingsRuntime, overlayDerivedWorkerIo, WORKER_BINDINGS_DTS, WORKER_BINDINGS_TS, } from "../../../toolkit/derivers/worker-io.js";
-import { emitMessageBindings, emitMessageBindingsRuntime, MESSAGE_BINDINGS_DTS, MESSAGE_BINDINGS_TS, } from "../../../toolkit/derivers/messages.js";
-import { emitMeta, META_TS } from "../../../toolkit/derivers/meta.js";
 const DEFAULT_MIGRATIONS_DIR = "db/migrations";
 /** JSON-safe a value: BigInt → number (when lossless) or string, recursing objects/arrays. SQLite
  * reports `lastInsertRowid` (and INTEGER columns) as BigInt, which `JSON.stringify` cannot encode. */
@@ -242,6 +232,17 @@ export async function runDataOp(host, root, manifestPath, req) {
             // debounced keystroke has no DB side-effect and pays only for `text` + `shapeDiagnostics`.
             const { default: def, sources } = listSources(manifest);
             const persist = req.write !== false;
+            // The derivers are the only toolkit modules `urban data` ever needs, and only this op runs
+            // them — load them here, not at module scope, so every other op (the hot path of the data
+            // gateway, nano-ide#592) never pays for the `src/toolkit/` tree. Imported directly from the
+            // deriver files (not the `toolkit/` barrel, which pulls the Node fs IO) so core stays free
+            // of host-specific IO.
+            const { GENERATED_DIR } = await import("../../../toolkit/artifact.js");
+            const { DOMAIN_BINDINGS, emitDomainBindings, emitDomainModel, registryFromManifest, } = await import("../../../toolkit/derivers/domain.js");
+            const { DOMAIN_MODEL_JSON, emitDomainModelJson, resolveShapes } = await import("../../../toolkit/derivers/shapes.js");
+            const { DOMAIN_DTS, emitWorkerBindings, emitWorkerBindingsRuntime, overlayDerivedWorkerIo, WORKER_BINDINGS_DTS, WORKER_BINDINGS_TS, } = await import("../../../toolkit/derivers/worker-io.js");
+            const { emitMessageBindings, emitMessageBindingsRuntime, MESSAGE_BINDINGS_DTS, MESSAGE_BINDINGS_TS, } = await import("../../../toolkit/derivers/messages.js");
+            const { emitMeta, META_TS } = await import("../../../toolkit/derivers/meta.js");
             // Introspect each sqlite source's live schema. When persisting, migrate first (the domain
             // model is derived from `gw.schema()`, so a regen that raced ahead of `migrate` on a fresh DB
             // would emit an empty `Domain`); the migration runs on the shared `_urban_migrations` ledger.

package/dist/runtime/core/modules/datasource.d.ts

@@ -2,7 +2,6 @@ import type { RuntimeContext } from "../context.ts";
 import type { HostContext, SqliteDb } from "../host.ts";
 import type { DomainType } from "../manifest.ts";
 import { Table, type DataSource as GatewayDataSource, type InsertObserver } from "./gateway.ts";
-import { isAbsolutePath } from "../../../toolkit/artifact.ts";
 export declare function sqlitePathFromUrl(url: string): string;
 /** True when `p` is already an absolute path on any host `urban data` targets. `urban data` runs
  * on a Node host that may be Windows, so absolute-path detection can't assume POSIX: this matches
@@ -10,10 +9,12 @@ export declare function sqlitePathFromUrl(url: string): string;
  * that starts with a single backslash ("\data\app.db") and a Windows UNC path
  * ("\\\\server\\share"). A single leading backslash covers both the drive-root and UNC cases,
  * matching Node's `path.win32.isAbsolute`. Used by `resolveAppPath` so a caller-supplied absolute
- * path is never incorrectly prefixed with the app root. Defined once in `toolkit/artifact.ts` (the
- * shared, dependency-free layer) and re-exported here so the toolkit's gen path-join and this
- * runtime resolver apply the identical rule (no gen/runtime drift). */
-export { isAbsolutePath };
+ * path is never incorrectly prefixed with the app root. Defined here in the runtime (not imported
+ * from `toolkit/artifact.ts`) so the `urban data` gateway's static module graph never touches the
+ * `src/toolkit/` tree (nano-ide#592); `toolkit/artifact.ts` re-exports this definition so the
+ * toolkit's gen path-join and this runtime resolver apply the identical rule (no gen/runtime
+ * drift). */
+export declare function isAbsolutePath(p: string): boolean;
 /** Resolve `p` against the app `root`: an absolute `p` (see `isAbsolutePath`) is returned as-is;
  * a relative `p` is joined onto `root`. Trims a trailing separator of either kind off `root` so
  * we never emit a doubled separator. The join separator matches the root's own style so we never

package/dist/runtime/core/modules/datasource.js

@@ -4,7 +4,6 @@
 // runtime side of ADR 0024 (datasource) + ADR 0040 (domain model), scoped to what an app needs.
 import { makeGateway, } from "./gateway.js";
 import { currentJobContext } from "../execContext.js";
-import { isAbsolutePath } from "../../../toolkit/artifact.js";
 import { SQL_IDENT, isReservedObjectName } from "../read-model.js";
 export function sqlitePathFromUrl(url) {
     // Accept "file:./x.db", "file:x.db", "sqlite:./x.db" or a bare path.
@@ -16,10 +15,14 @@ export function sqlitePathFromUrl(url) {
  * that starts with a single backslash ("\data\app.db") and a Windows UNC path
  * ("\\\\server\\share"). A single leading backslash covers both the drive-root and UNC cases,
  * matching Node's `path.win32.isAbsolute`. Used by `resolveAppPath` so a caller-supplied absolute
- * path is never incorrectly prefixed with the app root. Defined once in `toolkit/artifact.ts` (the
- * shared, dependency-free layer) and re-exported here so the toolkit's gen path-join and this
- * runtime resolver apply the identical rule (no gen/runtime drift). */
-export { isAbsolutePath };
+ * path is never incorrectly prefixed with the app root. Defined here in the runtime (not imported
+ * from `toolkit/artifact.ts`) so the `urban data` gateway's static module graph never touches the
+ * `src/toolkit/` tree (nano-ide#592); `toolkit/artifact.ts` re-exports this definition so the
+ * toolkit's gen path-join and this runtime resolver apply the identical rule (no gen/runtime
+ * drift). */
+export function isAbsolutePath(p) {
+    return /^(\/|\\|[A-Za-z]:[/\\])/.test(p);
+}
 /** Resolve `p` against the app `root`: an absolute `p` (see `isAbsolutePath`) is returned as-is;
  * a relative `p` is joined onto `root`. Trims a trailing separator of either kind off `root` so
  * we never emit a doubled separator. The join separator matches the root's own style so we never

package/dist/toolkit/artifact.d.ts

@@ -29,7 +29,9 @@ export declare const RUNTIME_MATERIALIZED_ARTIFACTS: readonly string[];
 /** Stable ordering so artifact lists compare deterministically. */
 export declare function sortArtifacts(a: DerivedArtifact[]): DerivedArtifact[];
 /** True when `p` is an absolute path — POSIX root (`/`), a drive-letter root (`C:\` or `C:/`), or a
- *  Windows UNC/drive-root backslash (`\`). The single source of truth for the absolute-path rule,
- *  shared by the toolkit's path join (gen.ts) and the runtime's resolveAppPath so both agree on
- *  whether a manifest path is app-root-relative or absolute (no gen/runtime drift). */
-export declare function isAbsolutePath(p: string): boolean;
+ *  Windows UNC/drive-root backslash (`\`). The single source of truth for the absolute-path rule is
+ *  the runtime's `resolveAppPath` side (`runtime/core/modules/datasource.ts`); it is re-exported
+ *  here so the toolkit's path join (gen.ts) and the runtime resolver agree on whether a manifest
+ *  path is app-root-relative or absolute (no gen/runtime drift) without the runtime's data gateway
+ *  statically importing the toolkit tree (nano-ide#592). */
+export { isAbsolutePath } from "../runtime/core/modules/datasource.ts";

package/dist/toolkit/artifact.js

@@ -28,9 +28,9 @@ export function sortArtifacts(a) {
     return [...a].sort((x, y) => (x.path < y.path ? -1 : x.path > y.path ? 1 : 0));
 }
 /** True when `p` is an absolute path — POSIX root (`/`), a drive-letter root (`C:\` or `C:/`), or a
- *  Windows UNC/drive-root backslash (`\`). The single source of truth for the absolute-path rule,
- *  shared by the toolkit's path join (gen.ts) and the runtime's resolveAppPath so both agree on
- *  whether a manifest path is app-root-relative or absolute (no gen/runtime drift). */
-export function isAbsolutePath(p) {
-    return /^(\/|\\|[A-Za-z]:[/\\])/.test(p);
-}
+ *  Windows UNC/drive-root backslash (`\`). The single source of truth for the absolute-path rule is
+ *  the runtime's `resolveAppPath` side (`runtime/core/modules/datasource.ts`); it is re-exported
+ *  here so the toolkit's path join (gen.ts) and the runtime resolver agree on whether a manifest
+ *  path is app-root-relative or absolute (no gen/runtime drift) without the runtime's data gateway
+ *  statically importing the toolkit tree (nano-ide#592). */
+export { isAbsolutePath } from "../runtime/core/modules/datasource.js";

package/dist/toolkit/gen.d.ts

@@ -48,6 +48,16 @@ export interface GenResult {
     incomplete: boolean;
     /** Per-file model-derivation errors (empty on success). */
     modelErrors: ModelError[];
+    /** Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+     *  Worker already serves (nano-ide#595). The worker-stub scaffolder skips these; empty for a
+     *  model-first app. */
+    inlineTaskTypes: string[];
+    /** The code-first models derived in-memory this run (`deriveModels().models`) — the
+     *  worker-stub scaffolder plans against these in addition to the on-disk models, since a
+     *  declared `models` block (e.g. `models.workflows`) suppresses the `resources/` convention
+     *  scan that would otherwise pick the written `.bpmn` up (nano-ide#595). Empty for a
+     *  model-first app. */
+    derivedModels: ModelSource[];
     /** Non-fatal spec-hygiene warnings (e.g. a requestBody schema shared by >1 operation). Empty on
      *  a clean spec. Surfaced by the CLI but never fail gen/check — advisory only. */
     warnings: string[];

package/dist/toolkit/gen.js

@@ -19,7 +19,8 @@ function join(root, rel) {
     // pass either style without gen/runtime drift over where a file resolves.
     const norm = (s) => s.replace(/\\/g, "/");
     // An absolute `rel` resolves to itself — never prefixed with `root` — mirroring the runtime's
-    // resolveAppPath (isAbsolutePath is the shared SoT in artifact.ts). Without this an absolute
+    // resolveAppPath (isAbsolutePath is the shared SoT, defined in runtime's datasource.ts and
+    // re-exported from artifact.ts). Without this an absolute
     // manifest path (e.g. "/abs/openapi.json") would be stripped to root-relative and gen would
     // read/derive a different file than the runtime resolves. Trailing edge separators are still
     // trimmed for stable, comparable artifact keys.
@@ -256,7 +257,7 @@ export async function runGen(opts) {
             swept.push(rel);
         }
     }
-    return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, warnings };
+    return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, inlineTaskTypes: derived.inlineTaskTypes, derivedModels: derived.models, warnings };
 }
 export { dirOf, join as joinPath };
 /** Derive code-first models in-memory (no writes) — backs `urban derive --stdout`, the

package/dist/toolkit/generate.js

@@ -30,7 +30,15 @@ export async function generate(opts) {
         return empty;
     const write = !opts.check;
     const scaffoldOpts = { root: opts.root, io: opts.io, manifestFile: opts.manifestFile, write };
-    const workers = await scaffoldWorkers(scaffoldOpts);
+    // Inline-handled (`w.run`) steps are already served by the app's in-process Worker — never
+    // scaffold a competing throwing stub for them (nano-ide#595). The derived models are also
+    // handed over: a code-first manifest's declared `models` block suppresses the resources/
+    // convention scan in readModels, so without them the scaffolder would plan from nothing.
+    const workers = await scaffoldWorkers({
+        ...scaffoldOpts,
+        inlineTaskTypes: res.inlineTaskTypes,
+        extraModels: res.derivedModels,
+    });
     const operations = await scaffoldOperations(scaffoldOpts);
     const missingStubs = [
         ...workers.outcomes.filter((o) => o.status === "would-create").map((o) => o.handlerPath),

package/dist/toolkit/models.d.ts

@@ -38,6 +38,13 @@ export interface DerivedModels {
     models: ModelSource[];
     /** Derived flow ids (used for the provenance-scoped stale sweep). */
     ids: string[];
+    /** Job types of inline-handled (`w.run`) steps across every derived declarative flow —
+     *  the set the app's in-process Worker already serves (nano-ide#595). The worker-stub
+     *  scaffolder skips these; only `w.task` (external) steps may be scaffolded. Empty when
+     *  derivation was a no-op (no loader / no workflow files) or all flows are imperative
+     *  (an imperative flow's steps run inside its single `:__orchestrate` job, which the
+     *  planner already skips). */
+    inlineTaskTypes: string[];
     /** Per-flow `{ id, kind, xml }` for the non-writing preview (`urban derive --stdout`). */
     list: DerivedModelInfo[];
     /** The output directory the artifacts were written into. */

package/dist/toolkit/models.js

@@ -8,7 +8,7 @@
 // optional `GenIO.importModule` (present on Node with type-stripping, and on Deno). When the
 // loader is absent — or the app authors its models directly (model-first) — derivation is a
 // no-op and the rest of `urban gen` proceeds on the authored/derived models unchanged.
-import { toDeployableBpmn } from "@nanobpm/workflow";
+import { inlineJobTypes, toDeployableBpmn } from "@nanobpm/workflow";
 import { expandPattern, joinPath } from "./gen.js";
 import { isRecord } from "../runtime/core/guards.js";
 /** Default source glob for code-first flows (matches the code-first scaffold layout). */
@@ -54,6 +54,7 @@ function emptyDerived(outDir) {
         artifacts: [],
         models: [],
         ids: [],
+        inlineTaskTypes: [],
         list: [],
         outDir,
         attempted: false,
@@ -131,6 +132,8 @@ export async function deriveModels(root, io, manifest) {
                 const path = `${outDir}/${bpmnFilename(id)}`;
                 out.artifacts.push({ path, content: xml });
                 out.models.push({ path, xml });
+                if (value.kind === "declarative")
+                    out.inlineTaskTypes.push(...inlineJobTypes(value));
                 out.list.push({ id, kind: value.kind, xml });
                 out.ids.push(id);
             }

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" | "external";
+export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external" | "inline";
 export interface SkippedWorker {
     taskType: string;
     reason: SkipReason;
@@ -42,9 +42,12 @@ export declare function renderWorkerStub(taskType: string, typedIn: boolean, typ
 /**
  * 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, 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.
+ * declared external (serviced by an out-of-process worker), NOT inline-handled (a code-first
+ * `w.run` step whose handler the app's in-process Worker already serves — nano-ide#595), 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. `inlineTaskTypes` are the flow-derived inline
+ * (`w.run`) job types (`deriveModels().inlineTaskTypes`).
  */
-export declare function planWorkerScaffold(models: ModelSource[], workers?: ScaffoldWorker[], declaredTypeIds?: Iterable<string>, externalTaskTypes?: Iterable<string>): WorkerScaffoldPlan;
+export declare function planWorkerScaffold(models: ModelSource[], workers?: ScaffoldWorker[], declaredTypeIds?: Iterable<string>, externalTaskTypes?: Iterable<string>, inlineTaskTypes?: Iterable<string>): WorkerScaffoldPlan;

package/dist/toolkit/scaffold/workers.js

@@ -65,17 +65,21 @@ 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, 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.
+ * declared external (serviced by an out-of-process worker), NOT inline-handled (a code-first
+ * `w.run` step whose handler the app's in-process Worker already serves — nano-ide#595), 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. `inlineTaskTypes` are the flow-derived inline
+ * (`w.run`) job types (`deriveModels().inlineTaskTypes`).
  */
-export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], externalTaskTypes = []) {
+export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], externalTaskTypes = [], inlineTaskTypes = []) {
     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 inline = new Set(inlineTaskTypes);
     const plans = [];
     const skipped = [];
     const seenTaskTypes = new Set();
@@ -91,6 +95,10 @@ export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], e
                 skipped.push({ taskType, reason: "external" });
                 continue;
             }
+            if (inline.has(taskType)) {
+                skipped.push({ taskType, reason: "inline" });
+                continue;
+            }
             if (wired.has(taskType)) {
                 skipped.push({ taskType, reason: "already-wired" });
                 continue;

package/dist/toolkit/scaffold.d.ts

@@ -1,4 +1,5 @@
 import type { GenIO } from "./gen.ts";
+import type { ModelSource } from "./derivers/worker-io.ts";
 import { type SkippedWorker, type StubManifestEntry } from "./scaffold/workers.ts";
 /**
  * Detect the indentation of a JSON document from its first indented line, so a rewrite can
@@ -18,6 +19,22 @@ export interface ScaffoldOptions {
     manifestFile?: string;
     /** Apply changes (create files + patch manifest). Default false = dry-run. */
     write?: boolean;
+    /**
+     * Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+     * Worker already serves (nano-ide#595). The planner skips these with reason `"inline"` so
+     * `urban gen` never scaffolds a throwing stub that competes with the real handler. Pass
+     * `deriveModels().inlineTaskTypes` (the `generate` composition does).
+     */
+    inlineTaskTypes?: Iterable<string>;
+    /**
+     * Extra in-memory models to plan against in addition to the on-disk ones `readModels`
+     * resolves (nano-ide#595). A code-first app's derived `.bpmn` lives under
+     * `resources/processes/`, which `readModels` does NOT resolve when the manifest declares a
+     * `models` block (e.g. `models.workflows`) without `models.processes` — a declared block
+     * suppresses the `resources/` convention. Pass `deriveModels().models` so the scaffolder
+     * plans from the same fused model set the type-contract derivers saw.
+     */
+    extraModels?: ModelSource[];
 }
 export type StubStatus = "created" | "would-create" | "kept";
 export interface StubOutcome {

package/dist/toolkit/scaffold.js

@@ -38,9 +38,16 @@ export async function scaffoldWorkers(opts) {
     // Preserve the manifest's own indentation when we patch it back (default tab, matching the
     // scaffold's Biome config), so wiring a worker never reformats the file out from under lint.
     const manifestIndent = detectJsonIndent(manifestRaw);
-    const models = await readModels(root, io, manifest);
+    const diskModels = await readModels(root, io, manifest);
     const declaredTypeIds = Object.keys(manifest.types ?? {});
-    const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds, manifest.externalTaskTypes ?? []);
+    // Fuse on-disk models with any in-memory extras (code-first derived models — see
+    // `ScaffoldOptions.extraModels`), deduped by path with the IN-MEMORY model winning: a derived
+    // model whose path also exists on disk may be stale there (`--check`/`--no-models` never write
+    // it), so planning from the disk copy would miss newly added tasks and keep removed ones. This
+    // mirrors the precedence `collectAll` (gen.ts) gives the type-contract derivers.
+    const extraPaths = new Set((opts.extraModels ?? []).map((m) => m.path));
+    const models = [...diskModels.filter((m) => !extraPaths.has(m.path)), ...(opts.extraModels ?? [])];
+    const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds, manifest.externalTaskTypes ?? [], opts.inlineTaskTypes ?? []);
     const outcomes = [];
     const wired = [];
     for (const plan of plans) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nanobpm/urban",
-	"version": "0.96.1",
+	"version": "0.96.3",
 	"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",
@@ -106,9 +106,9 @@
 		"@nanobpm/agentic": "^0.15.0",
 		"@nanobpm/nano-app-schema": "^0.11.0",
 		"@nanobpm/nano-sdk": "^1.2.5",
-		"@nanobpm/workflow": "^0.15.0",
+		"@nanobpm/workflow": "^0.15.1",
 		"bpmn-auto-layout": "^2.0.0-alpha.2",
-		"create-urban-app": "^0.15.2",
+		"create-urban-app": "^0.15.3",
 		"yaml": "^2.9.0"
 	},
 	"devDependencies": {