@nanobpm/urban 0.17.0 → 0.18.0

package/src/toolkit/gen.test.ts

@@ -1,9 +1,14 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { runGen, collectArtifacts, type GenIO } from "./gen.ts";
+import { defineFlow, envelope } from "@nanobpm/workflow";
+import { MODEL_PROVENANCE } from "./models.ts";
 
 /** In-memory filesystem for deterministic, IO-free gen tests. */
-function memIO(files: Record<string, string>): GenIO & { files: Record<string, string> } {
+function memIO(
+  files: Record<string, string>,
+  modules: Record<string, Record<string, unknown>> = {},
+): GenIO & { files: Record<string, string> } {
   return {
     files,
     async readText(p) {
@@ -27,6 +32,13 @@ function memIO(files: Record<string, string>): GenIO & { files: Record<string, s
     async exists(p) {
       return p in files;
     },
+    async remove(p) {
+      delete files[p];
+    },
+    async importModule(p) {
+      if (!(p in modules)) throw new Error(`no module registered for ${p}`);
+      return modules[p];
+    },
   };
 }
 
@@ -50,16 +62,23 @@ function fixture(): Record<string, string> {
   };
 }
 
-test("runGen writes migrations and the worker index", async () => {
+test("runGen writes migrations, the worker index, the meta accessor, and the message map", async () => {
   const io = memIO(fixture());
   const res = await runGen({ root: "/app", io });
   const paths = res.artifacts.map((a) => a.path).sort();
   assert.deepEqual(paths, [
     "nano-generated/app.schema.sql",
+    "nano-generated/domain-rows.d.ts",
+    "nano-generated/message-io.d.ts",
+    "nano-generated/meta.ts",
     "nano-generated/worker-io.d.ts",
   ]);
   assert.ok(io.files["/app/nano-generated/app.schema.sql"].includes("CREATE TABLE"));
   assert.ok(io.files["/app/nano-generated/worker-io.d.ts"].includes("demo.do"));
+  assert.ok(io.files["/app/nano-generated/meta.ts"].includes("export function meta"));
+  assert.ok(io.files["/app/nano-generated/message-io.d.ts"].includes("export type MessageName"));
+  assert.ok(io.files["/app/nano-generated/domain-rows.d.ts"].includes('"greetings": Greetings;'));
+  assert.ok(io.files["/app/nano-generated/domain-rows.d.ts"].includes('"greeting": {'));
 });
 
 test("gen --check reports no drift right after a write", async () => {
@@ -83,3 +102,66 @@ test("collectArtifacts touches no writes", async () => {
   await collectArtifacts({ root: "/app", io });
   assert.equal(Object.keys(io.files).length, before);
 });
+
+// --- code-first model derivation (urban gen / urban derive) ---
+
+const GreetIn = envelope("GreetIn", { who: "string" });
+const GreetOut = envelope("GreetOut", { message: "string" });
+const greetFlow = defineFlow("greet", { hello: { in: GreetIn, out: GreetOut } }, (w) => {
+  w.run("hello", async () => ({ message: "hi" }));
+});
+
+const CODE_FIRST_MANIFEST = JSON.stringify({
+  id: "cf",
+  data: { default: "app" },
+  models: { workflows: ["workflows/*.ts"] },
+  types: { greeting: { table: "greetings", fields: { who: { type: "string" } } } },
+});
+
+function codeFirstIO() {
+  return memIO(
+    {
+      "/cf/nano.app.json": CODE_FIRST_MANIFEST,
+      "/cf/workflows/greet.ts": "// derived in-memory via importModule stub",
+    },
+    { "/cf/workflows/greet.ts": { greet: greetFlow } },
+  );
+}
+
+test("runGen derives processes/<id>.bpmn from workflows/*.ts and feeds worker-io off it", async () => {
+  const io = codeFirstIO();
+  const res = await runGen({ root: "/cf", io });
+  const bpmn = io.files["/cf/processes/greet.bpmn"];
+  assert.ok(bpmn, "expected a derived processes/greet.bpmn");
+  assert.ok(bpmn.includes(MODEL_PROVENANCE), "derived .bpmn must be provenance-stamped");
+  assert.ok(bpmn.includes('type="greet:hello"'), "derived .bpmn carries the task type");
+  // worker-io is derived FROM the in-memory model, not from any on-disk file.
+  assert.ok(io.files["/cf/nano-generated/worker-io.d.ts"].includes("greet:hello"));
+  assert.equal(res.incomplete, false);
+  assert.deepEqual(res.modelErrors, []);
+});
+
+test("gen --no-models derives in-memory for worker-io but writes no .bpmn", async () => {
+  const io = codeFirstIO();
+  const res = await runGen({ root: "/cf", io, emitModels: false });
+  assert.equal(io.files["/cf/processes/greet.bpmn"], undefined, "must not write .bpmn");
+  // still derives the model in-memory so worker-io is populated.
+  assert.ok(io.files["/cf/nano-generated/worker-io.d.ts"].includes("greet:hello"));
+  assert.equal(res.incomplete, false);
+});
+
+test("the provenance sweep removes a stale derived .bpmn no longer backed by a workflow", async () => {
+  const io = codeFirstIO();
+  // a leftover derived model from a since-deleted flow, provenance-stamped.
+  io.files["/cf/processes/stale.bpmn"] = `<?xml version="1.0"?>\n${MODEL_PROVENANCE}\n<bpmn:x/>`;
+  await runGen({ root: "/cf", io });
+  assert.ok(io.files["/cf/processes/greet.bpmn"], "keeps the live derived model");
+  assert.equal(io.files["/cf/processes/stale.bpmn"], undefined, "sweeps the stale derived model");
+});
+
+test("the sweep never touches an authored (un-stamped) .bpmn", async () => {
+  const io = codeFirstIO();
+  io.files["/cf/processes/authored.bpmn"] = `<?xml version="1.0"?>\n<bpmn:authored/>`;
+  await runGen({ root: "/cf", io });
+  assert.ok(io.files["/cf/processes/authored.bpmn"], "authored .bpmn must survive the sweep");
+});

package/src/toolkit/gen.ts

@@ -6,7 +6,11 @@
 import type { DerivedArtifact } from "./artifact.ts";
 import { sortArtifacts } from "./artifact.ts";
 import { deriveMigrations, type ToolkitManifest } from "./derivers/migrations.ts";
+import { deriveDomain } from "./derivers/domain.ts";
 import { deriveWorkerBindings, type ModelSource } from "./derivers/worker-io.ts";
+import { deriveMeta } from "./derivers/meta.ts";
+import { deriveMessageBindings } from "./derivers/messages.ts";
+import { deriveModels, type DerivedModels, type ModelError, MODEL_PROVENANCE } from "./models.ts";
 
 /** Minimal filesystem port. Node/Deno impls live in `fsio.ts`. */
 export interface GenIO {
@@ -15,18 +19,40 @@ export interface GenIO {
   /** File names (not paths) in a directory; empty if it does not exist. */
   listDir(path: string): Promise<string[]>;
   exists(path: string): Promise<boolean>;
+  /**
+   * Import an app module and return its exports. Optional: only present when the caller runs on
+   * a runtime that can load the app's TypeScript (Node with type-stripping, or Deno). Code-first
+   * model derivation (`workflows/*.ts` → BPMN) needs it; when absent, gen still derives everything
+   * else (migrations, domain, worker I/O from authored/derived models).
+   */
+  importModule?(path: string): Promise<Record<string, unknown>>;
+  /** Delete a file. Optional: enables the provenance-scoped stale-model sweep (skipped when absent). */
+  remove?(path: string): Promise<void>;
 }
 
 export interface GenOptions {
   root: string;
   io: GenIO;
   manifestFile?: string;
+  /**
+   * Whether to emit (write) derived `.bpmn` models. Default true. When false, code-first models
+   * are still derived *in-memory* to feed the type-contract derivers (worker I/O, meta, messages)
+   * — they are just not written to disk or swept. This is the `urban gen --no-models` path, so
+   * the console's type-contract regen never mutates `processes/*.bpmn`.
+   */
+  emitModels?: boolean;
+  /** Derive ONLY the models (skip migrations/domain/worker-I/O). The `urban derive` path. */
+  modelsOnly?: boolean;
 }
 
 export interface GenResult {
   artifacts: DerivedArtifact[];
   /** Paths that differ from disk (only populated by `check`). */
   drift: string[];
+  /** True if any code-first workflow failed to import/derive. */
+  incomplete: boolean;
+  /** Per-file model-derivation errors (empty on success). */
+  modelErrors: ModelError[];
 }
 
 function join(root: string, rel: string): string {
@@ -41,7 +67,7 @@ function dirOf(p: string): string {
 }
 
 /** Resolve a `dir/*.ext` (or literal) manifest pattern to file paths relative to root. */
-async function expandPattern(root: string, io: GenIO, pattern: string): Promise<string[]> {
+export async function expandPattern(root: string, io: GenIO, pattern: string): Promise<string[]> {
   const star = pattern.indexOf("*");
   if (star === -1) {
     return (await io.exists(join(root, pattern))) ? [pattern] : [];
@@ -75,33 +101,55 @@ export async function readModels(
 
 /** Collect all artifacts a run would produce, without touching disk beyond reads. */
 export async function collectArtifacts(opts: GenOptions): Promise<DerivedArtifact[]> {
+  return (await collectAll(opts)).artifacts;
+}
+
+/** Internal: collect artifacts AND the model-derivation details (needed by `runGen` for the
+ * incomplete signal + the provenance-scoped stale sweep). */
+async function collectAll(opts: GenOptions): Promise<{ artifacts: DerivedArtifact[]; derived: DerivedModels }> {
   const { root, io } = opts;
+  const emitModels = opts.emitModels ?? true;
   const manifestPath = join(root, opts.manifestFile ?? "nano.app.json");
   const manifest = JSON.parse(await io.readText(manifestPath)) as ToolkitManifest & {
-    models?: { processes?: string[] };
+    models?: { processes?: string[]; workflows?: string[] };
   };
 
   const artifacts: DerivedArtifact[] = [];
 
-  // 1. types → migrations
-  if (manifest.types && Object.keys(manifest.types).length > 0) {
+  // 1. types → migrations + domain row types (DomainTables spine + DomainTypes registry)
+  if (!opts.modelsOnly && manifest.types && Object.keys(manifest.types).length > 0) {
     artifacts.push(...deriveMigrations(manifest));
+    artifacts.push(...deriveDomain(manifest));
   }
 
-  // 2. models → worker I/O index
-  const models = await readModels(root, io, manifest);
-  if (models.length > 0) {
-    const declaredTypeIds = Object.keys(manifest.types ?? {});
-    artifacts.push(...deriveWorkerBindings(models, declaredTypeIds));
+  // 2. code-first models → derive BPMN from `workflows/*.ts` (executes the app's TS). The derived
+  //    `.bpmn` are emitted only when `emitModels` (default), but always fed to the type-contract
+  //    derivers below so worker I/O works for a code-first app even on a `--no-models` run.
+  const derived = await deriveModels(root, io, manifest);
+  if (emitModels) artifacts.push(...derived.artifacts);
+
+  // 3. models (authored on-disk + derived) → worker I/O index + meta accessor + message map.
+  //    Drop any on-disk model whose path a derived model already covers, to avoid double-counting.
+  if (!opts.modelsOnly) {
+    const derivedPaths = new Set(derived.artifacts.map((a) => a.path));
+    const diskModels = (await readModels(root, io, manifest)).filter((m) => !derivedPaths.has(m.path));
+    const models = [...diskModels, ...derived.models];
+    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);
+  return { artifacts: sortArtifacts(artifacts), derived };
 }
 
 /** Run the derivers and write artifacts (or, with `check`, report drift without writing). */
 export async function runGen(opts: GenOptions & { check?: boolean }): Promise<GenResult> {
-  const artifacts = await collectArtifacts(opts);
+  const { artifacts, derived } = await collectAll(opts);
   const { root, io } = opts;
+  const emitModels = opts.emitModels ?? true;
   const drift: string[] = [];
 
   for (const a of artifacts) {
@@ -113,7 +161,33 @@ export async function runGen(opts: GenOptions & { check?: boolean }): Promise<Ge
       await io.writeText(abs, a.content);
     }
   }
-  return { artifacts, drift };
+
+  // Provenance-scoped stale sweep: delete derived `.bpmn` for flows that no longer exist. Only
+  // in write mode, only when we emitted models, only on a complete derivation (never delete when
+  // a workflow failed to load), and only files bearing our marker (authored models are untouched).
+  if (!opts.check && emitModels && derived.attempted && !derived.incomplete && io.remove) {
+    const keep = new Set(derived.artifacts.map((a) => a.path));
+    for (const name of await io.listDir(join(root, derived.outDir))) {
+      if (!name.endsWith(".bpmn")) continue;
+      const rel = `${derived.outDir}/${name}`;
+      if (keep.has(rel)) continue;
+      const content = await io.readText(join(root, rel));
+      if (content.includes(MODEL_PROVENANCE)) await io.remove(join(root, rel));
+    }
+  }
+
+  return { artifacts, drift, incomplete: derived.incomplete, modelErrors: derived.errors };
 }
 
 export { dirOf, join as joinPath };
+
+/** Derive code-first models in-memory (no writes) — backs `urban derive --stdout`, the
+ * non-mutating preview the console's read-only model viewer uses. */
+export async function previewModels(opts: GenOptions): Promise<DerivedModels> {
+  const { root, io } = opts;
+  const manifestPath = join(root, opts.manifestFile ?? "nano.app.json");
+  const manifest = JSON.parse(await io.readText(manifestPath)) as {
+    models?: { processes?: string[]; workflows?: string[] };
+  };
+  return deriveModels(root, io, manifest);
+}

package/src/toolkit/index.ts

@@ -13,8 +13,36 @@ export {
   migrationsDeriver,
   sqlType,
   createTableSql,
+  tableSchemaForType,
+  groupTypesBySource,
 } from "./derivers/migrations.ts";
-export type { ToolkitManifest, ToolkitType, ToolkitField } 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,
@@ -25,17 +53,52 @@ export {
   DOMAIN_DTS,
 } from "./derivers/worker-io.ts";
 export type { ModelSource, WorkerIo, WorkerBindingDecl } from "./derivers/worker-io.ts";
+export { byModelPath, typeRefFor } from "./derivers/worker-io.ts";
+
+export {
+  deriveMeta,
+  emitMeta,
+  foldMeta,
+  metaDeriver,
+  scanModelMeta,
+  META_TS,
+} from "./derivers/meta.ts";
+export type { MetaDecl } from "./derivers/meta.ts";
+
+export {
+  deriveMessageBindings,
+  emitMessageBindings,
+  messagesDeriver,
+  scanModelMessages,
+  MESSAGE_BINDINGS_DTS,
+} from "./derivers/messages.ts";
+export type { MessageIo, MessageBindingDecl } from "./derivers/messages.ts";
 
 // The registry of all derivers (for discovery / IDE migration).
 import { migrationsDeriver } from "./derivers/migrations.ts";
+import { domainDeriver } from "./derivers/domain.ts";
 import { workerIoDeriver } from "./derivers/worker-io.ts";
-export const DERIVERS = [migrationsDeriver, workerIoDeriver] as const;
+import { metaDeriver } from "./derivers/meta.ts";
+import { messagesDeriver } from "./derivers/messages.ts";
+export const DERIVERS = [migrationsDeriver, domainDeriver, workerIoDeriver, metaDeriver, messagesDeriver] as const;
 
 // Gen orchestrator + IO
-export { collectArtifacts, runGen, joinPath, readModels } from "./gen.ts";
+export { collectArtifacts, runGen, joinPath, readModels, expandPattern, previewModels } from "./gen.ts";
 export type { GenIO, GenOptions, GenResult } from "./gen.ts";
 export { createNodeGenIO } from "./fsio.ts";
 
+// Code-first model derivation (workflows/*.ts → BPMN)
+export {
+  deriveModels,
+  isWorkflow,
+  bpmnFilename,
+  processesOutDir,
+  DEFAULT_WORKFLOW_PATTERNS,
+  PROCESSES_DIR,
+  MODEL_PROVENANCE,
+} from "./models.ts";
+export type { DerivedModels, DerivedModelInfo, ModelError, ModelsManifest } from "./models.ts";
+
 // Worker-stub scaffolder (ADR 0056): write-once handler stubs from the model.
 export {
   planWorkerScaffold,

package/src/toolkit/models.test.ts

@@ -0,0 +1,159 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { defineFlow, envelope } from "@nanobpm/workflow";
+import { deriveModels, isWorkflow, bpmnFilename, processesOutDir, MODEL_PROVENANCE } from "./models.ts";
+import type { GenIO } from "./gen.ts";
+
+/** In-memory GenIO whose `importModule` returns pre-registered module exports by path. */
+function memIO(
+  files: Record<string, string>,
+  modules: Record<string, Record<string, unknown>> = {},
+): GenIO {
+  return {
+    async readText(p) {
+      if (!(p in files)) throw new Error(`ENOENT ${p}`);
+      return files[p];
+    },
+    async writeText(p, c) {
+      files[p] = c;
+    },
+    async listDir(p) {
+      const prefix = p.replace(/\/+$/, "") + "/";
+      const names = new Set<string>();
+      for (const f of Object.keys(files)) {
+        if (f.startsWith(prefix)) {
+          const rest = f.slice(prefix.length);
+          if (!rest.includes("/")) names.add(rest);
+        }
+      }
+      return [...names];
+    },
+    async exists(p) {
+      return p in files || p in modules;
+    },
+    importModule(p) {
+      const key = Object.keys(modules).find((k) => p.endsWith(k));
+      if (!key) return Promise.reject(new Error(`ENOENT ${p}`));
+      return Promise.resolve(modules[key]);
+    },
+  };
+}
+
+const GreetIn = envelope("GreetIn", { who: "string" });
+const GreetOut = envelope("GreetOut", { message: "string" });
+
+/** A real one-step declarative flow (exercises the actual toBpmn + layout pipeline). */
+const greet = defineFlow("greet", { hello: { in: GreetIn, out: GreetOut } }, (w) => {
+  w.run("hello", async () => ({ message: "hi" }));
+});
+
+const CODE_FIRST_MANIFEST = { models: { workflows: ["workflows/*.ts"] } };
+
+test("isWorkflow recognizes defineFlow exports, rejects everything else", () => {
+  assert.equal(isWorkflow(greet), true);
+  assert.equal(isWorkflow({ id: "x", kind: "imperative" }), true);
+  assert.equal(isWorkflow({ id: "x", kind: "nope" }), false);
+  assert.equal(isWorkflow({ kind: "declarative" }), false);
+  assert.equal(isWorkflow(null), false);
+  assert.equal(isWorkflow("greet"), false);
+});
+
+test("bpmnFilename sanitizes ids into safe .bpmn filenames", () => {
+  assert.equal(bpmnFilename("greet"), "greet.bpmn");
+  assert.equal(bpmnFilename("orders/place"), "orders-place.bpmn");
+  assert.equal(bpmnFilename("a b:c"), "a-b-c.bpmn");
+});
+
+test("processesOutDir defaults to processes/, or the dir of a models.processes glob", () => {
+  assert.equal(processesOutDir({}), "processes");
+  assert.equal(processesOutDir({ models: { processes: ["resources/processes/*.bpmn"] } }), "resources/processes");
+  assert.equal(processesOutDir({ models: { processes: ["src/models/*.bpmn"] } }), "src/models");
+});
+
+test("deriveModels turns workflows/*.ts into a provenance-stamped processes/<id>.bpmn", async () => {
+  const io = memIO(
+    { "/app/workflows/greet.ts": "// source" },
+    { "workflows/greet.ts": { greet } },
+  );
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+
+  assert.equal(d.attempted, true);
+  assert.equal(d.incomplete, false);
+  assert.deepEqual(d.ids, ["greet"]);
+  assert.equal(d.artifacts.length, 1);
+  assert.equal(d.artifacts[0].path, "processes/greet.bpmn");
+  assert.match(d.artifacts[0].content, /<!--.*@nanobpm\/urban/);
+  assert.ok(d.artifacts[0].content.includes(MODEL_PROVENANCE));
+  assert.match(d.artifacts[0].content, /greet/);
+  // the in-memory ModelSource is fed to the type-contract derivers
+  assert.deepEqual(d.models.map((m) => m.path), ["processes/greet.bpmn"]);
+  assert.equal(d.list[0].id, "greet");
+  assert.equal(d.list[0].kind, "declarative");
+});
+
+test("deriveModels is a no-op without a module loader (pure/IDE callers)", async () => {
+  const io = memIO({ "/app/workflows/greet.ts": "// source" });
+  delete (io as { importModule?: unknown }).importModule;
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+  assert.equal(d.attempted, false);
+  assert.equal(d.artifacts.length, 0);
+});
+
+test("deriveModels writes into the manifest's models.processes dir when declared", async () => {
+  const io = memIO(
+    { "/app/workflows/greet.ts": "// source" },
+    { "workflows/greet.ts": { greet } },
+  );
+  const d = await deriveModels("/app", io, {
+    models: { workflows: ["workflows/*.ts"], processes: ["resources/processes/*.bpmn"] },
+  });
+  assert.equal(d.outDir, "resources/processes");
+  assert.equal(d.artifacts[0].path, "resources/processes/greet.bpmn");
+});
+
+test("deriveModels records a failing workflow as incomplete without throwing", async () => {
+  const io = memIO(
+    { "/app/workflows/bad.ts": "// source" },
+    {}, // no module registered → importModule rejects
+  );
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+  assert.equal(d.attempted, true);
+  assert.equal(d.incomplete, true);
+  assert.equal(d.errors.length, 1);
+  assert.equal(d.errors[0].path, "workflows/bad.ts");
+});
+
+test("deriveModels flags a duplicate flow id across two files", async () => {
+  const io = memIO(
+    { "/app/workflows/a.ts": "// a", "/app/workflows/b.ts": "// b" },
+    { "workflows/a.ts": { greet }, "workflows/b.ts": { greet } },
+  );
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+  assert.equal(d.incomplete, true);
+  assert.ok(d.errors.some((e) => /duplicate flow id "greet"/.test(e.message)));
+  assert.equal(d.ids.length, 1); // first wins
+});
+
+test("deriveModels flags two distinct flows sharing an id in the same module", async () => {
+  // two SEPARATE defineFlow objects, same id, same file — a real collision, not a re-export.
+  const greetA = defineFlow("greet", { hello: { in: GreetIn, out: GreetOut } }, (w) => {
+    w.run("hello", async () => ({ message: "a" }));
+  });
+  const greetB = defineFlow("greet", { hello: { in: GreetIn, out: GreetOut } }, (w) => {
+    w.run("hello", async () => ({ message: "b" }));
+  });
+  const io = memIO({ "/app/workflows/dup.ts": "// dup" }, { "workflows/dup.ts": { greetA, greetB } });
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+  assert.equal(d.incomplete, true);
+  assert.ok(d.errors.some((e) => /duplicate flow id "greet" \(also defined in the same module\)/.test(e.message)));
+  assert.equal(d.ids.length, 1); // only the first is derived
+});
+
+test("deriveModels treats a genuine same-module re-export as one model, no error", async () => {
+  // the SAME flow object exported under two names in one file — harmless.
+  const io = memIO({ "/app/workflows/re.ts": "// re" }, { "workflows/re.ts": { greet, alsoGreet: greet } });
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+  assert.equal(d.incomplete, false);
+  assert.deepEqual(d.errors, []);
+  assert.equal(d.ids.length, 1);
+});