@nanobpm/urban 0.35.0 → 0.37.0

package/dist/toolkit/gen.js

@@ -98,7 +98,10 @@ async function collectAll(opts) {
     const specRef = typeof manifest.api?.spec === "string" ? manifest.api.spec.trim() : "";
     if (!opts.modelsOnly && specRef.length > 0) {
         const specText = await io.readText(join(root, specRef));
-        artifacts.push(...deriveApi(parseSpec(specText)));
+        const opsDir = typeof manifest.api?.dir === "string" && manifest.api.dir.trim().length > 0
+            ? manifest.api.dir.trim()
+            : undefined;
+        artifacts.push(...deriveApi(parseSpec(specText), opsDir));
     }
     return { artifacts: sortArtifacts(artifacts), derived };
 }

package/dist/toolkit/generate.d.ts

@@ -0,0 +1,27 @@
+import type { GenOptions, GenResult } from "./gen.ts";
+import type { OperationStubOutcome, StubOutcome } from "./scaffold.ts";
+import type { StubManifestEntry } from "./scaffold/workers.ts";
+export interface GenerateResult extends GenResult {
+    /** Worker-stub scaffolding outcomes (created / kept / would-create). */
+    workerStubs: StubOutcome[];
+    /** Operation-delegate scaffolding outcomes (created / kept / would-create). */
+    operationStubs: OperationStubOutcome[];
+    /** Worker manifest entries wired into `workers[]` (write mode only). */
+    wiredWorkers: StubManifestEntry[];
+    /** True when `workers[]` was patched (write mode, unwired workers present). */
+    manifestPatched: boolean;
+    /**
+     * App-relative paths of stubs that would be created — the scaffolding equivalent of `drift`.
+     * Populated in `check` mode (nothing is written); a caller should fail CI when non-empty.
+     */
+    missingStubs: string[];
+}
+/**
+ * Derive artifacts and scaffold the write-once handler stubs they reference, in one pass.
+ * In `check` mode nothing is written and any would-be-created stub is reported in `missingStubs`.
+ * Scaffolding is skipped when derivation is `incomplete` (never scaffold from a half-derived model);
+ * the caller reports the derivation failure first.
+ */
+export declare function generate(opts: GenOptions & {
+    check?: boolean;
+}): Promise<GenerateResult>;

package/dist/toolkit/generate.js

@@ -0,0 +1,47 @@
+// `urban gen`: the whole generation concern in one pass — derive artifacts (migrations, worker-I/O,
+// code-first models, OpenAPI contracts + controller) AND scaffold the write-once handler stubs those
+// artifacts reference (worker stubs from the model, operation-delegate stubs from the OpenAPI spec).
+//
+// This composes the pure derivation (`runGen`, gen.ts) with the write-once scaffolders (scaffold.ts)
+// WITHOUT a cycle: scaffold.ts already depends on gen.ts, so this leaf module depends on both and
+// neither depends back. Scaffolding is write-once (an existing, human-owned stub is never clobbered),
+// so folding it into `gen` is idempotent. `--check` writes nothing: a missing stub surfaces in
+// `missingStubs` exactly like a drifted artifact surfaces in `drift`, so CI fails when a stub the
+// generated controller imports isn't committed.
+import { runGen } from "./gen.js";
+import { scaffoldOperations, scaffoldWorkers } from "./scaffold.js";
+/**
+ * Derive artifacts and scaffold the write-once handler stubs they reference, in one pass.
+ * In `check` mode nothing is written and any would-be-created stub is reported in `missingStubs`.
+ * Scaffolding is skipped when derivation is `incomplete` (never scaffold from a half-derived model);
+ * the caller reports the derivation failure first.
+ */
+export async function generate(opts) {
+    const res = await runGen(opts);
+    const empty = {
+        ...res,
+        workerStubs: [],
+        operationStubs: [],
+        wiredWorkers: [],
+        manifestPatched: false,
+        missingStubs: [],
+    };
+    if (res.incomplete)
+        return empty;
+    const write = !opts.check;
+    const scaffoldOpts = { root: opts.root, io: opts.io, manifestFile: opts.manifestFile, write };
+    const workers = await scaffoldWorkers(scaffoldOpts);
+    const operations = await scaffoldOperations(scaffoldOpts);
+    const missingStubs = [
+        ...workers.outcomes.filter((o) => o.status === "would-create").map((o) => o.handlerPath),
+        ...operations.outcomes.filter((o) => o.status === "would-create").map((o) => o.handlerPath),
+    ];
+    return {
+        ...res,
+        workerStubs: workers.outcomes,
+        operationStubs: operations.outcomes,
+        wiredWorkers: workers.wired,
+        manifestPatched: workers.manifestPatched,
+        missingStubs,
+    };
+}

package/dist/toolkit/index.d.ts

@@ -13,7 +13,7 @@ export { deriveMeta, emitMeta, foldMeta, metaDeriver, scanModelMeta, META_TS, }
 export type { MetaDecl } from "./derivers/meta.ts";
 export { deriveMessageBindings, emitMessageBindings, emitMessageBindingsRuntime, messagesDeriver, scanModelMessages, MESSAGE_BINDINGS_DTS, MESSAGE_BINDINGS_TS, } from "./derivers/messages.ts";
 export type { MessageIo, MessageBindingDecl } from "./derivers/messages.ts";
-export { apiDeriver, deriveApi, emitApiBindings, emitApiBindingsRuntime, schemaToTs, API_BINDINGS_DTS, API_BINDINGS_TS, } from "./derivers/api.ts";
+export { apiDeriver, deriveApi, emitApiBindings, emitApiBindingsRuntime, emitApiController, schemaToTs, API_BINDINGS_DTS, API_BINDINGS_TS, API_CONTROLLER_TS, } from "./derivers/api.ts";
 export { collectOperations, HTTP_METHODS, isSafeOperationId, operationsWithoutId, operationsWithUnsafeId, parseSpec, refName, resolveSchema, toRouteMatcher, undeclaredPathParams, validateValue, } from "../openapi/spec.ts";
 export type { HttpMethodLower, OpenApiDoc, OpenApiParameter, OpenApiSchema, OperationInfo, } from "../openapi/spec.ts";
 export declare const DERIVERS: readonly [import("./artifact.ts").Deriver<import("./derivers/migrations.ts").ToolkitManifest>, import("./artifact.ts").Deriver<import("./derivers/migrations.ts").ToolkitManifest>, import("./artifact.ts").Deriver<{
@@ -26,9 +26,12 @@ export declare const DERIVERS: readonly [import("./artifact.ts").Deriver<import(
     declaredTypeIds: Iterable<string>;
 }>, import("./artifact.ts").Deriver<{
     doc: import("../openapi/spec.ts").OpenApiDoc;
+    operationsDir?: string;
 }>];
 export { collectArtifacts, runGen, joinPath, readModels, expandPattern, previewModels } from "./gen.ts";
 export type { GenIO, GenOptions, GenResult } from "./gen.ts";
+export { generate } from "./generate.ts";
+export type { GenerateResult } from "./generate.ts";
 export { createNodeGenIO } from "./fsio.ts";
 export { deriveModels, isWorkflow, bpmnFilename, processesOutDir, DEFAULT_WORKFLOW_PATTERNS, PROCESSES_DIR, MODEL_PROVENANCE, } from "./models.ts";
 export type { DerivedModels, DerivedModelInfo, ModelError, ModelsManifest } from "./models.ts";
@@ -36,5 +39,9 @@ export { planWorkerScaffold, renderWorkerStub, slugifyTaskType, } from "./scaffo
 export type { ScaffoldWorker, SkippedWorker, SkipReason, StubManifestEntry, WorkerScaffoldPlan, WorkerStubPlan, } from "./scaffold/workers.ts";
 export { scaffoldWorkers } from "./scaffold.ts";
 export type { ScaffoldOptions, ScaffoldRun, StubOutcome, StubStatus } from "./scaffold.ts";
+export { planOperationScaffold, renderOperationStub } from "./scaffold/operations.ts";
+export type { OperationStubPlan } from "./scaffold/operations.ts";
+export { scaffoldOperations } from "./scaffold.ts";
+export type { OperationScaffoldRun, OperationStubOutcome } from "./scaffold.ts";
 export { addConnector } from "./addConnector.ts";
 export type { AddConnectorOptions, AddConnectorResult } from "./addConnector.ts";

package/dist/toolkit/index.js

@@ -11,7 +11,7 @@ export { deriveWorkerBindings, emitWorkerBindings, emitWorkerBindingsRuntime, ov
 export { byModelPath, typeRefFor } from "./derivers/worker-io.js";
 export { deriveMeta, emitMeta, foldMeta, metaDeriver, scanModelMeta, META_TS, } from "./derivers/meta.js";
 export { deriveMessageBindings, emitMessageBindings, emitMessageBindingsRuntime, messagesDeriver, scanModelMessages, MESSAGE_BINDINGS_DTS, MESSAGE_BINDINGS_TS, } from "./derivers/messages.js";
-export { apiDeriver, deriveApi, emitApiBindings, emitApiBindingsRuntime, schemaToTs, API_BINDINGS_DTS, API_BINDINGS_TS, } from "./derivers/api.js";
+export { apiDeriver, deriveApi, emitApiBindings, emitApiBindingsRuntime, emitApiController, schemaToTs, API_BINDINGS_DTS, API_BINDINGS_TS, API_CONTROLLER_TS, } from "./derivers/api.js";
 // The OpenAPI machinery the deriver + runtime share (ADR 0058).
 export { collectOperations, HTTP_METHODS, isSafeOperationId, operationsWithoutId, operationsWithUnsafeId, parseSpec, refName, resolveSchema, toRouteMatcher, undeclaredPathParams, validateValue, } from "../openapi/spec.js";
 // The registry of all derivers (for discovery / IDE migration).
@@ -31,10 +31,14 @@ export const DERIVERS = [
 ];
 // Gen orchestrator + IO
 export { collectArtifacts, runGen, joinPath, readModels, expandPattern, previewModels } from "./gen.js";
+export { generate } from "./generate.js";
 export { createNodeGenIO } from "./fsio.js";
 // Code-first model derivation (workflows/*.ts → BPMN)
 export { deriveModels, isWorkflow, bpmnFilename, processesOutDir, DEFAULT_WORKFLOW_PATTERNS, PROCESSES_DIR, MODEL_PROVENANCE, } from "./models.js";
 // Worker-stub scaffolder (ADR 0056): write-once handler stubs from the model.
 export { planWorkerScaffold, renderWorkerStub, slugifyTaskType, } from "./scaffold/workers.js";
 export { scaffoldWorkers } from "./scaffold.js";
+// Operation-delegate scaffolder (ADR 0059): write-once typed delegate stubs from the OpenAPI spec.
+export { planOperationScaffold, renderOperationStub } from "./scaffold/operations.js";
+export { scaffoldOperations } from "./scaffold.js";
 export { addConnector } from "./addConnector.js";

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

@@ -0,0 +1,21 @@
+import { DEFAULT_OPERATIONS_DIR } from "../api-dir.ts";
+import { type OpenApiDoc } from "../../openapi/spec.ts";
+export { DEFAULT_OPERATIONS_DIR };
+/** One planned operation-delegate stub. */
+export interface OperationStubPlan {
+    operationId: string;
+    /** App-relative delegate path: `<dir>/<operationId>.ts`. */
+    handlerPath: string;
+    /** The stub file contents (a typed `defineOperation` that throws `NotImplemented` → HTTP 501). */
+    stub: string;
+}
+/** Render a stub matching a real hand-authored operation delegate (default-exported, typed via the
+ *  generated `defineOperation`). It throws `NotImplemented` so the endpoint returns 501 until the
+ *  body is implemented — never a silent 500, never a drift from the contract. */
+export declare function renderOperationStub(operationId: string, dir?: string): string;
+/**
+ * Plan write-once delegate stubs from the spec: one per declared `operationId` (collectOperations
+ * already skips ops without a safe id). The planner emits a plan for every operation; the impure
+ * edge (`scaffoldOperations`) keeps an existing file verbatim and creates only the absent ones.
+ */
+export declare function planOperationScaffold(doc: OpenApiDoc, dir?: string): OperationStubPlan[];

package/dist/toolkit/scaffold/operations.js

@@ -0,0 +1,55 @@
+// Pure planner for the write-once operation-delegate scaffolder (ADR 0059). Given a parsed OpenAPI
+// document, it plans one typed delegate stub per declared `operationId` — the ONE part of the HTTP
+// surface that cannot be derived from the spec (the handler *body* is human logic). Everything here
+// is pure and testable like a deriver; the impure write-if-absent edge lives in `../scaffold.ts`.
+//
+// scaffold ≠ derive: stubs are human-owned files under `<dir>/<operationId>.ts`, so they are planned
+// once and never overwritten — unlike the derived `nano-generated/` tree (which includes the
+// controller registry that statically imports these delegates and type-checks the whole set).
+import { DEFAULT_OPERATIONS_DIR, normalizeApiDir } from "../api-dir.js";
+import { assertUniqueOperationIds, collectOperations } from "../../openapi/spec.js";
+export { DEFAULT_OPERATIONS_DIR };
+/** Normalize an `api.dir` to a clean relative segment (see `normalizeApiDir`); rejects absolute
+ *  paths and `..` segments so stubs are scaffolded where the runtime resolves delegates from. */
+function normalizeDir(dir) {
+    return normalizeApiDir(dir);
+}
+/** Number of `../` hops from `<dir>/<file>.ts` back up to the app root (dir may be nested). */
+function upToRoot(dir) {
+    const depth = dir.split("/").filter((s) => s.length > 0).length;
+    return "../".repeat(depth);
+}
+/** Render a stub matching a real hand-authored operation delegate (default-exported, typed via the
+ *  generated `defineOperation`). It throws `NotImplemented` so the endpoint returns 501 until the
+ *  body is implemented — never a silent 500, never a drift from the contract. */
+export function renderOperationStub(operationId, dir = DEFAULT_OPERATIONS_DIR) {
+    const up = upToRoot(normalizeDir(dir));
+    const key = JSON.stringify(operationId);
+    return (`// Operation delegate stub for the \`${operationId}\` endpoint, scaffolded from the OpenAPI spec\n` +
+        `// (ADR 0059). This file is yours to edit — \`urban gen\` will never overwrite it. The\n` +
+        `// generated controller (nano-generated/controller.ts) imports this default export and\n` +
+        `// type-checks it against the spec, so the signature cannot drift. Implement the body below\n` +
+        `// (the validated \`{ req, params, query, body }\` input + the injected \`app\`) and delete the throw.\n` +
+        `import { NotImplemented } from "@nanobpm/urban";\n` +
+        `import { defineOperation } from ${JSON.stringify(`${up}nano-generated/operations.ts`)};\n` +
+        `\n` +
+        `export default defineOperation(${key}, async (input, app) => {\n` +
+        `  // \`input\` is the validated request (params/query/body/req); reach app state + services\n` +
+        `  // through the injected \`app\` API. Return \`{ status?, headers?, body? }\` (or nothing → 204).\n` +
+        `  throw new NotImplemented(${key});\n` +
+        `});\n`);
+}
+/**
+ * Plan write-once delegate stubs from the spec: one per declared `operationId` (collectOperations
+ * already skips ops without a safe id). The planner emits a plan for every operation; the impure
+ * edge (`scaffoldOperations`) keeps an existing file verbatim and creates only the absent ones.
+ */
+export function planOperationScaffold(doc, dir = DEFAULT_OPERATIONS_DIR) {
+    assertUniqueOperationIds(doc);
+    const cleanDir = normalizeDir(dir);
+    return collectOperations(doc).map((op) => ({
+        operationId: op.operationId,
+        handlerPath: `${cleanDir}/${op.operationId}.ts`,
+        stub: renderOperationStub(op.operationId, cleanDir),
+    }));
+}

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

@@ -41,7 +41,7 @@ export function renderWorkerStub(taskType, typedIn, typedOut) {
         ? `  // \`job.variables\` is typed as WorkerInputs[${key}].`
         : `  // \`job.variables\` is an open Record<string, unknown> (no declared input type).`;
     return (`// Handler stub for the \`${taskType}\` service task, scaffolded from the model (ADR 0056).\n` +
-        `// This file is yours to edit — \`urban stubs\` will never overwrite it. Implement the body\n` +
+        `// This file is yours to edit — \`urban gen\` will never overwrite it. Implement the body\n` +
         `// below (use \`app.data.table(...)\` for state) and delete the throw.\n` +
         `import type { AppJobHandler } from "@nanobpm/urban/worker";\n` +
         generatedImport +
@@ -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.d.ts

@@ -29,3 +29,19 @@ export interface ScaffoldRun {
 }
 /** Scaffold write-once worker stubs from the model, wiring them into `manifest.workers[]`. */
 export declare function scaffoldWorkers(opts: ScaffoldOptions): Promise<ScaffoldRun>;
+/** One planned operation-delegate outcome (write-once). */
+export interface OperationStubOutcome {
+    operationId: string;
+    handlerPath: string;
+    status: StubStatus;
+}
+export interface OperationScaffoldRun {
+    outcomes: OperationStubOutcome[];
+    write: boolean;
+}
+/**
+ * Scaffold write-once operation-delegate stubs from the app's OpenAPI spec (ADR 0059). One typed
+ * `defineOperation` stub per declared `operationId`, created only if absent (human-owned files are
+ * kept verbatim). Dry-run by default. A no-op when the app declares no `api.spec`.
+ */
+export declare function scaffoldOperations(opts: ScaffoldOptions): Promise<OperationScaffoldRun>;

package/dist/toolkit/scaffold.js

@@ -4,6 +4,8 @@
 // human-owned, so an existing file is KEPT verbatim, never clobbered (the opposite of `runGen`).
 import { joinPath, readModels } from "./gen.js";
 import { planWorkerScaffold, } from "./scaffold/workers.js";
+import { planOperationScaffold } from "./scaffold/operations.js";
+import { parseSpec } from "../openapi/spec.js";
 /** Scaffold write-once worker stubs from the model, wiring them into `manifest.workers[]`. */
 export async function scaffoldWorkers(opts) {
     const { root, io } = opts;
@@ -13,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) {
@@ -52,3 +54,41 @@ export async function scaffoldWorkers(opts) {
     }
     return { outcomes, skipped, wired, manifestPatched, write };
 }
+/**
+ * Scaffold write-once operation-delegate stubs from the app's OpenAPI spec (ADR 0059). One typed
+ * `defineOperation` stub per declared `operationId`, created only if absent (human-owned files are
+ * kept verbatim). Dry-run by default. A no-op when the app declares no `api.spec`.
+ */
+export async function scaffoldOperations(opts) {
+    const { root, io } = opts;
+    const write = opts.write ?? false;
+    const manifestFile = opts.manifestFile ?? "nano.app.json";
+    const manifestPath = joinPath(root, manifestFile);
+    const manifest = JSON.parse(await io.readText(manifestPath));
+    const specRef = typeof manifest.api?.spec === "string" ? manifest.api.spec.trim() : "";
+    if (specRef.length === 0)
+        return { outcomes: [], write };
+    const specText = await io.readText(joinPath(root, specRef));
+    const dir = typeof manifest.api?.dir === "string" && manifest.api.dir.trim().length > 0
+        ? manifest.api.dir.trim()
+        : undefined;
+    const plans = planOperationScaffold(parseSpec(specText), dir);
+    const outcomes = [];
+    for (const plan of plans) {
+        const abs = joinPath(root, plan.handlerPath);
+        const exists = await io.exists(abs);
+        let status;
+        if (exists) {
+            status = "kept"; // human-owned — never clobber
+        }
+        else if (write) {
+            await io.writeText(abs, plan.stub);
+            status = "created";
+        }
+        else {
+            status = "would-create";
+        }
+        outcomes.push({ operationId: plan.operationId, handlerPath: plan.handlerPath, status });
+    }
+    return { outcomes, write };
+}

package/package.json

@@ -1,76 +1,76 @@
 {
-  "name": "@nanobpm/urban",
-  "version": "0.35.0",
-  "description": "Urban: build and run code-first apps on Nano \u2014 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",
-  "keywords": [
-    "nanobpm",
-    "urban",
-    "cli",
-    "runtime",
-    "codegen",
-    "derivation",
-    "nano-app",
-    "rad"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nanobpm/nano-ide.git",
-    "directory": "packages/urban"
-  },
-  "engines": {
-    "node": ">=22.6"
-  },
-  "bin": {
-    "urban": "src/bin.mjs"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./runtime": {
-      "types": "./dist/runtime/index.d.ts",
-      "default": "./dist/runtime/index.js"
-    },
-    "./toolkit": {
-      "types": "./dist/toolkit/index.d.ts",
-      "default": "./dist/toolkit/index.js"
-    },
-    "./worker": {
-      "types": "./dist/worker.d.ts",
-      "default": "./dist/worker.js"
-    },
-    "./source": "./src/index.ts"
-  },
-  "files": [
-    "dist",
-    "src",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepack": "npm run build",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "test": "node --test --experimental-strip-types \"src/**/*.test.ts\"",
-    "test:deno": "deno test -A --no-check src/"
-  },
-  "dependencies": {
-    "@nanobpm/nano-app-schema": "^0.4.0",
-    "@nanobpm/nano-sdk": "^1.2.3",
-    "@nanobpm/workflow": "^0.8.0",
-    "bpmn-auto-layout": "^2.0.0-alpha.2",
-    "create-urban-app": "^0.9.0",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.20.1",
-    "typescript": "^5.9.3"
-  }
+	"name": "@nanobpm/urban",
+	"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",
+	"keywords": [
+		"nanobpm",
+		"urban",
+		"cli",
+		"runtime",
+		"codegen",
+		"derivation",
+		"nano-app",
+		"rad"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nanobpm/nano-ide.git",
+		"directory": "packages/urban"
+	},
+	"engines": {
+		"node": ">=22.6"
+	},
+	"bin": {
+		"urban": "src/bin.mjs"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./runtime": {
+			"types": "./dist/runtime/index.d.ts",
+			"default": "./dist/runtime/index.js"
+		},
+		"./toolkit": {
+			"types": "./dist/toolkit/index.d.ts",
+			"default": "./dist/toolkit/index.js"
+		},
+		"./worker": {
+			"types": "./dist/worker.d.ts",
+			"default": "./dist/worker.js"
+		},
+		"./source": "./src/index.ts"
+	},
+	"files": [
+		"dist",
+		"src",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"prepack": "npm run build",
+		"typecheck": "tsc --noEmit -p tsconfig.json",
+		"test": "node --test --experimental-strip-types \"src/**/*.test.ts\"",
+		"test:deno": "deno test -A --no-check src/"
+	},
+	"dependencies": {
+		"@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",
+		"create-urban-app": "^0.9.0",
+		"yaml": "^2.9.0"
+	},
+	"devDependencies": {
+		"@types/node": "^22.20.1",
+		"typescript": "^5.9.3"
+	}
 }

package/src/cli.test.ts

@@ -14,7 +14,6 @@ test("urban data exits 0 with a parseable envelope on an unreadable request", as
     root: ".",
     manifest: "nano.app.json",
     check: false,
-    write: false,
     deno: false,
     models: true,
     stdout: false,