@nanobpm/urban 0.16.1 → 0.17.1

package/dist/runtime/core/manifest.d.ts

@@ -1,138 +1,8 @@
 import type { HostContext } from "./host.ts";
-export interface DataSource {
-    driver: string;
-    url: string;
-    migrations?: string;
-}
-export interface TypeField {
-    type: string;
-    optional?: boolean;
-}
-export interface DomainType {
-    name?: string;
-    table?: string;
-    fields?: Record<string, TypeField>;
-}
-export interface WorkerDecl {
-    /** Job/task type the worker subscribes to. Schema allows `taskType` or `type`. */
-    taskType?: string;
-    type?: string;
-    /** Path to the handler module, relative to the app root. Mutually exclusive with `llm`. */
-    handler?: string;
-    /** Name of an `llm[]` binding used as the worker (LLM-as-worker). Mutually exclusive with `handler`. */
-    llm?: string;
-}
-/**
- * One named LLM binding (`llm.<id>` in the manifest). A binding is usable as a worker
- * (LLM-as-worker, ADR 0022 §E role 1) or as a chat surface agent. `provider` selects how
- * the endpoint is resolved (`"env"` reads it from the environment); `model` is typically
- * an env template. When `output.decision` is set, the model's JSON reply is fed through
- * that DMN decision (the "rails") and the decision's output is returned instead.
- */
-export interface LlmBinding {
-    /** Provider selector. `"env"` resolves an OpenAI-compatible endpoint from the environment. */
-    provider: string;
-    /** Model id, typically an env template (e.g. `${NANO_APP_LLM_MODEL}`). */
-    model: string;
-    /** Constrains the model's structured output — currently a DMN decision id (the rails). */
-    output?: {
-        decision?: string;
-    };
-    /** Action-API tools the agent may call (chat-agent role; unused by the worker role). */
-    tools?: string[];
-}
-export interface TriggerDecl {
-    id: string;
-    type: string;
-    path?: string;
-    auth?: string;
-    /** cron: the 5-field crontab spec (UTC), e.g. "0 6 * * *". */
-    spec?: string;
-    /** cron catch-up policy for fires missed while the app was down. Default "skip". */
-    onMissed?: "skip" | "once" | "all";
-    /** Source-kind-specific settings (e.g. file `{ pollMs }`). */
-    config?: Record<string, unknown>;
-    /** Name of a connections[] entry supplying this source's credentials. */
-    connection?: string;
-    /** Maps the event to one engine call: start a process OR publish a message (ADR 0025 §1). */
-    action?: {
-        /** Process id/name to start. */
-        start?: string;
-        /** messageName to publish as a CorrelateMessage. */
-        message?: string;
-        /** correlationKey (literal, or `= body.path`) for a message action. */
-        correlationKey?: string;
-        /**
-         * Variables for the started instance / published message. Per the manifest schema
-         * (`#/$defs/triggerAction.variables`) this is a FEEL string over the event body
-         * (e.g. `= body.payload`); an inline object literal is also accepted for convenience.
-         */
-        variables?: string | Record<string, unknown>;
-    };
-}
-export interface SurfaceDecl {
-    enabled?: boolean;
-    path?: string;
-    agent?: string;
-    /** pages surface: directory of `*.page.json` (relative to app root). Default `pages`. */
-    pagesDir?: string;
-    /** pages surface: the page served at `/`. Default `home`. */
-    homePage?: string;
-    /** pages surface: max rows a `dataGrid` fetch returns. Default 200. */
-    rowLimit?: number;
-    /** pages surface: the injected default datasource name. Default `app`. */
-    sourceName?: string;
-}
-/**
- * An app-authored action handler override (ADR 0055 phase 3). Each declaration binds a
- * route to a handler module (default-exports an `ActionHandler`), letting an app wrap the
- * generic pages start/cancel/message actions with business logic. Mounted before the
- * generic pages action routes, so an exact override shadows the generic one.
- */
-export interface ActionDecl {
-    /** Route path to serve, e.g. "/app/actions/cancel" or "/app/actions/start/convergence-loop". */
-    path: string;
-    /** Handler module path relative to the app root; default-exports an `ActionHandler`. */
-    module: string;
-    /** HTTP method to match. Default "POST". */
-    method?: string;
-    /** Match `path` as a prefix rather than exactly. Default false. */
-    prefix?: boolean;
-}
-export interface AppManifest {
-    $schema?: string;
-    schemaVersion: 1;
-    id: string;
-    name: string;
-    codename?: string;
-    runtime?: {
-        engine?: string;
-        node?: string;
-    };
-    models?: {
-        processes?: string[];
-        decisions?: string[];
-        forms?: string[];
-    };
-    data?: {
-        default?: string;
-        sources?: Record<string, DataSource>;
-    };
-    types?: Record<string, DomainType>;
-    triggers?: TriggerDecl[];
-    connections?: Record<string, {
-        type: string;
-        [k: string]: unknown;
-    }>;
-    surfaces?: Record<string, SurfaceDecl>;
-    actions?: ActionDecl[];
-    workers?: WorkerDecl[];
-    llm?: Record<string, LlmBinding>;
-    security?: Record<string, unknown>;
-    [k: string]: unknown;
-}
-/** The normalised job type for a worker declaration (`taskType` preferred, `type` fallback). */
-export declare function workerJobType(w: WorkerDecl): string | undefined;
+import type { AppManifest, Worker } from "@nanobpm/nano-app-schema";
+export type { ActionDecl, AppManifest, ChatSurface, Connection, Data, DataSource, DomainField, DomainType, LlmBinding, Models, PagesSurface, Runtime, Security, Surfaces, TaskInboxSurface, Trigger, TriggerAction, Worker, } from "@nanobpm/nano-app-schema";
+/** The job type a worker subscribes to (schema key: `taskType`). */
+export declare function workerJobType(w: Worker): string | undefined;
 /**
  * Expand `${VAR}` and `${VAR:-default}` placeholders in a string using `lookup`.
  * Unset vars with no default expand to "" (matching common shell semantics).

package/dist/runtime/core/manifest.js

@@ -1,10 +1,15 @@
-// Manifest types (a hand-mirrored subset of nano-app.schema.json — the block shapes the
-// runtime actually consumes) plus env-placeholder expansion and a host-driven loader.
-// The schema itself (src/schema/nano-app.schema.json) remains the source of truth for
-// validation; see validate.ts.
-/** The normalised job type for a worker declaration (`taskType` preferred, `type` fallback). */
+// Manifest types + env-placeholder expansion + a host-driven loader.
+//
+// The App manifest contract (nano.app.json) is owned by the canonical
+// @nanobpm/nano-app-schema package (ADR 0027): the JSON Schema and its generated
+// TypeScript types are the single source of truth. This module re-exports those
+// types (type-only, so nothing from the package is pulled into the runtime
+// bundle) and adds the runtime-side helpers the App loader needs. No shape is
+// hand-mirrored here — that eliminated the schema/type drift the vendored copies
+// used to cause.
+/** The job type a worker subscribes to (schema key: `taskType`). */
 export function workerJobType(w) {
-    return w.taskType ?? w.type;
+    return w.taskType;
 }
 const ENV_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
 /**

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

@@ -1,6 +1,5 @@
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import { type Route } from "../router.ts";
-import type { TriggerDecl } from "../manifest.ts";
 export interface TriggersHandle extends Mounted {
     routes: Route[];
 }
@@ -38,7 +37,20 @@ export declare function resolveActionVariables(expr: unknown, scope: Scope): Rec
  * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
  * was done.
  */
-export declare function runTriggerAction(app: AppApi, action: TriggerDecl["action"], scope: Scope): Promise<{
+/**
+ * The trigger action as the *runtime* helper reads it: the fields `runTriggerAction`
+ * consumes, with `variables` permitting an inline object literal as well as a FEEL string.
+ * The manifest surface keeps `variables` string-only (a FEEL expression);
+ * `resolveActionVariables` tolerates both, so this shape matches runtime behaviour without
+ * loosening the schema. A locked `Trigger["action"]` is assignable to it.
+ */
+export interface RuntimeTriggerAction {
+    start?: string;
+    message?: string;
+    correlationKey?: string;
+    variables?: string | Record<string, unknown>;
+}
+export declare function runTriggerAction(app: AppApi, action: RuntimeTriggerAction | undefined, scope: Scope): Promise<{
     kind: "start" | "message" | "none";
     target?: string;
     correlationKey?: string;

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

@@ -75,12 +75,6 @@ function headerRecord(req) {
     req.headers.forEach((v, k) => (out[k.toLowerCase()] = v));
     return out;
 }
-/**
- * Fire a trigger's action against the engine: start a process or publish a message
- * (ADR 0025 §1). `scope` supplies the event body/headers/query for FEEL-ish resolution
- * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
- * was done.
- */
 export async function runTriggerAction(app, action, scope) {
     if (!action)
         return { kind: "none" };

package/dist/runtime/core/validate.js

@@ -1,12 +1,13 @@
-// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to
-// keep core dependency-free and runtime-agnostic. Instead we drive validation *from* the
-// vendored nano-app.schema.json (the ADR 0027 source of truth) for the top-level envelope
-// — required keys, allowed keys (additionalProperties:false), the schemaVersion const, and
-// the id slug pattern — and then layer the runtime's binding rules (a worker needs a
-// handler, a data source needs driver+url, a typed table needs fields, a trigger needs
-// id+type). Reading the schema means the envelope check tracks the schema and can't drift
-// from it silently.
-import schema from "../schema/nano-app.schema.json" with { type: "json" };
+// Manifest validation. We deliberately avoid a heavyweight JSON-Schema engine here to keep
+// core lean and runtime-agnostic. Instead we drive validation *from* the canonical
+// nano-app.schema.json (the ADR 0027 source of truth, imported from the
+// @nanobpm/nano-app-schema package) for the top-level envelope — required keys, allowed keys
+// (additionalProperties:false), the schemaVersion const, and the id slug pattern — and then
+// layer the runtime's binding rules (a worker needs a handler, a data source needs
+// driver+url, a typed table needs fields, a trigger needs id+type). Importing the shared
+// schema JSON means the envelope check tracks the published schema and can't drift from it
+// silently — the whole point of consuming the package rather than vendoring a copy.
+import schema from "@nanobpm/nano-app-schema/schema" with { type: "json" };
 import { workerJobType } from "./manifest.js";
 export class ManifestValidationError extends Error {
     issues;
@@ -53,7 +54,7 @@ export function collectManifestIssues(m) {
     if (Array.isArray(man.workers)) {
         man.workers.forEach((w, i) => {
             if (!workerJobType(w)) {
-                issues.push({ path: `workers[${i}]`, message: "missing taskType/type" });
+                issues.push({ path: `workers[${i}]`, message: "missing taskType" });
             }
             // The schema allows a worker backed by either a `handler` file or an `llm`
             // binding (oneOf). Require exactly one — don't force `handler`.

package/dist/runtime/index.d.ts

@@ -1,7 +1,7 @@
 export { createUrbanApp } from "./core/runtime.ts";
 export type { CreateUrbanAppOptions, MountFlags, UrbanApp, } from "./core/runtime.ts";
 export { expandEnv, expandEnvString, loadManifest, parseManifest, workerJobType, } from "./core/manifest.ts";
-export type { ActionDecl, AppManifest, DataSource, DomainType, LlmBinding, SurfaceDecl, TriggerDecl, TypeField, WorkerDecl, } from "./core/manifest.ts";
+export type { ActionDecl, AppManifest, ChatSurface, DataSource, DomainField, DomainType, LlmBinding, PagesSurface, Surfaces, TaskInboxSurface, Trigger, Worker, } from "./core/manifest.ts";
 export { collectManifestIssues, ManifestValidationError, validateManifest, } from "./core/validate.ts";
 export type { ValidationIssue } from "./core/validate.ts";
 export type { EngineClient, EngineJob, HostContext, HttpHandler, HttpRequest, HttpResponse, HttpServer, JobHandler, SqliteDb, WatchHandle, WorkerSubscription, } from "./core/host.ts";

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

@@ -0,0 +1,69 @@
+import type { DerivedArtifact, Deriver } from "../artifact.ts";
+import type { ColumnMeta, TableMeta } from "../../runtime/core/modules/gateway.ts";
+import { type ToolkitManifest } from "./migrations.ts";
+export type { ColumnMeta, TableMeta };
+/** One datasource's tables, paired with its manifest alias. */
+export interface SourceSchema {
+    source: string;
+    tables: TableMeta[];
+}
+/**
+ * Map a SQLite declared column type to a TypeScript field type. SQLite is dynamically typed but
+ * assigns each column a *type affinity* from its declared name, so we apply the affinity rules
+ * (https://sqlite.org/datatype3.html §3.1) with two maker-friendly overrides: `BOOLEAN` →
+ * `boolean` and date/time types → `string` (ISO text), matching how Urban surfaces them.
+ */
+export declare function sqliteAffinityToTs(declaredType: string): string;
+/** PascalCase a table name into an interface name, sanitised to an identifier. */
+export declare function interfaceName(table: string): string;
+/**
+ * Emit the full `domain-rows.d.ts` from a datasource's tables: one `interface` per table plus a
+ * `DomainTables` lookup keyed by the *raw* table name, so callers write `DomainTables["customers"]`.
+ */
+export declare function emitDomainDts(tables: TableMeta[]): string;
+/**
+ * Emit `domain-rows.d.ts` for an App that declares *multiple* datasources: one `interface` per
+ * (source, table), a `DomainSources` map keyed by alias then wire table name, and a `DomainTables`
+ * alias to the default source. When there is one source (or none) this is byte-identical to
+ * `emitDomainDts` so the common case stays stable.
+ */
+export declare function emitDomainDtsForSources(sources: SourceSchema[], defaultSource?: string): string;
+/** One field of a declared domain type in the manifest `types` registry. */
+export interface DomainFieldDef {
+    /** A primitive keyword or the id of another registry type (nominal ref). */
+    type: string;
+    optional?: boolean;
+    list?: boolean;
+}
+/** A declared (transient) domain record type from the manifest `types` block. */
+export interface DomainTypeDef {
+    name?: string;
+    match?: string;
+    table?: string;
+    fields: Record<string, DomainFieldDef>;
+}
+/** The manifest `types` registry: type id → declared record type. */
+export type DomainTypeRegistry = Record<string, DomainTypeDef>;
+/**
+ * Emit the `DomainTypes` block for the manifest `types` registry: an inline map keyed by type id.
+ * Returns `""` when the registry is empty, so the table spine stays byte-identical when no types
+ * are declared. `optional` widens the key with `?`.
+ */
+export declare function emitDomainTypeRegistry(types: DomainTypeRegistry): string;
+/**
+ * Compose the full `domain-rows.d.ts`: the datasource table spine (every source, ADR 0029 §6)
+ * followed by the manifest `types` registry (§4.2).
+ */
+export declare function emitDomainModel(sources: SourceSchema[], defaultSource: string | undefined, types: DomainTypeRegistry): string;
+/** The datasource table spine derived from the manifest types, grouped by source (same grouping
+ * and order as the SQL migration). */
+export declare function sourcesFromManifest(manifest: ToolkitManifest): SourceSchema[];
+/** The `DomainTypes` registry derived from the manifest types (declared fields only — the
+ * persisted `id` belongs to the table row, not the logical type). */
+export declare function registryFromManifest(manifest: ToolkitManifest): DomainTypeRegistry;
+/** Emit the `domain-rows.d.ts` content for an app manifest. */
+export declare function emitDomain(manifest: ToolkitManifest): string;
+/** Derive `nano-generated/domain-rows.d.ts` from the manifest types. Empty when the app declares
+ * no types (no tables, no registry, and nothing references `DomainTypes`). */
+export declare function deriveDomain(manifest: ToolkitManifest): DerivedArtifact[];
+export declare const domainDeriver: Deriver<ToolkitManifest>;

package/dist/toolkit/derivers/domain.js

@@ -0,0 +1,243 @@
+// Deriver: manifest `types` → `domain-rows.d.ts`, the domain row-type contract (ADR 0029 §4.1/§6,
+// ADR 0053). Two blocks compose into one generated `.d.ts`:
+//   • the **table spine** — one `interface` per persisted table plus a `DomainTables` lookup
+//     keyed by wire name, so a worker types `DomainTables["greetings"]`; and
+//   • the **`DomainTypes` registry** — the declared (transient) manifest types keyed by id, so
+//     envelope/worker/message refs resolve to `DomainTypes["<id>"]` (see `typeRefFor`).
+//
+// Byte-faithful port of the console's `emitDomainModel`/`emitDomainDts…`/`emitDomainTypeRegistry`
+// (server `domain_types.ts`), so the toolkit is a drop-in for the IDE's codegen. The emitters are
+// pure; the table spine is derived from the manifest (code-first, ADR 0054) via the *same*
+// canonical `tableSchemaForType` the SQL migration uses — one schema truth, no drift surface.
+import { GENERATED_DIR } from "../artifact.js";
+import { DOMAIN_DTS } from "./worker-io.js";
+import { groupTypesBySource, tableSchemaForType, } from "./migrations.js";
+// --- table spine emitters (port of domain_types.ts) ------------------------------------------
+/**
+ * Map a SQLite declared column type to a TypeScript field type. SQLite is dynamically typed but
+ * assigns each column a *type affinity* from its declared name, so we apply the affinity rules
+ * (https://sqlite.org/datatype3.html §3.1) with two maker-friendly overrides: `BOOLEAN` →
+ * `boolean` and date/time types → `string` (ISO text), matching how Urban surfaces them.
+ */
+export function sqliteAffinityToTs(declaredType) {
+    const t = declaredType.toUpperCase();
+    if (t.length === 0)
+        return "unknown"; // NONE affinity — opaque
+    if (t.includes("BOOL"))
+        return "boolean";
+    if (t.includes("DATE") || t.includes("TIME"))
+        return "string";
+    if (t.includes("INT"))
+        return "number";
+    if (t.includes("CHAR") || t.includes("CLOB") || t.includes("TEXT"))
+        return "string";
+    if (t.includes("BLOB"))
+        return "Uint8Array";
+    if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB"))
+        return "number";
+    return "number"; // NUMERIC affinity
+}
+/** A TS identifier is safe to use bare as a property name / type name. */
+function isIdent(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+/** PascalCase a table name into an interface name, sanitised to an identifier. */
+export function interfaceName(table) {
+    const pascal = table
+        .replace(/[^A-Za-z0-9]+/g, " ")
+        .trim()
+        .split(/\s+/)
+        .map((w) => (w ? w[0].toUpperCase() + w.slice(1) : ""))
+        .join("");
+    const safe = pascal.replace(/[^A-Za-z0-9_$]/g, "");
+    return /^[A-Za-z_$]/.test(safe) ? safe : `T_${safe}`;
+}
+/** The TS field type for a column: nullable columns widen with `| null`. */
+function fieldType(col) {
+    const base = sqliteAffinityToTs(col.type);
+    // A NOT NULL column (or the INTEGER PRIMARY KEY rowid alias) is never null.
+    return col.notNull || col.primaryKey ? base : `${base} | null`;
+}
+/** One `export interface` block for a table under an explicit interface name. */
+function tableInterfaceNamed(name, t) {
+    const fields = t.columns
+        .map((c) => {
+        const key = isIdent(c.name) ? c.name : JSON.stringify(c.name);
+        const pk = c.primaryKey ? " (primary key)" : "";
+        return `  /** ${c.type || "?"}${pk} */\n  ${key}: ${fieldType(c)};`;
+    })
+        .join("\n");
+    return `export interface ${name} {\n${fields}\n}`;
+}
+/** One `export interface` block for a table (name derived from the table). */
+function tableInterface(t) {
+    return tableInterfaceNamed(interfaceName(t.name), t);
+}
+/**
+ * Emit the full `domain-rows.d.ts` from a datasource's tables: one `interface` per table plus a
+ * `DomainTables` lookup keyed by the *raw* table name, so callers write `DomainTables["customers"]`.
+ */
+export function emitDomainDts(tables) {
+    const header = "// AUTO-GENERATED by nanobpmn from the datasource schema (ADR 0029 §4.1).\n" +
+        "// Do not edit — regenerated from the live tables. Erased at `deno compile`.\n" +
+        "// eslint-disable\n";
+    if (tables.length === 0) {
+        return `${header}\nexport interface DomainTables {}\n`;
+    }
+    const interfaces = tables.map(tableInterface).join("\n\n");
+    const map = tables
+        .map((t) => `  ${JSON.stringify(t.name)}: ${interfaceName(t.name)};`)
+        .join("\n");
+    return `${header}\n${interfaces}\n\n/** Every table keyed by its wire name — index it for a row type. */\nexport interface DomainTables {\n${map}\n}\n`;
+}
+/**
+ * The interface name for a table in a multi-source union: the source alias is PascalCased and
+ * prefixed to the table's interface name so tables that share a name across datasources get
+ * distinct, collision-free interfaces (`AppCustomers`, `AnalyticsCustomers`).
+ */
+function prefixedInterfaceName(source, table) {
+    return `${interfaceName(source)}${interfaceName(table)}`;
+}
+/**
+ * Emit `domain-rows.d.ts` for an App that declares *multiple* datasources: one `interface` per
+ * (source, table), a `DomainSources` map keyed by alias then wire table name, and a `DomainTables`
+ * alias to the default source. When there is one source (or none) this is byte-identical to
+ * `emitDomainDts` so the common case stays stable.
+ */
+export function emitDomainDtsForSources(sources, defaultSource) {
+    if (sources.length <= 1) {
+        return emitDomainDts(sources[0]?.tables ?? []);
+    }
+    const header = "// AUTO-GENERATED by nanobpmn from the datasource schemas (ADR 0029 §4.1/§6).\n" +
+        "// Do not edit — regenerated from the live tables. Erased at `deno compile`.\n" +
+        "// eslint-disable\n";
+    const interfaces = sources
+        .flatMap((s) => s.tables.map((t) => tableInterfaceNamed(prefixedInterfaceName(s.source, t.name), t)))
+        .join("\n\n");
+    const sourceMap = sources
+        .map((s) => {
+        if (s.tables.length === 0)
+            return `  ${JSON.stringify(s.source)}: {};`;
+        const tableMap = s.tables
+            .map((t) => `    ${JSON.stringify(t.name)}: ${prefixedInterfaceName(s.source, t.name)};`)
+            .join("\n");
+        return `  ${JSON.stringify(s.source)}: {\n${tableMap}\n  };`;
+    })
+        .join("\n");
+    const def = defaultSource && sources.some((s) => s.source === defaultSource)
+        ? defaultSource
+        : sources[0].source;
+    return `${header}\n${interfaces}\n\n` +
+        `/** Every datasource keyed by alias, then table by wire name. */\n` +
+        `export interface DomainSources {\n${sourceMap}\n}\n\n` +
+        `/** The default datasource's tables — index by wire name. */\n` +
+        `export type DomainTables = DomainSources[${JSON.stringify(def)}];\n`;
+}
+/** Manifest primitive field keywords → TS types (ADR 0029 §4.2 / schema). */
+const PRIMITIVE_TS = {
+    string: "string",
+    number: "number",
+    integer: "number",
+    boolean: "boolean",
+    date: "string",
+    datetime: "string",
+    json: "unknown",
+};
+/**
+ * The TS type for a registry field. A primitive keyword maps directly (and takes precedence over
+ * an identically named type, per the schema); anything else is a nominal reference to another
+ * registry type, emitted as an indexed access into `DomainTypes`. An unresolved reference degrades
+ * to `unknown`. `list` wraps the base type in `[]`.
+ */
+function fieldTsType(field, ids) {
+    const base = PRIMITIVE_TS[field.type] ??
+        (ids.has(field.type) ? `DomainTypes[${JSON.stringify(field.type)}]` : "unknown");
+    return field.list ? `${base}[]` : base;
+}
+/**
+ * Emit the `DomainTypes` block for the manifest `types` registry: an inline map keyed by type id.
+ * Returns `""` when the registry is empty, so the table spine stays byte-identical when no types
+ * are declared. `optional` widens the key with `?`.
+ */
+export function emitDomainTypeRegistry(types) {
+    const ids = new Set(Object.keys(types));
+    if (ids.size === 0)
+        return "";
+    const entries = Object.entries(types)
+        .map(([id, def]) => {
+        const fields = Object.entries(def.fields ?? {})
+            .map(([fname, field]) => {
+            const key = isIdent(fname) ? fname : JSON.stringify(fname);
+            const opt = field.optional ? "?" : "";
+            return `    ${key}${opt}: ${fieldTsType(field, ids)};`;
+        })
+            .join("\n");
+        const body = fields.length > 0 ? `{\n${fields}\n  }` : "{}";
+        return `  ${JSON.stringify(id)}: ${body};`;
+    })
+        .join("\n");
+    return `/** Declared (transient) domain types from the manifest \`types\` registry (ADR 0029 §4.2), keyed by id. */\nexport interface DomainTypes {\n${entries}\n}\n`;
+}
+/**
+ * Compose the full `domain-rows.d.ts`: the datasource table spine (every source, ADR 0029 §6)
+ * followed by the manifest `types` registry (§4.2).
+ */
+export function emitDomainModel(sources, defaultSource, types) {
+    const spine = emitDomainDtsForSources(sources, defaultSource);
+    const registry = emitDomainTypeRegistry(types);
+    return registry ? `${spine}\n${registry}` : spine;
+}
+// --- manifest bridge (code-first, ADR 0054) --------------------------------------------------
+/** Project one manifest type's canonical schema into a `TableMeta` for the row-type spine. Reuses
+ * the *same* `tableSchemaForType` the SQL migration uses, so the row types can't drift from the DB. */
+function tableMetaFromType(typeName, def) {
+    const { table, columns } = tableSchemaForType(typeName, def);
+    return {
+        name: table,
+        columns: columns.map((c) => ({
+            name: c.name,
+            type: c.sqlType,
+            notNull: c.notNull,
+            primaryKey: c.primaryKey,
+        })),
+        indexes: [],
+        foreignKeys: [],
+    };
+}
+/** The datasource table spine derived from the manifest types, grouped by source (same grouping
+ * and order as the SQL migration). */
+export function sourcesFromManifest(manifest) {
+    return [...groupTypesBySource(manifest)].map(([source, list]) => ({
+        source,
+        tables: list.map(([name, def]) => tableMetaFromType(name, def)),
+    }));
+}
+/** The `DomainTypes` registry derived from the manifest types (declared fields only — the
+ * persisted `id` belongs to the table row, not the logical type). */
+export function registryFromManifest(manifest) {
+    const out = {};
+    for (const [id, def] of Object.entries(manifest.types ?? {})) {
+        const fields = {};
+        for (const [fname, f] of Object.entries(def.fields ?? {})) {
+            fields[fname] = { type: f.type ?? "string", optional: f.optional, list: f.list };
+        }
+        out[id] = { table: def.table, fields };
+    }
+    return out;
+}
+/** Emit the `domain-rows.d.ts` content for an app manifest. */
+export function emitDomain(manifest) {
+    return emitDomainModel(sourcesFromManifest(manifest), manifest.data?.default ?? "app", registryFromManifest(manifest));
+}
+/** Derive `nano-generated/domain-rows.d.ts` from the manifest types. Empty when the app declares
+ * no types (no tables, no registry, and nothing references `DomainTypes`). */
+export function deriveDomain(manifest) {
+    if (!manifest.types || Object.keys(manifest.types).length === 0)
+        return [];
+    return [{ path: `${GENERATED_DIR}/${DOMAIN_DTS}`, content: emitDomain(manifest) }];
+}
+export const domainDeriver = {
+    id: "types->domain",
+    describe: "Derive domain row types (DomainTables spine + DomainTypes registry) from manifest types.",
+    derive: deriveDomain,
+};

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

@@ -0,0 +1,36 @@
+import type { DerivedArtifact, Deriver } from "../artifact.ts";
+import { type ModelSource } from "./worker-io.ts";
+/** Filename the console uses for the derived message-payload map; kept identical (drop-in). */
+export declare const MESSAGE_BINDINGS_DTS = "message-io.d.ts";
+/** One message-IO entry scanned from a model: a `bpmn:message` name plus the envelope
+ * type refs it carries. `inputType` is the received payload (what a `publishMessage`
+ * caller sends); `outputType` is reserved. Mirrors the Rust `MessageIo`. */
+export interface MessageIo {
+    messageName: string;
+    inputType?: string;
+    outputType?: string;
+}
+/** The binding shape the emitter reads. Identical to a scanned `MessageIo`, so it is an
+ * alias — one canonical shape, no second declaration to drift (the console keeps the two
+ * apart only because its scan output is Rust and its emitter input is TS). */
+export type MessageBindingDecl = MessageIo;
+/** 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 declare function scanModelMessages(xml: string): MessageIo[];
+/** 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 declare function emitMessageBindings(messages: MessageBindingDecl[], declaredTypeIds: Iterable<string>): string;
+/**
+ * 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 declare function deriveMessageBindings(models: ModelSource[], declaredTypeIds?: Iterable<string>): DerivedArtifact[];
+export declare const messagesDeriver: Deriver<{
+    models: ModelSource[];
+    declaredTypeIds: Iterable<string>;
+}>;