@nanobpm/urban 0.16.1 → 0.17.1

package/dist/toolkit/derivers/messages.js

@@ -0,0 +1,134 @@
+// Deriver: BPMN models → `message-io.d.ts`, the message-payload type map (ADR 0040 slice 2).
+// Scans each process for `bpmn:message` envelopes and maps each message name to its declared
+// payload type. It emits the SAME `message-io.d.ts` the console generates (a faithful port of
+// `emitMessageBindings` in the server's domain_types.ts), so the toolkit is a drop-in for the
+// IDE's codegen (ADR 0053). The static typed-`publishMessage` wrapper (`messages.ts`) never
+// changes with the model, so — like the worker SDK — it is a package/runtime concern, not a
+// derived artifact; only the model-derived `message-io.d.ts` is emitted here.
+import { GENERATED_DIR } from "../artifact.js";
+import { byModelPath, DOMAIN_DTS, typeRefFor } from "./worker-io.js";
+/** Filename the console uses for the derived message-payload map; kept identical (drop-in). */
+export const MESSAGE_BINDINGS_DTS = "message-io.d.ts";
+const ENVELOPE_IN = "io.nanobpm.dataEnvelope.in";
+const ENVELOPE_OUT = "io.nanobpm.dataEnvelope.out";
+function attr(tag, name) {
+    const m = tag.match(new RegExp(`\\b${name}\\s*=\\s*"([^"]*)"`));
+    return m ? m[1] : undefined;
+}
+/** An envelope ref is trimmed; an empty/whitespace value contributes nothing (mirrors the
+ * Rust `envelope_ref`). A message name, by contrast, is a correlation identity matched
+ * verbatim by the engine, so it is NOT trimmed — only an absent/empty name is dropped. */
+function envelopeRef(value) {
+    const v = value?.trim();
+    return v ? v : undefined;
+}
+/** Scan one BPMN document for `bpmn:message` envelopes. Handles both a self-closing
+ * `<bpmn:message name=.. />` (name only — completes the `MessageName` union) and an open
+ * message whose body carries the `io.nanobpm.dataEnvelope.in/out` `zeebe:property`. */
+export function scanModelMessages(xml) {
+    const out = [];
+    const blockRe = /<bpmn:message\b([^>]*?)(?:\/>|>([\s\S]*?)<\/bpmn:message>)/g;
+    let m;
+    while ((m = blockRe.exec(xml)) !== null) {
+        const name = attr(`<x ${m[1]}>`, "name");
+        if (name == null || name.length === 0)
+            continue;
+        const io = { messageName: name };
+        const body = m[2] ?? "";
+        const propRe = /<zeebe:property\b[^>]*>/g;
+        let p;
+        while ((p = propRe.exec(body)) !== null) {
+            const pname = attr(p[0], "name");
+            if (pname === ENVELOPE_IN)
+                io.inputType = envelopeRef(attr(p[0], "value"));
+            else if (pname === ENVELOPE_OUT)
+                io.outputType = envelopeRef(attr(p[0], "value"));
+        }
+        out.push(io);
+    }
+    return out;
+}
+// --- Faithful port of the console's emitMessageBindings (domain_types.ts) so the emitted
+//     message-io.d.ts is byte-compatible with the IDE's own codegen. ---
+/** Emit `message-io.d.ts` from message bindings + the set of declared domain type ids.
+ * Each named message joins the `MessageName` union; a message whose envelope names a
+ * declared type also maps to it in `MessagePayloads` (else falls back to `MessageVars`). */
+export function emitMessageBindings(messages, declaredTypeIds) {
+    const declared = new Set(declaredTypeIds);
+    const propKey = (m) => JSON.stringify(m);
+    const names = [
+        ...new Set(messages
+            .map((m) => m?.messageName)
+            .filter((n) => typeof n === "string" && n.length > 0)),
+    ];
+    const nameUnion = names.length > 0
+        ? names.map((n) => JSON.stringify(n)).join(" | ")
+        : "string";
+    const payloads = [];
+    for (const m of messages) {
+        if (typeof m?.messageName !== "string" || m.messageName.length === 0)
+            continue;
+        const ref = typeRefFor(m.inputType, declared);
+        if (ref)
+            payloads.push(`  ${propKey(m.messageName)}: ${ref};`);
+    }
+    const header = "// AUTO-GENERATED by nanobpmn from the process model (ADR 0040 slice 2).\n" +
+        "// The bridge from a `bpmn:message`'s data envelope to the message type system:\n" +
+        "// each named message maps to the TS type of its payload, so the typed\n" +
+        "// `publishMessage` types a call by its message name. Do not edit — regenerated\n" +
+        "// from the model. Erased to plain JS at compile.\n" +
+        "// eslint-disable\n";
+    const needsRegistry = payloads.length > 0;
+    const importTypes = needsRegistry
+        ? `import type { DomainTypes } from "./${DOMAIN_DTS}";\n`
+        : "";
+    const payloadsIface = payloads.length > 0
+        ? `export interface MessagePayloads {\n${payloads.join("\n")}\n}\n`
+        : `export interface MessagePayloads {}\n`;
+    return `${header}\n` +
+        importTypes +
+        `\n/** Untyped fallback payload for a message that declares no envelope type. */\n` +
+        `export type MessageVars = Record<string, unknown>;\n\n` +
+        `/** Every declared message \`name\` (ADR 0040 slice 2): the model-derived set the\n` +
+        ` * typed \`publishMessage\` accepts, so \`name\` autocompletes and rejects unknown messages. */\n` +
+        `export type MessageName = ${nameUnion};\n\n` +
+        `/** Payload (\`variables\`) per declared message, keyed by \`name\`. */\n` +
+        payloadsIface;
+}
+/**
+ * Derive `nano-generated/message-io.d.ts` from BPMN models. Messages are aggregated the way
+ * the console's Rust scan does (a `BTreeMap` keyed by name): deduped by name, sorted by name,
+ * with the envelope type refs merged first-wins across models — so the derived output matches
+ * the host's `derivedMessages` for the same models. `declaredTypeIds` is the manifest `types`
+ * key set; a message only gets a typed payload when its envelope names a declared type.
+ */
+export function deriveMessageBindings(models, declaredTypeIds = []) {
+    const byName = new Map();
+    for (const model of [...models].sort(byModelPath)) {
+        for (const msg of scanModelMessages(model.xml)) {
+            const existing = byName.get(msg.messageName);
+            if (!existing) {
+                byName.set(msg.messageName, {
+                    messageName: msg.messageName,
+                    inputType: msg.inputType,
+                    outputType: msg.outputType,
+                });
+            }
+            else {
+                // First-wins merge of the envelope refs (mirrors the Rust `fill`).
+                if (existing.inputType == null)
+                    existing.inputType = msg.inputType;
+                if (existing.outputType == null)
+                    existing.outputType = msg.outputType;
+            }
+        }
+    }
+    const messages = [...byName.values()].sort((a, b) => a.messageName < b.messageName ? -1 : a.messageName > b.messageName ? 1 : 0);
+    const content = emitMessageBindings(messages, declaredTypeIds);
+    return [{ path: `${GENERATED_DIR}/${MESSAGE_BINDINGS_DTS}`, content }];
+}
+export const messagesDeriver = {
+    id: "model->message-io",
+    describe: "Derive message-io.d.ts (bpmn:message name + envelope payload) from BPMN models.",
+    derive: ({ models, declaredTypeIds }) => deriveMessageBindings(models, declaredTypeIds),
+};

package/dist/toolkit/derivers/meta.d.ts

@@ -0,0 +1,34 @@
+import type { DerivedArtifact, Deriver } from "../artifact.ts";
+import { type ModelSource } from "./worker-io.ts";
+/** Basename the console uses for the generated accessor; kept identical (drop-in). */
+export declare const META_TS = "meta.ts";
+/** One model-level metadata entry (`nano:meta`), tagged with its defining process for
+ * the `model:<processId>` provenance (ADR 0040 §5). `process` is carried for the fuse;
+ * the emitted `meta.ts` folds on key/value only. */
+export interface MetaDecl {
+    process?: string;
+    key: string;
+    value: string;
+}
+/** Scan one BPMN document for model-level `nano:meta` key/value entries, in document
+ * order, tagged with the enclosing process. A meta with no `key` attribute is ignored;
+ * a missing `value` folds to the empty string (matches envelope_scan.rs). */
+export declare function scanModelMeta(xml: string): MetaDecl[];
+/** Fold the scanned model-level metadata into a single key→value record. When two models
+ * declare the same key the last (scan order) wins. Empty keys are ignored. The accumulator
+ * is a **null-prototype** dict so user-authored keys (including `__proto__`) round-trip
+ * deterministically as own data properties. */
+export declare function foldMeta(metas: MetaDecl[]): Record<string, string>;
+/** Emit `meta.ts`: the typed model-metadata accessor (`@nanobpm/meta`, ADR 0040 §5).
+ * `AppMeta` keys the declared metadata as string-literal properties; `appMeta` is the
+ * concrete null-prototype record; the overloaded `meta()` returns the typed value for a
+ * known key and `string | undefined` for a dynamic one. Strip-safe (ADR 0036). */
+export declare function emitMeta(metas: MetaDecl[]): string;
+/**
+ * Derive `nano-generated/meta.ts` from BPMN models. Deterministic: models are scanned in
+ * path order, then their `nano:meta` entries folded (last write wins) into the accessor.
+ */
+export declare function deriveMeta(models: ModelSource[]): DerivedArtifact[];
+export declare const metaDeriver: Deriver<{
+    models: ModelSource[];
+}>;

package/dist/toolkit/derivers/meta.js

@@ -0,0 +1,106 @@
+// Deriver: BPMN models → `meta.ts`, the typed model-metadata accessor (`@nanobpm/meta`,
+// ADR 0040 §5). Scans each process for `nano:meta` key/value siblings of the `nano:shapes`
+// container and folds them into a single app-wide record. It emits the SAME `meta.ts` the
+// console generates (a faithful port of `foldMeta`/`emitMeta` in the server's domain_types.ts),
+// so the toolkit is a drop-in for the IDE's codegen (ADR 0053).
+import { GENERATED_DIR } from "../artifact.js";
+import { byModelPath } from "./worker-io.js";
+/** Basename the console uses for the generated accessor; kept identical (drop-in). */
+export const META_TS = "meta.ts";
+function attr(tag, name) {
+    const m = tag.match(new RegExp(`\\b${name}\\s*=\\s*"([^"]*)"`));
+    return m ? m[1] : undefined;
+}
+function processId(xml) {
+    const m = xml.match(/<[\w.-]*:?process\b[^>]*>/);
+    return m ? attr(m[0], "id") : undefined;
+}
+// A `nano:shape` carrier (`<...:shape>…</...:shape>`, and self-closing) — meta is only
+// recognised *outside* a shape carrier (its op children, e.g. `extend`, are a different
+// vocabulary), so strip carriers before matching `nano:meta` (mirrors envelope_scan.rs).
+const SHAPE_BLOCK_RE = /<([\w.-]*:)?shape\b[^>]*(?:\/>|>[\s\S]*?<\/\1?shape\s*>)/g;
+// A `nano:meta` element (any namespace prefix; matches the Rust local-name scan).
+const META_RE = /<([\w.-]*:)?meta\b([^>]*?)\/?>/g;
+/** Scan one BPMN document for model-level `nano:meta` key/value entries, in document
+ * order, tagged with the enclosing process. A meta with no `key` attribute is ignored;
+ * a missing `value` folds to the empty string (matches envelope_scan.rs). */
+export function scanModelMeta(xml) {
+    const proc = processId(xml);
+    const withoutShapes = xml.replace(SHAPE_BLOCK_RE, "");
+    const out = [];
+    let m;
+    while ((m = META_RE.exec(withoutShapes)) !== null) {
+        const key = attr(`<x ${m[2]}>`, "key");
+        if (key == null)
+            continue;
+        out.push({ process: proc, key, value: attr(`<x ${m[2]}>`, "value") ?? "" });
+    }
+    return out;
+}
+// --- Faithful port of the console's foldMeta/emitMeta (domain_types.ts) so the emitted
+//     meta.ts is byte-compatible with the IDE's own codegen. ---
+function isIdent(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+/** Fold the scanned model-level metadata into a single key→value record. When two models
+ * declare the same key the last (scan order) wins. Empty keys are ignored. The accumulator
+ * is a **null-prototype** dict so user-authored keys (including `__proto__`) round-trip
+ * deterministically as own data properties. */
+export function foldMeta(metas) {
+    const out = Object.create(null);
+    for (const m of metas) {
+        const key = (m?.key ?? "").trim();
+        if (!key)
+            continue;
+        out[key] = m.value ?? "";
+    }
+    return out;
+}
+/** Emit `meta.ts`: the typed model-metadata accessor (`@nanobpm/meta`, ADR 0040 §5).
+ * `AppMeta` keys the declared metadata as string-literal properties; `appMeta` is the
+ * concrete null-prototype record; the overloaded `meta()` returns the typed value for a
+ * known key and `string | undefined` for a dynamic one. Strip-safe (ADR 0036). */
+export function emitMeta(metas) {
+    const folded = foldMeta(metas);
+    const keys = Object.keys(folded);
+    const propKey = (k) => (isIdent(k) ? k : JSON.stringify(k));
+    const header = "// AUTO-GENERATED by nanobpmn from the process model (ADR 0040 §5): the typed\n" +
+        "// model-metadata accessor. Each `nano:meta` key/value the models declare becomes\n" +
+        "// a checked `AppMeta` property, so `meta(key)` is typed and app-wide queryable\n" +
+        "// without a second store. Do not edit — regenerated from the model.\n" +
+        "// eslint-disable\n\n";
+    const iface = keys.length > 0
+        ? `export interface AppMeta {\n${keys.map((k) => `  ${propKey(k)}: string;`).join("\n")}\n}\n`
+        : `export interface AppMeta {}\n`;
+    const constDecl = keys.length > 0
+        ? `export const appMeta: AppMeta = (() => {\n` +
+            `  const m: Record<string, string> = Object.create(null);\n` +
+            keys.map((k) => `  m[${JSON.stringify(k)}] = ${JSON.stringify(folded[k])};`).join("\n") +
+            `\n  return m as AppMeta;\n})();\n`
+        : `export const appMeta: AppMeta = Object.create(null) as AppMeta;\n`;
+    const accessor = `\n/** Read a model-level metadata value. A declared key is typed; a dynamic key\n` +
+        ` * returns \`string | undefined\`. */\n` +
+        `export function meta<K extends keyof AppMeta>(key: K): AppMeta[K];\n` +
+        `export function meta(key: string): string | undefined;\n` +
+        `export function meta(key: string): string | undefined {\n` +
+        `  return (appMeta as Record<string, string>)[key];\n` +
+        `}\n`;
+    return `${header}/** Every model-level metadata key the App's models declare (ADR 0040 §5). */\n` +
+        iface + "\n" + constDecl + accessor;
+}
+/**
+ * Derive `nano-generated/meta.ts` from BPMN models. Deterministic: models are scanned in
+ * path order, then their `nano:meta` entries folded (last write wins) into the accessor.
+ */
+export function deriveMeta(models) {
+    const metas = [];
+    for (const model of [...models].sort(byModelPath)) {
+        metas.push(...scanModelMeta(model.xml));
+    }
+    return [{ path: `${GENERATED_DIR}/${META_TS}`, content: emitMeta(metas) }];
+}
+export const metaDeriver = {
+    id: "model->meta",
+    describe: "Derive meta.ts (the typed @nanobpm/meta accessor) from BPMN nano:meta entries.",
+    derive: ({ models }) => deriveMeta(models),
+};

package/dist/toolkit/derivers/migrations.d.ts

@@ -2,6 +2,8 @@ import type { DerivedArtifact, Deriver } from "../artifact.ts";
 export interface ToolkitField {
     type?: string;
     optional?: boolean;
+    /** Marks a repeated field: the domain row-type projects it as `T[]` in the `DomainTypes` registry. */
+    list?: boolean;
 }
 export interface ToolkitType {
     table?: string;
@@ -20,7 +22,38 @@ export interface ToolkitManifest {
 /** Map a domain field type to a SQLite column type. Unknown types fall back to TEXT. */
 export declare function sqlType(t: string | undefined): string;
 export declare function assertSqlIdent(kind: string, name: string): string;
-/** Build the CREATE TABLE statement for one type. */
+/** Double-quote an identifier for DDL. `assertSqlIdent` already rejects non-identifier
+ * chars (the injection guard), but quoting is what makes valid-but-reserved words
+ * (`order`, `group`, `select`, …) legal SQL — no reserved-word denylist to maintain.
+ * Embedded double quotes are doubled per the SQL standard (defensive; can't occur here). */
+export declare function quoteSqlIdent(name: string): string;
+/** A column in a manifest type's canonical table schema. `sqlType` is the SQLite
+ * declared type (the affinity source for both the CREATE TABLE and the row types). */
+export interface DerivedColumn {
+    name: string;
+    sqlType: string;
+    notNull: boolean;
+    primaryKey: boolean;
+}
+/** The canonical table schema for one manifest type. */
+export interface DerivedTable {
+    table: string;
+    columns: DerivedColumn[];
+}
+/**
+ * Derive the canonical table schema for one manifest type: an implicit
+ * autoincrement `id` primary key plus one column per declared field. This is the
+ * single source of truth both the SQL migration (`createTableSql`) and the domain
+ * row-types (`domain.ts`) derive from, so the schema can never drift between them.
+ */
+export declare function tableSchemaForType(typeName: string, def: ToolkitType): DerivedTable;
+/** Group manifest types by their datasource, preserving declaration order within each
+ * source. Shared by the migrations and domain derivers so both partition and order
+ * sources identically (a single source of truth for the source spine). */
+export declare function groupTypesBySource(manifest: ToolkitManifest): Map<string, Array<[string, ToolkitType]>>;
+/** Build the CREATE TABLE statement for one type, from its canonical schema. Table and
+ * column identifiers are quoted so valid-but-reserved names (`order`, `group`, …) emit
+ * legal SQL. */
 export declare function createTableSql(typeName: string, def: ToolkitType): string;
 export declare function deriveMigrations(manifest: ToolkitManifest): DerivedArtifact[];
 export declare const migrationsDeriver: Deriver<ToolkitManifest>;

package/dist/toolkit/derivers/migrations.js

@@ -31,25 +31,40 @@ export function assertSqlIdent(kind, name) {
     }
     return name;
 }
-/** Build the CREATE TABLE statement for one type. */
-export function createTableSql(typeName, def) {
+/** Double-quote an identifier for DDL. `assertSqlIdent` already rejects non-identifier
+ * chars (the injection guard), but quoting is what makes valid-but-reserved words
+ * (`order`, `group`, `select`, …) legal SQL — no reserved-word denylist to maintain.
+ * Embedded double quotes are doubled per the SQL standard (defensive; can't occur here). */
+export function quoteSqlIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/**
+ * Derive the canonical table schema for one manifest type: an implicit
+ * autoincrement `id` primary key plus one column per declared field. This is the
+ * single source of truth both the SQL migration (`createTableSql`) and the domain
+ * row-types (`domain.ts`) derive from, so the schema can never drift between them.
+ */
+export function tableSchemaForType(typeName, def) {
     const table = assertSqlIdent("table name", def.table ?? typeName);
-    const cols = ["  id INTEGER PRIMARY KEY AUTOINCREMENT"];
+    const columns = [
+        { name: "id", sqlType: "INTEGER", notNull: false, primaryKey: true },
+    ];
     const fields = def.fields ?? {};
     for (const [name, f] of Object.entries(fields)) {
         assertSqlIdent("field name", name);
         if (name === "id") {
             throw new Error(`type "${typeName}": field "id" is reserved (the table's implicit primary key)`);
         }
-        const notNull = f.optional ? "" : " NOT NULL";
-        cols.push(`  ${name} ${sqlType(f.type)}${notNull}`);
+        columns.push({ name, sqlType: sqlType(f.type), notNull: !f.optional, primaryKey: false });
     }
-    return `CREATE TABLE IF NOT EXISTS ${table} (\n${cols.join(",\n")}\n);`;
+    return { table, columns };
 }
-export function deriveMigrations(manifest) {
+/** Group manifest types by their datasource, preserving declaration order within each
+ * source. Shared by the migrations and domain derivers so both partition and order
+ * sources identically (a single source of truth for the source spine). */
+export function groupTypesBySource(manifest) {
     const types = manifest.types ?? {};
     const defaultSource = manifest.data?.default ?? "app";
-    // Group types by their datasource.
     const bySource = new Map();
     for (const [name, def] of Object.entries(types)) {
         const src = def.source ?? defaultSource;
@@ -57,6 +72,20 @@ export function deriveMigrations(manifest) {
         list.push([name, def]);
         bySource.set(src, list);
     }
+    return bySource;
+}
+/** Build the CREATE TABLE statement for one type, from its canonical schema. Table and
+ * column identifiers are quoted so valid-but-reserved names (`order`, `group`, …) emit
+ * legal SQL. */
+export function createTableSql(typeName, def) {
+    const { table, columns } = tableSchemaForType(typeName, def);
+    const cols = columns.map((c) => c.primaryKey
+        ? `  ${quoteSqlIdent(c.name)} ${c.sqlType} PRIMARY KEY AUTOINCREMENT`
+        : `  ${quoteSqlIdent(c.name)} ${c.sqlType}${c.notNull ? " NOT NULL" : ""}`);
+    return `CREATE TABLE IF NOT EXISTS ${quoteSqlIdent(table)} (\n${cols.join(",\n")}\n);`;
+}
+export function deriveMigrations(manifest) {
+    const bySource = groupTypesBySource(manifest);
     const artifacts = [];
     for (const [src, list] of bySource) {
         const header = `-- Derived from manifest \`types\` by @nanobpm/urban (urban gen). Do not edit.\n` +

package/dist/toolkit/derivers/worker-io.d.ts

@@ -4,6 +4,16 @@ export interface ModelSource {
     path: string;
     xml: string;
 }
+/** Deterministic comparator for ordering `ModelSource` lists by path. Returns 0 on equal
+ * paths so it satisfies the JS sort contract (a comparator that reports both `a>b` and
+ * `b>a` can reorder equal elements unpredictably) — keeping the derivers' cross-model
+ * fold order stable even if a manifest pattern yields duplicate paths. Shared by every
+ * model-scanning deriver so there is one canonical ordering. */
+export declare function byModelPath(a: {
+    path: string;
+}, b: {
+    path: string;
+}): number;
 export interface WorkerIo {
     taskType: string;
     elementId?: string;
@@ -19,6 +29,10 @@ export declare const WORKER_BINDINGS_DTS = "worker-io.d.ts";
 export declare const DOMAIN_DTS = "domain-rows.d.ts";
 /** Scan one BPMN document for service-task worker I/O. */
 export declare function scanModelWorkers(xml: string): WorkerIo[];
+/** A `DomainTypes[...]` ref for a declared type id (else undefined). The one canonical
+ * ref helper shared by the worker- and message-IO emitters (matches the console's single
+ * `typeRefFor` in domain_types.ts), so both stay identical to the host codegen. */
+export declare function typeRefFor(id: string | undefined, declared: Set<string>): string | undefined;
 export interface WorkerBindingDecl {
     taskType?: string;
     inputType?: string;

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

@@ -4,6 +4,14 @@
 // `worker-io.d.ts` the console generates (a faithful port of `emitWorkerBindings` in the
 // server's domain_types.ts), so the toolkit is a drop-in for the IDE's codegen (ADR 0053).
 import { GENERATED_DIR } from "../artifact.js";
+/** Deterministic comparator for ordering `ModelSource` lists by path. Returns 0 on equal
+ * paths so it satisfies the JS sort contract (a comparator that reports both `a>b` and
+ * `b>a` can reorder equal elements unpredictably) — keeping the derivers' cross-model
+ * fold order stable even if a manifest pattern yields duplicate paths. Shared by every
+ * model-scanning deriver so there is one canonical ordering. */
+export function byModelPath(a, b) {
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+}
 /** Filename the console uses; kept identical so the artifact is a drop-in. */
 export const WORKER_BINDINGS_DTS = "worker-io.d.ts";
 /** The domain type declarations `worker-io.d.ts` imports from (console: domain-rows.d.ts). */
@@ -51,7 +59,10 @@ export function scanModelWorkers(xml) {
 }
 // --- Faithful port of the console's emitWorkerBindings (domain_types.ts) so the emitted
 //     worker-io.d.ts is byte-compatible with the IDE's own codegen. ---
-function typeRefFor(id, declared) {
+/** A `DomainTypes[...]` ref for a declared type id (else undefined). The one canonical
+ * ref helper shared by the worker- and message-IO emitters (matches the console's single
+ * `typeRefFor` in domain_types.ts), so both stay identical to the host codegen. */
+export function typeRefFor(id, declared) {
     return id != null && declared.has(id) ? `DomainTypes[${JSON.stringify(id)}]` : undefined;
 }
 /** Emit `worker-io.d.ts` from worker bindings + the set of declared domain type ids. */
@@ -120,7 +131,7 @@ export function emitWorkerBindings(workers, declaredTypeIds) {
  */
 export function deriveWorkerBindings(models, declaredTypeIds = []) {
     const workers = [];
-    for (const model of [...models].sort((a, b) => (a.path < b.path ? -1 : 1))) {
+    for (const model of [...models].sort(byModelPath)) {
         for (const w of scanModelWorkers(model.xml)) {
             workers.push({ taskType: w.taskType, inputType: w.in, outputType: w.out });
         }

package/dist/toolkit/gen.js

@@ -4,7 +4,10 @@
 // pure; all IO is confined here behind a tiny FS port so the same code runs on Node and Deno.
 import { sortArtifacts } from "./artifact.js";
 import { deriveMigrations } from "./derivers/migrations.js";
+import { deriveDomain } from "./derivers/domain.js";
 import { deriveWorkerBindings } from "./derivers/worker-io.js";
+import { deriveMeta } from "./derivers/meta.js";
+import { deriveMessageBindings } from "./derivers/messages.js";
 function join(root, rel) {
     // Trim either separator so callers may pass Windows-style paths; GenIO
     // implementations accept forward slashes on all platforms.
@@ -47,15 +50,18 @@ export async function collectArtifacts(opts) {
     const manifestPath = join(root, opts.manifestFile ?? "nano.app.json");
     const manifest = JSON.parse(await io.readText(manifestPath));
     const artifacts = [];
-    // 1. types → migrations
+    // 1. types → migrations + domain row types (DomainTables spine + DomainTypes registry)
     if (manifest.types && Object.keys(manifest.types).length > 0) {
         artifacts.push(...deriveMigrations(manifest));
+        artifacts.push(...deriveDomain(manifest));
     }
-    // 2. models → worker I/O index
+    // 2. models → worker I/O index + model-metadata accessor + message payload map
     const models = await readModels(root, io, manifest);
     if (models.length > 0) {
         const declaredTypeIds = Object.keys(manifest.types ?? {});
         artifacts.push(...deriveWorkerBindings(models, declaredTypeIds));
+        artifacts.push(...deriveMeta(models));
+        artifacts.push(...deriveMessageBindings(models, declaredTypeIds));
     }
     return sortArtifacts(artifacts);
 }

package/dist/toolkit/index.d.ts

@@ -1,10 +1,22 @@
 export type { DerivedArtifact, Deriver } from "./artifact.ts";
 export { GENERATED_DIR, sortArtifacts } from "./artifact.ts";
-export { deriveMigrations, migrationsDeriver, sqlType, createTableSql, } from "./derivers/migrations.ts";
-export type { ToolkitManifest, ToolkitType, ToolkitField } from "./derivers/migrations.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 type { ModelSource, WorkerIo, WorkerBindingDecl } from "./derivers/worker-io.ts";
-export declare const DERIVERS: readonly [import("./artifact.ts").Deriver<import("./derivers/migrations.ts").ToolkitManifest>, import("./artifact.ts").Deriver<{
+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 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[];
+    declaredTypeIds: Iterable<string>;
+}>, import("./artifact.ts").Deriver<{
+    models: import("./derivers/worker-io.ts").ModelSource[];
+}>, import("./artifact.ts").Deriver<{
     models: import("./derivers/worker-io.ts").ModelSource[];
     declaredTypeIds: Iterable<string>;
 }>];

package/dist/toolkit/index.js

@@ -4,12 +4,19 @@
 // (ADR 0054) — the toolkit derives migrations and worker I/O from the model.
 export { GENERATED_DIR, sortArtifacts } from "./artifact.js";
 // Derivers
-export { deriveMigrations, migrationsDeriver, sqlType, createTableSql, } from "./derivers/migrations.js";
+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 { 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";
 // The registry of all derivers (for discovery / IDE migration).
 import { migrationsDeriver } from "./derivers/migrations.js";
+import { domainDeriver } from "./derivers/domain.js";
 import { workerIoDeriver } from "./derivers/worker-io.js";
-export const DERIVERS = [migrationsDeriver, workerIoDeriver];
+import { metaDeriver } from "./derivers/meta.js";
+import { messagesDeriver } from "./derivers/messages.js";
+export const DERIVERS = [migrationsDeriver, domainDeriver, workerIoDeriver, metaDeriver, messagesDeriver];
 // Gen orchestrator + IO
 export { collectArtifacts, runGen, joinPath, readModels } from "./gen.js";
 export { createNodeGenIO } from "./fsio.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/urban",
-  "version": "0.16.1",
+  "version": "0.17.1",
   "description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
   "license": "Apache-2.0",
   "type": "module",
@@ -55,13 +55,14 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node -e \"const fs=require('fs');fs.mkdirSync('dist/runtime/schema',{recursive:true});fs.copyFileSync('src/runtime/schema/nano-app.schema.json','dist/runtime/schema/nano-app.schema.json')\"",
+    "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.1.0",
     "@nanobpm/nano-sdk": "^1.2.3",
     "@nanobpm/workflow": "^0.7.0",
     "bpmn-auto-layout": "^2.0.0-alpha.2",

package/src/runtime/core/manifest.test.ts

@@ -24,8 +24,7 @@ test("parseManifest expands env in place", () => {
   assert.equal(m.name, "App");
 });
 
-test("workerJobType prefers taskType then type", () => {
+test("workerJobType returns the taskType", () => {
   assert.equal(workerJobType({ taskType: "a", handler: "h" }), "a");
-  assert.equal(workerJobType({ type: "b", handler: "h" }), "b");
-  assert.equal(workerJobType({ handler: "h" }), undefined);
+  assert.equal(workerJobType({ taskType: "llm-job", llm: "gpt" }), "llm-job");
 });