@nanobpm/urban 0.17.0 → 0.17.1

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.17.0",
+  "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",

package/src/toolkit/derivers/domain.test.ts

@@ -0,0 +1,140 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  emitDomainModel,
+  emitDomain,
+  deriveDomain,
+  sourcesFromManifest,
+  registryFromManifest,
+  sqliteAffinityToTs,
+  interfaceName,
+  type SourceSchema,
+  type TableMeta,
+  type DomainTypeRegistry,
+} from "./domain.ts";
+import type { ToolkitManifest } from "./migrations.ts";
+
+// Goldens captured verbatim from the console's `emitDomainModel` (server domain_types.ts) via
+// Deno — this IS the per-emitter drift gate (ADR 0053): the toolkit must be byte-identical.
+const GOLDENS: Record<string, string> = JSON.parse("{\n  \"empty\": \"// 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\\nexport interface DomainTables {}\\n\",\n  \"tablesOnly\": \"// 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\\nexport interface Customers {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  email: string;\\n  /** TEXT */\\n  tier: string | null;\\n}\\n\\nexport interface OrderItems {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** INTEGER */\\n  qty: number;\\n  /** REAL */\\n  \\\"unit price\\\": number | null;\\n}\\n\\n/** Every table keyed by its wire name — index it for a row type. */\\nexport interface DomainTables {\\n  \\\"customers\\\": Customers;\\n  \\\"order_items\\\": OrderItems;\\n}\\n\",\n  \"typesOnly\": \"// 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\\nexport interface DomainTables {}\\n\\n/** Declared (transient) domain types from the manifest `types` registry (ADR 0029 §4.2), keyed by id. */\\nexport interface DomainTypes {\\n  \\\"taxReturn\\\": {\\n    year: number;\\n    notes?: string;\\n    lines: DomainTypes[\\\"lineItem\\\"][];\\n  };\\n  \\\"lineItem\\\": {\\n    \\\"line no\\\": number;\\n    amount: number;\\n  };\\n}\\n\",\n  \"both\": \"// 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\\nexport interface Greetings {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  who: string;\\n  /** TEXT */\\n  message: string;\\n  /** TEXT */\\n  createdAt: string | null;\\n}\\n\\n/** Every table keyed by its wire name — index it for a row type. */\\nexport interface DomainTables {\\n  \\\"greetings\\\": Greetings;\\n}\\n\\n/** Declared (transient) domain types from the manifest `types` registry (ADR 0029 §4.2), keyed by id. */\\nexport interface DomainTypes {\\n  \\\"greeting\\\": {\\n    who: string;\\n    message: string;\\n    createdAt?: string;\\n  };\\n}\\n\",\n  \"multi\": \"// 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\\nexport interface AppCustomers {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  email: string;\\n}\\n\\nexport interface AnalyticsEvents {\\n  /** INTEGER (primary key) */\\n  id: number;\\n  /** TEXT */\\n  kind: string;\\n}\\n\\n/** Every datasource keyed by alias, then table by wire name. */\\nexport interface DomainSources {\\n  \\\"app\\\": {\\n    \\\"customers\\\": AppCustomers;\\n  };\\n  \\\"analytics\\\": {\\n    \\\"events\\\": AnalyticsEvents;\\n  };\\n}\\n\\n/** The default datasource's tables — index by wire name. */\\nexport type DomainTables = DomainSources[\\\"analytics\\\"];\\n\"\n}");
+
+const col = (name: string, type: string, notNull: boolean, primaryKey: boolean) =>
+  ({ name, type, notNull, primaryKey });
+const table = (name: string, cols: TableMeta["columns"]): TableMeta => ({ name, columns: cols, indexes: [], foreignKeys: [] });
+
+test("emitDomainModel: empty app → bare DomainTables (byte-parity)", () => {
+  assert.equal(emitDomainModel([], undefined, {}), GOLDENS.empty);
+});
+
+test("emitDomainModel: table spine only (byte-parity)", () => {
+  const sources: SourceSchema[] = [{ source: "app", tables: [
+    table("customers", [col("id","INTEGER",false,true), col("email","TEXT",true,false), col("tier","TEXT",false,false)]),
+    table("order_items", [col("id","INTEGER",false,true), col("qty","INTEGER",true,false), col("unit price","REAL",false,false)]),
+  ]}];
+  assert.equal(emitDomainModel(sources, "app", {}), GOLDENS.tablesOnly);
+});
+
+test("emitDomainModel: registry only — nominal ref, list, optional, non-ident key (byte-parity)", () => {
+  const types: DomainTypeRegistry = {
+    taxReturn: { fields: { year: { type: "integer" }, notes: { type: "string", optional: true }, lines: { type: "lineItem", list: true } } },
+    lineItem: { fields: { "line no": { type: "integer" }, amount: { type: "number" } } },
+  };
+  assert.equal(emitDomainModel([], undefined, types), GOLDENS.typesOnly);
+});
+
+test("emitDomainModel: table + registry coexist for same type (byte-parity)", () => {
+  const sources: SourceSchema[] = [{ source: "app", tables: [
+    table("greetings", [col("id","INTEGER",false,true), col("who","TEXT",true,false), col("message","TEXT",true,false), col("createdAt","TEXT",false,false)]),
+  ]}];
+  const types: DomainTypeRegistry = { greeting: { table: "greetings", fields: { who: { type: "string" }, message: { type: "string" }, createdAt: { type: "datetime", optional: true } } } };
+  assert.equal(emitDomainModel(sources, "app", types), GOLDENS.both);
+});
+
+test("emitDomainModel: multi-source → DomainSources + DomainTables alias to default (byte-parity)", () => {
+  const sources: SourceSchema[] = [
+    { source: "app", tables: [ table("customers", [col("id","INTEGER",false,true), col("email","TEXT",true,false)]) ] },
+    { source: "analytics", tables: [ table("events", [col("id","INTEGER",false,true), col("kind","TEXT",true,false)]) ] },
+  ];
+  assert.equal(emitDomainModel(sources, "analytics", {}), GOLDENS.multi);
+});
+
+// --- manifest bridge: code-first derivation reproduces the console output --------------------
+
+test("emitDomain: manifest types drive BOTH the table spine and the registry (byte-parity)", () => {
+  const manifest: ToolkitManifest = {
+    data: { default: "app" },
+    types: { greeting: { table: "greetings", fields: {
+      who: { type: "string" }, message: { type: "string" }, createdAt: { type: "datetime", optional: true },
+    } } },
+  };
+  // The manifest 'greeting' type yields DomainTables["greetings"] (id + fields) and
+  // DomainTypes["greeting"] (declared fields only) — identical to the console's `both` case.
+  assert.equal(emitDomain(manifest), GOLDENS.both);
+});
+
+test("sourcesFromManifest: implicit id PK + field affinity + nullability", () => {
+  const manifest: ToolkitManifest = { data: { default: "app" }, types: {
+    greeting: { table: "greetings", fields: { who: { type: "string" }, createdAt: { type: "datetime", optional: true } } },
+  } };
+  const [src] = sourcesFromManifest(manifest);
+  assert.equal(src.source, "app");
+  assert.deepEqual(src.tables[0], table("greetings", [
+    col("id", "INTEGER", false, true),
+    col("who", "TEXT", true, false),
+    col("createdAt", "TEXT", false, false),
+  ]));
+});
+
+test("sourcesFromManifest: table name defaults to the type id; types group by source", () => {
+  const manifest: ToolkitManifest = { data: { default: "app" }, types: {
+    order: { fields: { total: { type: "number" } } },
+    event: { source: "analytics", fields: { kind: { type: "string" } } },
+  } };
+  const sources = sourcesFromManifest(manifest);
+  assert.deepEqual(sources.map((s) => s.source), ["app", "analytics"]);
+  assert.equal(sources[0].tables[0].name, "order");
+  assert.equal(sources[1].tables[0].name, "event");
+});
+
+test("registryFromManifest: declared fields only (no persisted id); type defaults to string", () => {
+  const manifest: ToolkitManifest = { types: {
+    greeting: { table: "greetings", fields: { who: {}, note: { type: "string", optional: true } } },
+  } };
+  assert.deepEqual(registryFromManifest(manifest), {
+    greeting: { table: "greetings", fields: { who: { type: "string", optional: undefined, list: undefined }, note: { type: "string", optional: true, list: undefined } } },
+  });
+});
+
+test("registryFromManifest + emitDomain: the `list` modifier is preserved as `T[]`", () => {
+  const manifest: ToolkitManifest = { types: {
+    order: { fields: { tags: { type: "string", list: true } } },
+  } };
+  // The bridge must forward `list` (not drop it) so the emitter can project the repeated field.
+  assert.equal(registryFromManifest(manifest).order.fields.tags.list, true);
+  assert.match(emitDomain(manifest), /tags: string\[\];/);
+});
+
+test("deriveDomain: emits domain-rows.d.ts only when the manifest declares types", () => {
+  assert.deepEqual(deriveDomain({}), []);
+  assert.deepEqual(deriveDomain({ types: {} }), []);
+  const arts = deriveDomain({ data: { default: "app" }, types: { greeting: { table: "greetings", fields: { who: { type: "string" } } } } });
+  assert.equal(arts.length, 1);
+  assert.equal(arts[0].path, "nano-generated/domain-rows.d.ts");
+});
+
+test("sqliteAffinityToTs: SQLite affinity rules with boolean/datetime overrides", () => {
+  assert.equal(sqliteAffinityToTs("INTEGER"), "number");
+  assert.equal(sqliteAffinityToTs("TEXT"), "string");
+  assert.equal(sqliteAffinityToTs("REAL"), "number");
+  assert.equal(sqliteAffinityToTs("BLOB"), "Uint8Array");
+  assert.equal(sqliteAffinityToTs("BOOLEAN"), "boolean");
+  assert.equal(sqliteAffinityToTs("DATETIME"), "string");
+  assert.equal(sqliteAffinityToTs("NUMERIC"), "number");
+  assert.equal(sqliteAffinityToTs(""), "unknown");
+});
+
+test("interfaceName: PascalCases + sanitises table names to identifiers", () => {
+  assert.equal(interfaceName("order_items"), "OrderItems");
+  assert.equal(interfaceName("customers"), "Customers");
+  assert.equal(interfaceName("2024_events"), "T_2024Events");
+});