@nanobpm/urban 0.16.1 → 0.17.1

package/src/runtime/core/manifest.ts

@@ -1,139 +1,40 @@
-// 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.
+// 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.
 
 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 function workerJobType(w: WorkerDecl): string | undefined {
-  return w.taskType ?? w.type;
+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 function workerJobType(w: Worker): string | undefined {
+  return w.taskType;
 }
 
 const ENV_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;

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

@@ -2,7 +2,7 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import type { AppApi, RuntimeContext } from "../context.ts";
 import type { HttpRequest } from "../host.ts";
-import type { TriggerDecl } from "../manifest.ts";
+import type { Trigger } from "../manifest.ts";
 import { makeRouter } from "../router.ts";
 import { evalCorrelation, mountTriggers, runTriggerAction, type SchedulerDeps } from "./triggers.ts";
 
@@ -33,7 +33,7 @@ function fakeApp(): { app: AppApi; calls: EngineCall[]; logs: Array<{ level: str
   return { app, calls, logs };
 }
 
-function fakeCtx(triggers: TriggerDecl[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
+function fakeCtx(triggers: Trigger[]): { ctx: RuntimeContext; hostLogs: Array<{ level: string; msg: string }> } {
   const hostLogs: Array<{ level: string; msg: string }> = [];
   const ctx = {
     root: "/app",
@@ -113,6 +113,8 @@ test("evalCorrelation returns undefined for a non-scalar result", () => {
 
 test("runTriggerAction starts a process with action.variables", async () => {
   const { app, calls } = fakeApp();
+  // The manifest surface types `variables` as a FEEL string; the runtime helper
+  // (runTriggerAction/resolveActionVariables) also accepts an inline object literal.
   const res = await runTriggerAction(app, { start: "proc-1", variables: { a: 1 } }, {
     body: { ignored: true },
     headers: {},
@@ -207,7 +209,7 @@ test("cron trigger with an invalid spec logs an error and does not schedule", ()
 
 test("cron trigger with no actionable action is not scheduled", () => {
   const { app, logs } = fakeApp();
-  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *" }]);
+  const { ctx } = fakeCtx([{ id: "noop", type: "cron", spec: "0 6 * * *", action: {} }]);
   const sched = fakeScheduler(0);
   const handle = mountTriggers(ctx, app, sched);
   assert.equal(sched.pending(), 0);

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

@@ -6,7 +6,7 @@
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import type { HttpRequest } from "../host.ts";
 import { json, normalizeRoutePath, type Route } from "../router.ts";
-import type { TriggerDecl } from "../manifest.ts";
+import type { Trigger } from "../manifest.ts";
 import { nextCronFire, parseCron } from "./cron.ts";
 
 export interface TriggersHandle extends Mounted {
@@ -112,9 +112,23 @@ function headerRecord(req: HttpRequest): Record<string, string> {
  * of `correlationKey`/`variables`; cron passes a minimal `{ firedAt }` body. Returns what
  * was done.
  */
+/**
+ * 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 async function runTriggerAction(
   app: AppApi,
-  action: TriggerDecl["action"],
+  action: RuntimeTriggerAction | undefined,
   scope: Scope,
 ): Promise<{ kind: "start" | "message" | "none"; target?: string; correlationKey?: string }> {
   if (!action) return { kind: "none" };
@@ -161,7 +175,7 @@ export function mountTriggers(
   let stopped = false;
 
   // Arm a cron trigger: compute the next UTC fire, sleep until it, fire the action, repeat.
-  const armCron = (trig: TriggerDecl): void => {
+  const armCron = (trig: Trigger): void => {
     const spec = trig.spec;
     if (!spec) {
       ctx.host.log("warn", `trigger "${trig.id}": cron trigger has no spec, skipped`);
@@ -241,7 +255,7 @@ export function mountTriggers(
     arm();
   };
 
-  for (const trig of (ctx.manifest.triggers ?? []) as TriggerDecl[]) {
+  for (const trig of (ctx.manifest.triggers ?? []) as Trigger[]) {
     if (trig.type === "cron") {
       armCron(trig);
       continue;

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

@@ -4,7 +4,7 @@
 
 import type { AppApi, Mounted, RuntimeContext } from "../context.ts";
 import type { EngineJob, JobHandler, WorkerSubscription } from "../host.ts";
-import { workerJobType, type WorkerDecl } from "../manifest.ts";
+import { workerJobType, type Worker } from "../manifest.ts";
 import { type DecisionEvaluator, type LlmRuntime, runLlmJob } from "./llm.ts";
 
 /** The subset of the engine SDK the LLM decision-rails need: evaluate a DMN decision,
@@ -106,7 +106,7 @@ export async function mountWorkers(ctx: RuntimeContext, app: AppApi): Promise<Wo
     return mod;
   };
 
-  for (const decl of decls as WorkerDecl[]) {
+  for (const decl of decls as Worker[]) {
     const jobType = workerJobType(decl);
     if (!jobType) continue;
     if (!decl.handler) {

package/src/runtime/core/validate.ts

@@ -1,13 +1,14 @@
-// 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.
+// 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 "../schema/nano-app.schema.json" with { type: "json" };
+import schema from "@nanobpm/nano-app-schema/schema" with { type: "json" };
 import { workerJobType, type AppManifest } from "./manifest.ts";
 
 export interface ValidationIssue {
@@ -73,7 +74,7 @@ export function collectManifestIssues(m: unknown): ValidationIssue[] {
   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/src/runtime/index.ts

@@ -19,13 +19,16 @@ export {
 export type {
   ActionDecl,
   AppManifest,
+  ChatSurface,
   DataSource,
+  DomainField,
   DomainType,
   LlmBinding,
-  SurfaceDecl,
-  TriggerDecl,
-  TypeField,
-  WorkerDecl,
+  PagesSurface,
+  Surfaces,
+  TaskInboxSurface,
+  Trigger,
+  Worker,
 } from "./core/manifest.ts";
 
 // Validation

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");
+});