@nanobpm/urban 0.25.0 → 0.27.0

package/dist/toolkit/derivers/worker-io.js

@@ -14,6 +14,9 @@ export function byModelPath(a, b) {
 }
 /** Filename the console uses; kept identical so the artifact is a drop-in. */
 export const WORKER_BINDINGS_DTS = "worker-io.d.ts";
+/** The generated typed-`defineWorker` wrapper's basename — re-exports the worker SDK and overrides
+ * `defineWorker` with a taskType-keyed typed signature. */
+export const WORKER_BINDINGS_TS = "workers.ts";
 /** The domain type declarations `worker-io.d.ts` imports from (console: domain-rows.d.ts). */
 export const DOMAIN_DTS = "domain-rows.d.ts";
 const ENVELOPE_IN = "io.nanobpm.dataEnvelope.in";
@@ -65,6 +68,22 @@ export function scanModelWorkers(xml) {
 export function typeRefFor(id, declared) {
     return id != null && declared.has(id) ? `DomainTypes[${JSON.stringify(id)}]` : undefined;
 }
+/** The TS type expression for a worker's declared custom-header keys: an object type mapping each
+ * declared key to `string` (Zeebe headers are strings on the wire) plus a `string` index signature
+ * so undeclared headers stay accessible with the same honest wire type. Returns `undefined` when no
+ * keys are declared (the caller omits the entry so the taskType falls back to `WorkerHdrs`). */
+function headerRefFor(keys) {
+    const clean = [
+        ...new Set((keys ?? [])
+            .filter((k) => typeof k === "string")
+            .map((k) => k.trim())
+            .filter((k) => k.length > 0)),
+    ];
+    if (clean.length === 0)
+        return undefined;
+    const fields = clean.map((k) => `${JSON.stringify(k)}: string`).join("; ");
+    return `{ ${fields}; [key: string]: string }`;
+}
 /** Emit `worker-io.d.ts` from worker bindings + the set of declared domain type ids. */
 export function emitWorkerBindings(workers, declaredTypeIds) {
     const declared = new Set(declaredTypeIds);
@@ -79,6 +98,7 @@ export function emitWorkerBindings(workers, declaredTypeIds) {
         : "string";
     const inputs = [];
     const outputs = [];
+    const headers = [];
     for (const w of workers) {
         if (typeof w?.taskType !== "string" || w.taskType.length === 0)
             continue;
@@ -88,6 +108,9 @@ export function emitWorkerBindings(workers, declaredTypeIds) {
         const outRef = typeRefFor(w.outputType, declared);
         if (outRef)
             outputs.push(`  ${propKey(w.taskType)}: ${outRef};`);
+        const hdrRef = headerRefFor(w.headerKeys);
+        if (hdrRef)
+            headers.push(`  ${propKey(w.taskType)}: ${hdrRef};`);
     }
     const header = "// AUTO-GENERATED by nanobpmn from the App manifest (ADR 0033 §3).\n" +
         "// The bridge from the process model to the worker type system: each declared\n" +
@@ -105,7 +128,9 @@ export function emitWorkerBindings(workers, declaredTypeIds) {
     const outputsIface = outputs.length > 0
         ? `export interface WorkerOutputs {\n${outputs.join("\n")}\n}\n`
         : `export interface WorkerOutputs {}\n`;
-    const headersIface = `export interface WorkerHeaders {}\n`;
+    const headersIface = headers.length > 0
+        ? `export interface WorkerHeaders {\n${headers.join("\n")}\n}\n`
+        : `export interface WorkerHeaders {}\n`;
     return `${header}\n` +
         importTypes +
         `\n/** Untyped fallback for a job whose worker declares no input/output type. */\n` +
@@ -144,3 +169,78 @@ export const workerIoDeriver = {
     describe: "Derive worker-io.d.ts (task type + data-envelope in/out) from BPMN models.",
     derive: ({ models, declaredTypeIds }) => deriveWorkerBindings(models, declaredTypeIds),
 };
+/**
+ * Overlay the model-derived worker-IO map onto the manifest `workers[]`. The model is authoritative
+ * for the envelope (`inputType`/`outputType`), so every scanned `taskType` takes its I/O from
+ * `derived` (clearing a stale manifest value when the model carries none); manifest entries the scan
+ * did not cover (e.g. a worker declared only for an `llm` binding, with no service task) are
+ * preserved. New `taskType`s seen only in the model are appended. A byte-faithful port of the
+ * console's `overlayDerivedWorkerIo` (server `data_cli.ts`).
+ */
+export function overlayDerivedWorkerIo(manifest, derived) {
+    const byType = new Map();
+    for (const w of manifest) {
+        if (typeof w.taskType === "string")
+            byType.set(w.taskType, { ...w });
+    }
+    for (const d of derived) {
+        if (typeof d.taskType !== "string")
+            continue;
+        const existing = byType.get(d.taskType);
+        const merged = existing
+            ? { ...existing, taskType: d.taskType }
+            : { taskType: d.taskType };
+        if (d.inputType)
+            merged.inputType = d.inputType;
+        else
+            delete merged.inputType;
+        if (d.outputType)
+            merged.outputType = d.outputType;
+        else
+            delete merged.outputType;
+        // Header keys are authored on the model, so the derived set is authoritative: replace (not
+        // union) the manifest's, and clear when the model declares none.
+        if (d.headerKeys && d.headerKeys.length > 0)
+            merged.headerKeys = [...d.headerKeys];
+        else
+            delete merged.headerKeys;
+        byType.set(d.taskType, merged);
+    }
+    return [...byType.values()];
+}
+/**
+ * The static typed-`defineWorker` wrapper (`workers.ts`). It re-exports the whole worker SDK and
+ * overrides `defineWorker` with a signature that keys off the `type:` string literal: when a job
+ * type is present in the generated `WorkerInputs`/`WorkerOutputs` (ADR 0033 §3), the handler's
+ * `job.variables` and result are typed from the declared domain type; otherwise they fall back to
+ * `WorkerVars`. The body is a pass-through — the wire stays untyped JSON (ADR 0029 §3). This file
+ * never changes with the schema, so it is written verbatim (unlike the regenerated
+ * `worker-io.d.ts`). A byte-faithful port of the console's `emitWorkerBindingsRuntime`.
+ */
+export function emitWorkerBindingsRuntime() {
+    return "// AUTO-GENERATED by nanobpmn (ADR 0033 §3): the typed `defineWorker`.\n" +
+        "// Re-exports the worker SDK and overrides `defineWorker` with a taskType-keyed\n" +
+        "// typed signature (job.variables, job.customHeaders + result typed from the\n" +
+        "// worker's declared input/output/header contract). Erased to a pass-through at\n" +
+        "// runtime. Do not edit.\n" +
+        "// eslint-disable\n\n" +
+        `import { defineWorker as defineWorkerRaw } from "./worker-sdk.ts";\n` +
+        `import type { WorkerOptions } from "./worker-sdk.ts";\n` +
+        `import type { WorkerInputs, WorkerOutputs, WorkerHeaders, WorkerTaskType, WorkerVars, WorkerHdrs } from "./${WORKER_BINDINGS_DTS}";\n\n` +
+        `export * from "./worker-sdk.ts";\n\n` +
+        `type InFor<K extends WorkerTaskType> = K extends keyof WorkerInputs ? WorkerInputs[K] : WorkerVars;\n` +
+        `type OutFor<K extends WorkerTaskType> = K extends keyof WorkerOutputs ? WorkerOutputs[K] : WorkerVars;\n` +
+        `type HdrFor<K extends WorkerTaskType> = K extends keyof WorkerHeaders ? WorkerHeaders[K] : WorkerHdrs;\n\n` +
+        `/**\n` +
+        ` * Typed \`defineWorker\`: \`type\` is constrained to the model's declared job types\n` +
+        ` * (\`WorkerTaskType\`, ADR 0033 §3) so it autocompletes and rejects unknown jobs,\n` +
+        ` * and the handler's \`job.variables\`, \`job.customHeaders\` + result are typed from\n` +
+        ` * the worker's declared \`inputType\`/\`outputType\`/header keys. A declared job type\n` +
+        ` * with no declared type falls back to WorkerVars / WorkerHdrs.\n` +
+        ` */\n` +
+        `export function defineWorker<K extends WorkerTaskType>(\n` +
+        `  opts: { type: K } & WorkerOptions<InFor<K> & object, OutFor<K> & object, HdrFor<K> & object>,\n` +
+        `): void {\n` +
+        `  defineWorkerRaw(opts as unknown as WorkerOptions);\n` +
+        `}\n`;
+}

package/dist/toolkit/index.d.ts

@@ -2,14 +2,16 @@ export type { DerivedArtifact, Deriver } from "./artifact.ts";
 export { GENERATED_DIR, sortArtifacts } from "./artifact.ts";
 export { deriveMigrations, migrationsDeriver, sqlType, createTableSql, tableSchemaForType, groupTypesBySource, } from "./derivers/migrations.ts";
 export type { ToolkitManifest, ToolkitType, ToolkitField, DerivedColumn, DerivedTable, } from "./derivers/migrations.ts";
-export { deriveDomain, emitDomain, emitDomainModel, emitDomainDts, emitDomainDtsForSources, emitDomainTypeRegistry, domainDeriver, sourcesFromManifest, registryFromManifest, sqliteAffinityToTs, interfaceName, } from "./derivers/domain.ts";
-export type { SourceSchema, DomainFieldDef, DomainTypeDef, DomainTypeRegistry, } from "./derivers/domain.ts";
-export { deriveWorkerBindings, emitWorkerBindings, workerIoDeriver, scanModelWorkers, WORKER_BINDINGS_DTS, DOMAIN_DTS, } from "./derivers/worker-io.ts";
+export { deriveDomain, emitDomain, emitDomainModel, emitDomainBindings, emitDomainDts, emitDomainDtsForSources, emitDomainTypeRegistry, domainDeriver, isPrimitiveKeyword, sourcesFromManifest, registryFromManifest, sqliteAffinityToTs, interfaceName, DOMAIN_BINDINGS, } from "./derivers/domain.ts";
+export type { SourceSchema, DomainFieldDef, DomainTypeDef, DomainTypeRegistry, ColumnMeta, TableMeta, } from "./derivers/domain.ts";
+export { resolveShapes, columnToField, emitDomainModelJson, DOMAIN_MODEL_JSON, } from "./derivers/shapes.ts";
+export type { ShapeOp, ShapeDecl, ShapeDiagnostic, ShapeResolution, FusedMetaDecl, } from "./derivers/shapes.ts";
+export { deriveWorkerBindings, emitWorkerBindings, emitWorkerBindingsRuntime, overlayDerivedWorkerIo, workerIoDeriver, scanModelWorkers, WORKER_BINDINGS_DTS, WORKER_BINDINGS_TS, DOMAIN_DTS, } from "./derivers/worker-io.ts";
 export type { ModelSource, WorkerIo, WorkerBindingDecl } from "./derivers/worker-io.ts";
 export { byModelPath, typeRefFor } from "./derivers/worker-io.ts";
 export { deriveMeta, emitMeta, foldMeta, metaDeriver, scanModelMeta, META_TS, } from "./derivers/meta.ts";
 export type { MetaDecl } from "./derivers/meta.ts";
-export { deriveMessageBindings, emitMessageBindings, messagesDeriver, scanModelMessages, MESSAGE_BINDINGS_DTS, } from "./derivers/messages.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 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<{
     models: import("./derivers/worker-io.ts").ModelSource[];

package/dist/toolkit/index.js

@@ -5,11 +5,12 @@
 export { GENERATED_DIR, sortArtifacts } from "./artifact.js";
 // Derivers
 export { deriveMigrations, migrationsDeriver, sqlType, createTableSql, tableSchemaForType, groupTypesBySource, } from "./derivers/migrations.js";
-export { deriveDomain, emitDomain, emitDomainModel, emitDomainDts, emitDomainDtsForSources, emitDomainTypeRegistry, domainDeriver, sourcesFromManifest, registryFromManifest, sqliteAffinityToTs, interfaceName, } from "./derivers/domain.js";
-export { deriveWorkerBindings, emitWorkerBindings, workerIoDeriver, scanModelWorkers, WORKER_BINDINGS_DTS, DOMAIN_DTS, } from "./derivers/worker-io.js";
+export { deriveDomain, emitDomain, emitDomainModel, emitDomainBindings, emitDomainDts, emitDomainDtsForSources, emitDomainTypeRegistry, domainDeriver, isPrimitiveKeyword, sourcesFromManifest, registryFromManifest, sqliteAffinityToTs, interfaceName, DOMAIN_BINDINGS, } from "./derivers/domain.js";
+export { resolveShapes, columnToField, emitDomainModelJson, DOMAIN_MODEL_JSON, } from "./derivers/shapes.js";
+export { deriveWorkerBindings, emitWorkerBindings, emitWorkerBindingsRuntime, overlayDerivedWorkerIo, workerIoDeriver, scanModelWorkers, WORKER_BINDINGS_DTS, WORKER_BINDINGS_TS, DOMAIN_DTS, } from "./derivers/worker-io.js";
 export { byModelPath, typeRefFor } from "./derivers/worker-io.js";
 export { deriveMeta, emitMeta, foldMeta, metaDeriver, scanModelMeta, META_TS, } from "./derivers/meta.js";
-export { deriveMessageBindings, emitMessageBindings, messagesDeriver, scanModelMessages, MESSAGE_BINDINGS_DTS, } from "./derivers/messages.js";
+export { deriveMessageBindings, emitMessageBindings, emitMessageBindingsRuntime, messagesDeriver, scanModelMessages, MESSAGE_BINDINGS_DTS, MESSAGE_BINDINGS_TS, } from "./derivers/messages.js";
 // The registry of all derivers (for discovery / IDE migration).
 import { migrationsDeriver } from "./derivers/migrations.js";
 import { domainDeriver } from "./derivers/domain.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.25.0",
+  "version": "0.27.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",
@@ -19,7 +19,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jwulf/nano-ide.git",
+    "url": "git+https://github.com/nanobpm/nano-ide.git",
     "directory": "packages/urban"
   },
   "engines": {

package/src/runtime/core/modules/dataops.test.ts

@@ -46,6 +46,11 @@ function expectRecords(value: unknown): Record<string, unknown>[] {
   return value;
 }
 
+function expectString(value: unknown): string {
+  if (typeof value !== "string") throw new TypeError("expected a string");
+  return value;
+}
+
 test("sources lists declared datasources and the default", async () => {
   const { dir, cleanup } = await fixture();
   try {
@@ -225,15 +230,6 @@ test("migrations treats a missing migrations dir as an empty list", async () =>
   }
 });
 
-test("domaintypes is not yet implemented and errors clearly", async () => {
-  const { dir, cleanup } = await fixture();
-  try {
-    await assert.rejects(run(dir, { op: "domaintypes" }), /not yet implemented/);
-  } finally {
-    await cleanup();
-  }
-});
-
 test("an unknown op and an unknown source error", async () => {
   const { dir, cleanup } = await fixture();
   try {
@@ -304,3 +300,130 @@ test("an absolute --manifest path is honoured as-is (not re-prefixed with root)"
     await cleanup();
   }
 });
+
+// --- domaintypes: live-schema reification + shape fuse (ADR 0029 §4/§6, ADR 0040 §9/§10) ---
+//
+// The op ported off the console's vendored data_cli (host dry-out nano-bpm#576). It migrates each
+// sqlite source (write mode only), introspects the live schema, folds the manifest `types` + the
+// model's composed shapes through the fuse, and RETURNS every artifact's content (the read-only
+// host never writes files — the caller persists). These lock that contract.
+
+test("domaintypes migrates, introspects the live schema, and returns every artifact", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    const r = await run(dir, { op: "domaintypes" });
+    // Both migrations ran on the shared `_urban_migrations` ledger before introspection.
+    assert.deepEqual(r.migrated, { app: ["001_orders.sql", "002_customers.sql"] });
+    // Two tables reified from the live schema.
+    assert.equal(r.tables, 2);
+    // The domain `.d.ts` carries an interface per live table.
+    assert.equal(typeof r.text, "string");
+    assert.match(expectString(r.text), /export interface Orders\b/);
+    assert.match(expectString(r.text), /export interface Customers\b/);
+    // Persisting: every `*Path` is the app-relative nano-generated target.
+    assert.equal(r.path, "nano-generated/domain-rows.d.ts");
+    assert.equal(r.bindingsPath, "nano-generated/domain.ts");
+    assert.equal(r.workerBindingsPath, "nano-generated/worker-io.d.ts");
+    assert.equal(r.workerRuntimePath, "nano-generated/workers.ts");
+    assert.equal(r.messageBindingsPath, "nano-generated/message-io.d.ts");
+    assert.equal(r.messageRuntimePath, "nano-generated/messages.ts");
+    assert.equal(r.metaPath, "nano-generated/meta.ts");
+    assert.equal(r.domainModelPath, "nano-generated/domain.json");
+    // The Fused Domain Model is emitted and lists both live tables.
+    assert.equal(typeof r.domainModel, "string");
+    const model = JSON.parse(expectString(r.domainModel));
+    assert.deepEqual(
+      model.entities.map((e: { id: string }) => e.id).sort(),
+      ["app.customers", "app.orders"],
+    );
+    // The static runtime wrappers are returned verbatim for the caller to write.
+    assert.equal(typeof r.workerRuntime, "string");
+    assert.equal(typeof r.messageRuntime, "string");
+    assert.deepEqual(r.shapeDiagnostics, []);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("domaintypes write:false is a side-effect-free preview (no migrate, null paths)", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    const r = await run(dir, { op: "domaintypes", write: false });
+    // The preview never migrates — nothing applied, DB stays fresh.
+    assert.deepEqual(r.migrated, {});
+    // …and because this fixture's DB is fresh (unmigrated), introspecting the *current* live schema
+    // finds no tables. (An existing DB could legitimately report tables here; this count is scoped
+    // to the fresh fixture, not a general preview guarantee.)
+    assert.equal(r.tables, 0);
+    // Content is still returned (the composer preview needs `text`)…
+    assert.equal(typeof r.text, "string");
+    // …but every persistence target is null and the largest artifact is skipped.
+    assert.equal(r.path, null);
+    assert.equal(r.bindingsPath, null);
+    assert.equal(r.workerBindingsPath, null);
+    assert.equal(r.workerRuntimePath, null);
+    assert.equal(r.messageBindingsPath, null);
+    assert.equal(r.messageRuntimePath, null);
+    assert.equal(r.metaPath, null);
+    assert.equal(r.domainModelPath, null);
+    assert.equal(r.domainModel, null);
+    // A second preview did not leave a migrated DB behind for the next write.
+    const applied = await run(dir, { op: "migrations" });
+    assert.ok(expectRecords(applied.entries).every((e) => e.applied === false));
+  } finally {
+    await cleanup();
+  }
+});
+
+test("domaintypes folds a composed shape into DomainTypes and reports its diagnostics", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    const r = await run(dir, {
+      op: "domaintypes",
+      derivedShapes: [
+        {
+          id: "ReviewRound",
+          ops: [
+            { op: "extend", name: "prUrl", type: "string" },
+            { op: "extend", name: "approved", type: "boolean" },
+          ],
+        },
+        // A broken shape: unresolved extend type → error diagnostic, omitted from the emit.
+        { id: "Broken", ops: [{ op: "extend", name: "ref", type: "NoSuchType" }] },
+      ],
+    });
+    // The good shape reifies into the `DomainTypes` registry surfaced by the domain `.d.ts`.
+    assert.match(expectString(r.text), /ReviewRound/);
+    assert.doesNotMatch(expectString(r.text), /Broken/);
+    // The broken shape's diagnostic is returned so the panel can surface it.
+    const diags = expectRecords(r.shapeDiagnostics);
+    assert.equal(diags.length, 1);
+    assert.equal(diags[0].shape, "Broken");
+    assert.equal(diags[0].severity, "error");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("domaintypes emits worker/message bindings from the injected model IO maps", async () => {
+  const { dir, cleanup } = await fixture();
+  try {
+    const r = await run(dir, {
+      op: "domaintypes",
+      derivedShapes: [
+        { id: "Order", ops: [{ op: "extend", name: "total", type: "integer" }] },
+      ],
+      derivedWorkers: [
+        { taskType: "review", inputType: "Order", outputType: "Order", headerKeys: ["priority"] },
+      ],
+      derivedMessages: [{ messageName: "approved", inputType: "Order" }],
+    });
+    // The worker binding names the task type and threads the declared header key.
+    assert.match(expectString(r.workerBindings), /review/);
+    assert.match(expectString(r.workerBindings), /priority/);
+    // The message binding names the message.
+    assert.match(expectString(r.messageBindings), /approved/);
+  } finally {
+    await cleanup();
+  }
+});

package/src/runtime/core/modules/dataops.ts

@@ -14,9 +14,10 @@
 //   op = "sources" | "schema" | "query" | "exec" | "script" | "migrations" | "migrate"
 //      | "domaintypes"
 //
-// `domaintypes` (live-schema reification + shape resolution) is a known protocol op but is
-// intentionally NOT handled here yet — it is ported to `urban data` in a follow-up (PR 2 of
-// #576) and errors clearly for now.
+// `domaintypes` (live-schema reification + shape resolution) composes the domain reifier from the
+// pure toolkit derivers (ported from the console's `domain_types.ts`, host dry-out #576); it never
+// writes files (the host is read-only) — it returns every artifact's content and the caller
+// persists it.
 
 import type { HostContext, SqliteDb } from "../host.ts";
 import { isRecord } from "../guards.ts";
@@ -25,11 +26,48 @@ import { loadManifest } from "../manifest.ts";
 import { validateManifest } from "../validate.ts";
 import { makeGateway, type DataSource as GatewayDataSource } from "./gateway.ts";
 import { applyMigrations, MIGRATIONS_TABLE, openSqliteSource, resolveAppPath } from "./datasource.ts";
+// 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.ts";
+import {
+  DOMAIN_BINDINGS,
+  type DomainTypeDef,
+  type DomainTypeRegistry,
+  emitDomainBindings,
+  emitDomainModel,
+  registryFromManifest,
+  type SourceSchema,
+} from "../../../toolkit/derivers/domain.ts";
+import {
+  DOMAIN_MODEL_JSON,
+  emitDomainModelJson,
+  type FusedMetaDecl,
+  resolveShapes,
+  type ShapeDecl,
+} from "../../../toolkit/derivers/shapes.ts";
+import {
+  DOMAIN_DTS,
+  emitWorkerBindings,
+  emitWorkerBindingsRuntime,
+  overlayDerivedWorkerIo,
+  WORKER_BINDINGS_DTS,
+  WORKER_BINDINGS_TS,
+  type WorkerBindingDecl,
+} from "../../../toolkit/derivers/worker-io.ts";
+import {
+  emitMessageBindings,
+  emitMessageBindingsRuntime,
+  MESSAGE_BINDINGS_DTS,
+  MESSAGE_BINDINGS_TS,
+  type MessageBindingDecl,
+} from "../../../toolkit/derivers/messages.ts";
+import { emitMeta, META_TS, type MetaDecl } from "../../../toolkit/derivers/meta.ts";
 
-/** The DB-manager op protocol's known op set. `domaintypes` is part of the protocol but is not
- * yet handled here (it errors clearly — see the file header); every other op is dispatched by
- * `runDataOp`. Typing `op` as this union (instead of `string`) gives SDK/console callers
- * type-safety and catches typos at compile time. */
+/** 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. */
 export type DataOp =
   | "sources"
   | "schema"
@@ -46,6 +84,27 @@ export interface DataRequest {
   sql?: string;
   params?: unknown[];
   statements?: string[];
+  /**
+   * `domaintypes`: persist the derived artifacts (default true). A `write:false` request is the
+   * latency-sensitive composer preview — it introspects WITHOUT migrating the DB first and returns
+   * only the artifact *content* (never a DB side-effect per keystroke). `urban data` never writes
+   * files itself (the host is read-only); the caller persists the returned content when `write` is
+   * not false. This flag only gates the pre-introspection migration side-effect.
+   */
+  write?: boolean;
+  /** `domaintypes`: the model-derived worker-IO map (`taskType → {in,out,headerKeys}`), scanned
+   * from the process models by the caller. Overlaid on the manifest `workers[]` (authoritative for
+   * the envelope). Absent → the manifest projection alone. */
+  derivedWorkers?: WorkerBindingDecl[];
+  /** `domaintypes`: the model-derived message-payload map (`messageName → {in,out}`), scanned from
+   * the models' `bpmn:message` envelopes. Authoritative (no manifest projection). */
+  derivedMessages?: MessageBindingDecl[];
+  /** `domaintypes`: the model-derived composed shapes (`nano:shape`). Each is resolved through the
+   * fuse into a flat domain type folded into the `types` registry. Absent → no shapes. */
+  derivedShapes?: ShapeDecl[];
+  /** `domaintypes`: the model-derived model-level metadata (`nano:meta`). Folded into `meta.ts` and
+   * the structured `domain.json`. Absent → no metadata. */
+  derivedMeta?: MetaDecl[];
 }
 
 /** One datasource the manifest declares, resolved against the environment (env templates in
@@ -281,10 +340,120 @@ export async function runDataOp(
       }
     }
     case "domaintypes": {
-      throw new Error(
-        "`domaintypes` is not yet implemented in `urban data` — the Nano console still serves it " +
-          "(tracked as PR 2 of nano-bpm#576)",
-      );
+      // ADR 0029 §4.1/§4.2/§6 + ADR 0040 §9/§10: reify the domain model from the *live* schema.
+      // Union every declared datasource (the table spine), fold in the manifest `types` registry and
+      // the model's composed `nano:shape`s (resolved through the fuse), and derive the worker/message
+      // typed accessors. Unlike the vendored data_cli, this op NEVER writes files (the host is
+      // read-only): it returns every artifact's content and the caller persists it. `write:false` is
+      // the latency-sensitive composer preview — it skips the pre-introspection migration so a
+      // debounced keystroke has no DB side-effect and pays only for `text` + `shapeDiagnostics`.
+      const { default: def, sources } = listSources(manifest);
+      const persist = req.write !== false;
+      // 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.
+      const migrated: Record<string, string[]> = {};
+      const schemas: SourceSchema[] = [];
+      for (const s of sources) {
+        if (String(s.driver) !== "sqlite") continue; // only sqlite is introspectable (see openGateway)
+        const { gw, db } = await openGateway(host, root, manifest, s.name);
+        try {
+          if (persist) {
+            const applied = await applyMigrations(
+              host,
+              db,
+              root,
+              s.migrations ?? DEFAULT_MIGRATIONS_DIR,
+            );
+            if (applied.length) migrated[s.name] = applied;
+          }
+          schemas.push({ source: s.name, tables: await gw.schema() });
+        } finally {
+          db.close();
+        }
+      }
+
+      const types = registryFromManifest(manifest);
+      // Snapshot the manifest `types` *before* folding the resolved shapes so `domain.json` can tag
+      // each entity with its true provenance (manifest vs model) — once folded they are
+      // indistinguishable in `types`.
+      const manifestTypesSnapshot: DomainTypeRegistry = { ...types };
+      // Composed motion shapes (ADR 0040 §9/§10): resolve each `nano:shape` against the leaf fuse
+      // into a flat domain type and fold it into the registry *before* it feeds the domain model and
+      // the worker/message bindings, so a composed shape becomes a first-class `DomainTypes` entry.
+      // Broken shapes are omitted; their diagnostics are returned so the panel can surface them.
+      const shapeResolution = resolveShapes(req.derivedShapes ?? [], types, schemas);
+      const shapeDeclById = new Map((req.derivedShapes ?? []).map((s) => [s.id, s]));
+      const shapeEntities: { decl: ShapeDecl; def: DomainTypeDef }[] = [];
+      for (const [id, shapeDef] of Object.entries(shapeResolution.types)) {
+        types[id] = shapeDef;
+        shapeEntities.push({ decl: shapeDeclById.get(id) ?? { id, ops: [] }, def: shapeDef });
+      }
+      const declaredIds = Object.keys(types);
+
+      const text = emitDomainModel(schemas, def, types);
+      const bindings = emitDomainBindings(schemas, def);
+      const derivedMeta: MetaDecl[] = req.derivedMeta ?? [];
+      const metaAccessor = emitMeta(derivedMeta);
+      // Worker-IO map (ADR 0033 §3): the model is authoritative for the envelope, so an injected
+      // `derivedWorkers` is overlaid on the manifest `workers[]` (which still carries non-IO
+      // bindings such as `llm`); absent, the manifest projection stands alone.
+      const manifestWorkers: WorkerBindingDecl[] = (manifest.workers ?? []).map((w) => ({
+        taskType: w.taskType,
+        inputType: w.inputType,
+        outputType: w.outputType,
+      }));
+      const workers = req.derivedWorkers
+        ? overlayDerivedWorkerIo(manifestWorkers, req.derivedWorkers)
+        : manifestWorkers;
+      const workerBindings = emitWorkerBindings(workers, declaredIds);
+      const workerRuntime = emitWorkerBindingsRuntime();
+      // Message-payload registry (ADR 0040 slice 2): no manifest projection, so the model-derived
+      // map is authoritative and emitted directly.
+      const messages = req.derivedMessages ?? [];
+      const messageBindings = emitMessageBindings(messages, declaredIds);
+      const messageRuntime = emitMessageBindingsRuntime();
+      // The structured Fused Domain Model (`domain.json`, ADR 0040 §1): the largest artifact, so it
+      // is built only when persisting (the preview consumes only `text` + `shapeDiagnostics`).
+      const meta: FusedMetaDecl[] = derivedMeta;
+      const domainModel = persist
+        ? emitDomainModelJson({
+            sources: schemas,
+            default: def,
+            manifestTypes: manifestTypesSnapshot,
+            shapes: shapeEntities,
+            meta,
+            diagnostics: shapeResolution.diagnostics,
+          })
+        : null;
+
+      const rel = (name: string): string => `${GENERATED_DIR}/${name}`;
+      const tables = schemas.reduce((n, s) => n + s.tables.length, 0);
+      // The returned `*Path` fields are the app-relative targets the caller writes to when
+      // persisting (null on a preview). `urban data` returns content only — persisting is the
+      // caller's job (host dry-out nano-bpm#576). The static runtime wrappers (`workers.ts`,
+      // `messages.ts`) are returned too so the caller can write them verbatim.
+      return {
+        path: persist ? rel(DOMAIN_DTS) : null,
+        text,
+        tables,
+        bindingsPath: persist ? rel(DOMAIN_BINDINGS) : null,
+        bindings,
+        workerBindingsPath: persist ? rel(WORKER_BINDINGS_DTS) : null,
+        workerBindings,
+        workerRuntimePath: persist ? rel(WORKER_BINDINGS_TS) : null,
+        workerRuntime,
+        messageBindingsPath: persist ? rel(MESSAGE_BINDINGS_DTS) : null,
+        messageBindings,
+        messageRuntimePath: persist ? rel(MESSAGE_BINDINGS_TS) : null,
+        messageRuntime,
+        metaPath: persist ? rel(META_TS) : null,
+        meta: metaAccessor,
+        domainModelPath: persist ? rel(DOMAIN_MODEL_JSON) : null,
+        domainModel,
+        migrated,
+        shapeDiagnostics: shapeResolution.diagnostics,
+      };
     }
     default:
       throw new Error(`unknown op "${req.op}"`);

package/src/runtime/core/modules/pages.test.ts

@@ -86,14 +86,56 @@ test("GET / serves the renderer shell with the home marker", async () => {
   assert.equal(res.status, 200);
   assert.match(res.headers?.["content-type"] ?? "", /text\/html/);
   assert.match(res.body ?? "", /data-home="home"/);
+  // The runtime module is loaded by a *relative* src so it resolves against the
+  // document's mount path — works both at the origin root and under the Nano
+  // console's /console/app-view/<name>/ reverse proxy. A root-absolute
+  // "/app/runtime.js" would 404 against the console origin and never hydrate.
+  assert.match(res.body ?? "", /src="\.\/app\/runtime\.js"/);
+  assert.doesNotMatch(res.body ?? "", /src="\/app\/runtime\.js"/);
+});
+
+test("the shell styles the app through the shared --nano-* token contract", async () => {
+  const res = await dispatch("GET", "/");
+  const html = res.body ?? "";
+  // Body colours resolve through the console's token vocabulary, not hardcoded hex.
+  assert.match(html, /background:var\(--nano-app\)/);
+  assert.match(html, /color:var\(--nano-text\)/);
+  assert.match(html, /--pc-accent:var\(--nano-accent\)/);
+  // Self-contained defaults for standalone (CLI) runs: dark base + a light
+  // palette gated on data-appearance, and prefers-color-scheme only until themed.
+  assert.match(html, /--nano-accent:#8b5cf6/);
+  assert.match(html, /\[data-appearance="light"\]/);
+  assert.match(html, /:root:not\(\[data-appearance\]\)/);
 });
 
 test("GET /app/runtime.js serves the renderer module", async () => {
   const res = await dispatch("GET", "/app/runtime.js");
   assert.match(res.headers?.["content-type"] ?? "", /javascript/);
   assert.match(res.body ?? "", /pc:refresh/);
+  // Endpoints are rebased against the served module URL so the app works under a
+  // path-prefixed reverse proxy (Nano console embed), not just at the origin root.
+  assert.match(res.body ?? "", /new URL\("\.\.\/", import\.meta\.url\)/);
+  assert.match(res.body ?? "", /function apiUrl\(u\)/);
+});
+
+test("the renderer bridges the console theme over postMessage", async () => {
+  const res = await dispatch("GET", "/app/runtime.js");
+  const js = res.body ?? "";
+  // Announces readiness to the framing console (same-origin, posture A).
+  assert.match(js, /postMessage\(\{ type: "nano-app-ready" \}, window\.location\.origin\)/);
+  // Only trusts the framing parent, and only accepts nano-theme messages.
+  assert.match(js, /ev\.source === window\.parent/);
+  // Same-origin posture A: a cross-origin framer is rejected before applyTheme.
+  assert.match(js, /ev\.origin === window\.location\.origin/);
+  assert.match(js, /msg\.type !== "nano-theme"/);
+  // Mirrors the console appearance + lays --nano-* tokens onto :root; ignores
+  // any property outside the shared token namespace.
+  assert.match(js, /el\.dataset\.appearance = msg\.appearance/);
+  assert.match(js, /k\.startsWith\("--nano-"\)/);
+  assert.match(js, /el\.style\.setProperty\(k, v\)/);
 });
 
+
 test("renderer preserves grid row-detail expansion across refreshes", async () => {
   // Regression: the 5s poll rebuilds the whole tbody, which used to collapse an open
   // detail row (e.g. the escalation-answer form). The client now tracks open rowKeys