okengine 0.10.0 → 0.10.2

package/src/compiler/effects-infer.ts

@@ -15,6 +15,7 @@ import type {
   TemplateRef,
   FlowRef,
 } from "../manifest/types.ts";
+import { sqlTableRef } from "../manifest/sql-resource.ts";
 
 /** Minimal ESTree-shaped nodes produced by oxc-parser. */
 export interface AstNode {
@@ -54,6 +55,7 @@ export interface InferBinding {
     | "template"
     | "flow"
     | "embed"
+    | "table"
     | "unknown";
   /** Resolved resource / name. */
   readonly ref: string;
@@ -103,9 +105,20 @@ const READ_METHODS = new Set([
   "findMany",
   "findFirst",
   "find",
+  "list",
 ]);
 
-const WRITE_METHODS = new Set(["insert", "set", "delete", "increment", "update", "upsert", "log"]);
+const WRITE_METHODS = new Set([
+  "insert",
+  "set",
+  "delete",
+  "increment",
+  "update",
+  "upsert",
+  "log",
+  "put",
+  "putImage",
+]);
 
 /** Methods whose first argument is a table / collection identifier. */
 const TABLE_ARG_METHODS = new Set([
@@ -203,7 +216,7 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       // Skip incomplete chains (`select` before `.from`, `insert` before table) —
       // the sibling call that carries the table arg records the real resource.
       const leaf = resolved.methods[resolved.methods.length - 1]!;
-      const hasTable = tableFromStoreChain(call) !== undefined;
+      const hasTable = tableFromStoreChain(call, options.bindings) !== undefined;
       if (!hasTable && (leaf === "select" || leaf === "insert" || leaf === "update")) {
         continue;
       }
@@ -352,11 +365,14 @@ export function storeResourceFromCall(
   const storeBinding = resolveBinding(storeArg, bindings);
   const facet = storeBinding?.facet ?? "sql";
 
-  const table = tableFromStoreChain(call);
+  const table = tableFromStoreChain(call, bindings);
 
   if (table) {
     return {
-      resource: `${facet}:${table}` as ResourceRef,
+      // sql:<table> is the shared naming convention with the kernel's
+      // runtime capability gate (see ../manifest/sql-resource.ts) — table
+      // args only ever occur on sql-facet methods in practice.
+      resource: (facet === "sql" ? sqlTableRef(table) : `${facet}:${table}`) as ResourceRef,
       methods: chain.methods,
     };
   }
@@ -382,11 +398,21 @@ export function storeResourceFromCall(
 }
 
 /**
- * Walk an `fx.store(…).a().b(table)` chain and return the table identifier.
+ * Walk an `fx.store(…).a().b(table)` chain and return the declared table
+ * name — resolved through a registered `table` binding (the real string
+ * passed to `store.schema.table(name, …)`) when the argument is one, so a
+ * JS binding named differently from its declared table (`const notesTable
+ * = store.schema.table("notes", …)`) still resolves to `"notes"`, matching
+ * what the kernel reads off the live table object at call time. Falls back
+ * to the raw identifier text otherwise.
  *
  * @param call - Any call in the chain
+ * @param bindings - Scope bindings
  */
-function tableFromStoreChain(call: CallExpression): string | undefined {
+function tableFromStoreChain(
+  call: CallExpression,
+  bindings: ReadonlyMap<string, InferBinding>,
+): string | undefined {
   let current: AstNode | undefined = call;
   while (current && current.type === "CallExpression") {
     const c = current as CallExpression;
@@ -394,8 +420,11 @@ function tableFromStoreChain(call: CallExpression): string | undefined {
     if (!link || link.rootMethod !== "store") break;
     const leaf = link.methods[link.methods.length - 1]!;
     if (TABLE_ARG_METHODS.has(leaf)) {
-      const table = identifierName(c.arguments[0]);
-      if (table) return table;
+      const id = identifierName(c.arguments[0]);
+      if (id) {
+        const binding = bindings.get(id);
+        return binding?.kind === "table" ? binding.ref : id;
+      }
     }
     const callee = c.callee;
     if (callee.type === "MemberExpression") {

package/src/compiler/extract.test.ts

@@ -123,8 +123,7 @@ describe("extractManifest — performance", () => {
       parts.push(`
 export const flow_${i} = on(
   http.get("/f/${i}"),
-  flow({
-    name: "synth.flow_${i}",
+  flow("synth.flow_${i}", {
     do: async (input, fx) => {
       await fx.store(db).insert(items).values(input);
       const rows = await fx.store(db).select().from(items);
@@ -166,8 +165,7 @@ export const daily = { name: "daily" };
 
 export const listLinks = on(
   http.get("/links"),
-  flow({
-    name: "rel.root",
+  flow("rel.root", {
     do: async (_input, fx) => {
       return fx.store(db).select().from(links);
     },
@@ -178,8 +176,7 @@ export const listLinks = on(
 // relations, so the related table must NOT appear in effects.
 export const withDaily = on(
   http.get("/links/with-daily"),
-  flow({
-    name: "rel.with",
+  flow("rel.with", {
     do: async (_input, fx) => {
       return fx.store(db).findMany({ with: { daily: true } });
     },
@@ -344,3 +341,186 @@ export const remove = mounted.remove;
     expect(manifest.flows?.list?.breaking).toBe(true);
   });
 });
+
+describe("extractManifest — files-store write methods", () => {
+  test("fx.store(files).put(...) infers a write, unannotated", async () => {
+    const source = `
+import { on, flow, http, gate, store } from "okengine";
+
+export const files = store.files("uploads");
+
+export const attach = on(
+  http.post("/attach").gate(gate.public),
+  flow("notes.attach", {
+    do: async (input, fx) => {
+      await fx.store(files).put("key", input.text);
+      return { ok: true };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/attach.ts": source });
+
+    expect(manifest.flows?.["notes.attach"]?.effects?.writes).toEqual(["files:uploads"]);
+  });
+
+  test("fx.store(files).putImage(...) infers a write, unannotated", async () => {
+    const source = `
+import { on, flow, http, gate, store } from "okengine";
+
+export const files = store.files("uploads");
+
+export const attach = on(
+  http.post("/attach").gate(gate.public),
+  flow("notes.attachImage", {
+    do: async (input, fx) => {
+      await fx.store(files).putImage("key", input.bytes);
+      return { ok: true };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/attach.ts": source });
+
+    expect(manifest.flows?.["notes.attachImage"]?.effects?.writes).toEqual(["files:uploads"]);
+  });
+
+  test("fx.store(files).list(...) infers a read, unannotated", async () => {
+    const source = `
+import { on, flow, every, store } from "okengine";
+
+export const files = store.files("uploads");
+
+export const sweep = on(
+  every("1d"),
+  flow("notes.sweep", {
+    do: async (_input, fx) => {
+      const keys = await fx.store(files).list();
+      return { count: keys.length };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/sweep.ts": source });
+
+    expect(manifest.flows?.["notes.sweep"]?.effects?.reads).toEqual(["files:uploads"]);
+  });
+});
+
+describe("extractManifest — channel medium binder aliasing", () => {
+  test("mail.template(...) resolves through `const mail = channel.email(...)`", async () => {
+    const source = `
+import { on, flow, http, gate, channel } from "okengine";
+
+const mail = channel.email({ from: "Notes <notes@localhost>" });
+
+export const noteCreatedMail = mail.template("note-created", {
+  locales: ["en", "ar"],
+});
+
+export const onCreated = on(
+  http.post("/hook").gate(gate.public),
+  flow("notes.onCreated", {
+    do: async (payload, fx) => {
+      await fx.send(noteCreatedMail, { to: "you@localhost", data: payload });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/notes.ts": source });
+
+    expect(manifest.flows?.["notes.onCreated"]?.effects?.sends).toEqual(["note-created"]);
+    expect(manifest.channels?.["note-created"]?.medium).toBe("email");
+  });
+
+  test("sms medium binder alias carries its medium (not defaulted to email)", async () => {
+    const source = `
+import { on, flow, http, gate, channel } from "okengine";
+
+const otp = channel.sms({});
+
+export const otpTemplate = otp.template("otp-code", {});
+
+export const send = on(
+  http.post("/otp").gate(gate.public),
+  flow("notes.sendOtp", {
+    do: async (payload, fx) => {
+      await fx.send(otpTemplate, { to: "+10000000000", data: payload });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/otp.ts": source });
+
+    expect(manifest.flows?.["notes.sendOtp"]?.effects?.sends).toEqual(["otp-code"]);
+    expect(manifest.channels?.["otp-code"]?.medium).toBe("sms");
+  });
+});
+
+describe("extractManifest — flow(name, options) positional signature", () => {
+  test("bare flow(name, {...}) extracts name, in, out, effects", async () => {
+    const source = `
+import { flow } from "okengine";
+
+export const chargeOrder = flow("checkout.chargeOrder", {
+  in: ChargeIn,
+  out: ChargeOut,
+  effects: { reads: ["sql:orders"], writes: ["sql:orders"] },
+  do: async (input, fx) => {
+    return { ok: true };
+  },
+});
+`;
+    const manifest = await extractFromSources({ "src/flows/checkout.ts": source });
+
+    expect(manifest.flows?.["checkout.chargeOrder"]).toBeDefined();
+    expect(manifest.flows?.["checkout.chargeOrder"]?.in).toBeDefined();
+    expect(manifest.flows?.["checkout.chargeOrder"]?.out).toBeDefined();
+    expect(manifest.flows?.["checkout.chargeOrder"]?.effects?.reads).toEqual(["sql:orders"]);
+    expect(manifest.flows?.["checkout.chargeOrder"]?.effects?.writes).toEqual(["sql:orders"]);
+  });
+
+  test("on(trigger, flow(name, {...})) extracts the same shape as bare flow()", async () => {
+    const source = `
+import { on, http, flow } from "okengine";
+
+export const getOrder = on(
+  http.get("/orders/:id"),
+  flow("checkout.getOrder", {
+    out: OrderOut,
+    effects: { reads: ["sql:orders"] },
+    do: async (input, fx) => {
+      return { id: input.id };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/checkout.ts": source });
+
+    expect(manifest.flows?.["checkout.getOrder"]).toBeDefined();
+    expect(manifest.flows?.["checkout.getOrder"]?.trigger?.http?.method).toBe("GET");
+    expect(manifest.flows?.["checkout.getOrder"]?.out).toBeDefined();
+    expect(manifest.flows?.["checkout.getOrder"]?.effects?.reads).toEqual(["sql:orders"]);
+  });
+
+  test("a stray `name:` key inside the options object is ignored — the positional arg wins", async () => {
+    // Regression guard for the exact class of AST-shape assumption that broke
+    // silently before (channel-alias tracking, `.put()` inference): the
+    // compiler must read the flow's identity from the first positional
+    // argument, never from a `name` property on the options object, even
+    // when one happens to be present.
+    const source = `
+import { flow } from "okengine";
+
+export const decoy = flow("checkout.realName", {
+  name: "checkout.decoyName",
+  effects: { reads: ["sql:orders"] },
+  do: async () => ({ ok: true }),
+});
+`;
+    const manifest = await extractFromSources({ "src/flows/checkout.ts": source });
+
+    expect(manifest.flows?.["checkout.realName"]).toBeDefined();
+    expect(manifest.flows?.["checkout.decoyName"]).toBeUndefined();
+  });
+});

package/src/compiler/extract.ts

@@ -14,6 +14,7 @@ import type {
   AiModel,
   AiPrompt,
   Channel,
+  ChannelMedium,
   Clock,
   DeclaredColumn,
   Effects,
@@ -94,6 +95,8 @@ interface ProjectScope {
     string,
     { storeName: string; storeRef: string; unit?: string; breaking?: boolean }
   >;
+  /** Local binding name → medium, for `const x = channel.email(…)` binders. */
+  channelMediumBindings: Map<string, ChannelMedium>;
 }
 
 /**
@@ -123,6 +126,7 @@ export async function extractManifest(options: ExtractManifestOptions = {}): Pro
     flows: {},
     flowExports: new Map(),
     resources: new Map(),
+    channelMediumBindings: new Map(),
   };
 
   const parsed = files.map((file) => {
@@ -329,7 +333,14 @@ function collectSchemaTable(call: CallExpression, program: AstNode, scope: Proje
   const entry = { name: tableName, columns };
   scope.schemaTables.set(tableName, entry);
   const bindingName = enclosingConstName(call, program);
-  if (bindingName) scope.schemaTables.set(bindingName, entry);
+  if (bindingName) {
+    scope.schemaTables.set(bindingName, entry);
+    // Declared table name, not the JS binding — resolved by
+    // tableFromStoreChain so `const notesTable = store.schema.table("notes",
+    // …)` still infers "sql:notes", matching what the kernel reads off the
+    // live table object (see ../manifest/sql-resource.ts).
+    scope.bindings.set(bindingName, { kind: "table", ref: tableName });
+  }
 }
 
 function attachSchemaOption(
@@ -584,6 +595,8 @@ function camelToSnakeKey(key: string): string {
     .toLowerCase();
 }
 
+const CHANNEL_MEDIUM_METHODS = new Set(["email", "sms", "whatsapp", "push"]);
+
 function visitDeclarationCall(call: CallExpression, program: AstNode, scope: ProjectScope): void {
   const callee = call.callee;
 
@@ -718,7 +731,17 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
       }
     }
 
-    if (obj === "channel" && prop === "template") {
+    // channel.email(…) / .sms(…) / .whatsapp(…) / .push(…) — medium binder,
+    // usually held in a local const and called later as `mail.template(…)`.
+    if (obj === "channel" && prop && CHANNEL_MEDIUM_METHODS.has(prop)) {
+      const bindingName = enclosingConstName(call, program);
+      if (bindingName) {
+        scope.channelMediumBindings.set(bindingName, prop as ChannelMedium);
+      }
+    }
+
+    const boundMedium = obj ? scope.channelMediumBindings.get(obj) : undefined;
+    if ((obj === "channel" && prop === "template") || (prop === "template" && boundMedium)) {
       const templateName = stringArg(call.arguments[0]);
       const opts = objectArg(call.arguments[1]);
       if (templateName) {
@@ -726,7 +749,9 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
         const locales = stringArrayProp(opts, "locales");
         const description = stringProp(opts, "description");
         scope.channels[templateName] = {
-          ...(medium ? { medium: medium as Channel["medium"] } : { medium: "email" }),
+          ...(medium
+            ? { medium: medium as Channel["medium"] }
+            : { medium: boundMedium ?? "email" }),
           ...(locales ? { locales } : {}),
           ...(description ? { description } : {}),
         };
@@ -1134,11 +1159,11 @@ function registerFlow(args: {
   scope: ProjectScope;
   exportName: string | undefined;
 }): void {
-  const opts = objectArg(args.flowCall.arguments[0]);
+  const opts = objectArg(args.flowCall.arguments[1]);
   if (!opts) return;
 
   const name =
-    stringProp(opts, "name") ??
+    stringArg(args.flowCall.arguments[0]) ??
     args.exportName ??
     `flow_${Object.keys(args.scope.flows).length + 1}`;
 
@@ -1207,7 +1232,7 @@ function registerFlow(args: {
   const errors = parseErrors(objectProp(opts, "errors"));
   if (errors) flow.errors = errors;
 
-  if (effects && Object.keys(effects).length > 0) flow.effects = effects;
+  if (effects) flow.effects = effects;
 
   const line = lineAt(args.file.source, args.flowCall.start ?? 0);
   flow.source = `${args.file.path}:${line}`;

package/src/compiler/fixtures/raw/raw-unannotated.ts

@@ -5,8 +5,7 @@ import { on, flow, http } from "okengine";
  */
 export const escapeHatch = on(
   http.get("/raw"),
-  flow({
-    name: "raw.unannotated",
+  flow("raw.unannotated", {
     do: async (_, fx) => {
       return fx.raw("select 1");
     },
@@ -18,8 +17,7 @@ export const escapeHatch = on(
  */
 export const annotated = on(
   http.get("/raw-ok"),
-  flow({
-    name: "raw.annotated",
+  flow("raw.annotated", {
     effects: { reads: ["sql:orders"] },
     do: async (_, fx) => {
       return fx.raw("select * from orders");

package/src/compiler/fixtures/skyport/src/flows/bookings/index.ts

@@ -15,8 +15,7 @@ void 0;
 
 export const create = on(
   http.post("/bookings").gate(member, canBook, fair),
-  flow({
-    name: "bookings.create",
+  flow("bookings.create", {
     in: BookingIn,
     out: BookingOut,
     errors: { FlightFull },
@@ -35,8 +34,7 @@ export const create = on(
 
 export const mine = on(
   http.get("/bookings").gate(member).live(),
-  flow({
-    name: "bookings.mine",
+  flow("bookings.mine", {
     live: true,
     do: (_, fx) =>
       fx
@@ -47,13 +45,11 @@ export const mine = on(
   }),
 );
 
-export const getBooking = flow({
-  name: "bookings.getBooking",
+export const getBooking = flow("bookings.getBooking", {
   do: ({ id }, fx) => fx.store(db).findById(bookings, id),
 });
 
-export const refundBooking = flow({
-  name: "bookings.refundBooking",
+export const refundBooking = flow("bookings.refundBooking", {
   do: async ({ id }, fx) => {
     await fx.store(db).update(bookings).set({ status: "refunded" }).where({ id });
     return fx.store(db).findById(bookings, id);

package/src/compiler/fixtures/skyport/src/flows/payments/index.ts

@@ -1,8 +1,7 @@
 import { flow } from "okengine";
 import { stripeKey } from "../../vault.ts";
 
-export const chargeBooking = flow({
-  name: "payments.chargeBooking",
+export const chargeBooking = flow("payments.chargeBooking", {
   durable: true,
   do: async ({ orderId }, fx) => {
     // Journal only serializable step values — a Redacted is not journaled.

package/src/compiler/fixtures/skyport/src/flows/support/index.ts

@@ -6,8 +6,7 @@ import { tickets } from "../../schema.ts";
 
 export const createTicket = on(
   http.post("/tickets").gate(member),
-  flow({
-    name: "support.createTicket",
+  flow("support.createTicket", {
     pii: "masked",
     cost: { estimatePerCall: 0.011, budget: 0.02 },
     do: async (input, fx) => {

package/src/compiler/fixtures/skyport.expected.json

@@ -32,7 +32,7 @@
       "effects": {
         "reads": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:50"
+      "source": "src/flows/bookings/index.ts:48"
     },
     "bookings.mine": {
       "trigger": {
@@ -45,7 +45,7 @@
       "effects": {
         "reads": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:38",
+      "source": "src/flows/bookings/index.ts:37",
       "live": true,
       "cacheKeys": "computed:sql:bookings/userId"
     },
@@ -54,7 +54,7 @@
         "reads": ["sql:bookings"],
         "writes": ["sql:bookings"]
       },
-      "source": "src/flows/bookings/index.ts:55"
+      "source": "src/flows/bookings/index.ts:52"
     },
     "payments.chargeBooking": {
       "effects": {

package/src/compiler/fixtures/triggers/five-triggers.ts

@@ -16,8 +16,7 @@ export const linkClicked = signal("link-clicked", {
 // ① HTTP
 export const create = on(
   http.post("/orders"),
-  flow({
-    name: "triggers.http",
+  flow("triggers.http", {
     do: async (input, fx) => {
       await fx.store(db).insert(orders).values(input);
       return { ok: true };
@@ -28,8 +27,7 @@ export const create = on(
 // ② CLOCK / every
 on(
   every("10m"),
-  flow({
-    name: "triggers.every",
+  flow("triggers.every", {
     do: (_, fx) => fx.store(db).delete(links).where({ createdAt: 0 }),
   }),
 );
@@ -37,8 +35,7 @@ on(
 // ③ SIGNAL
 on(
   linkClicked,
-  flow({
-    name: "triggers.signal",
+  flow("triggers.signal", {
     do: async ({ code }, fx) => {
       const clicks = await fx.store(db).increment(links, code, "clicks");
       await fx.emit(linkClicked, { code, clicks });
@@ -49,8 +46,7 @@ on(
 // ④ CDC
 on(
   table("orders").changed("status"),
-  flow({
-    name: "triggers.cdc",
+  flow("triggers.cdc", {
     do: ({ before, after }, fx) => fx.store(db).insert(orders).values({ before, after }),
   }),
 );
@@ -58,8 +54,7 @@ on(
 // ⑤ INTERNAL / call-only
 export const stats = on(
   internal,
-  flow({
-    name: "triggers.internal",
+  flow("triggers.internal", {
     do: async ({ code }, fx) => {
       const [row] = await fx.store(db).select().from(links).where({ code });
       return row?.clicks ?? 0;

package/src/compiler/generate-adopt.test.ts

@@ -0,0 +1,85 @@
+/**
+ * `.adopt()` barrel generator — real filesystem before/after proofs.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { generateAdoptBarrel } from "./generate-adopt.ts";
+
+async function makeUnit(root: string, name: string, withIndex = true): Promise<void> {
+  const dir = join(root, "src/flows", name);
+  await mkdir(dir, { recursive: true });
+  if (withIndex) await writeFile(join(dir, "index.ts"), "export const nothing = 1;\n");
+}
+
+describe("generateAdoptBarrel", () => {
+  test("emits one `export * as <unit>` per flows folder with an index.ts barrel", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      await makeUnit(root, "notes");
+      await makeUnit(root, "main");
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.units).toEqual(["main", "notes"]);
+      expect(result.source).toContain('export * as main from "./main/index.ts";');
+      expect(result.source).toContain('export * as notes from "./notes/index.ts";');
+      expect(result.skipped).toEqual([]);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("skips a unit folder with no index.ts barrel (never crashes)", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      await makeUnit(root, "notes");
+      await makeUnit(root, "scratch", false);
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.units).toEqual(["notes"]);
+      expect(result.skipped).toEqual(["scratch"]);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("missing flows directory yields an empty barrel, never throws", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.units).toEqual([]);
+      expect(result.source).toContain("AUTO-GENERATED");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("real before/after: generated barrel matches the hand-written form it replaces", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
+    try {
+      await mkdir(join(root, "src/flows/main"), { recursive: true });
+      await mkdir(join(root, "src/flows/notes"), { recursive: true });
+      await writeFile(join(root, "src/flows/main/index.ts"), 'export const root = "main-flow";\n');
+      await writeFile(
+        join(root, "src/flows/notes/index.ts"),
+        'export const create = "notes-flow";\n',
+      );
+      const result = await generateAdoptBarrel({ rootDir: root });
+      const generatedPath = join(root, "src/flows/generated.ts");
+      await writeFile(generatedPath, result.source);
+
+      // Same shape as `import * as main from "./flows/main"; import * as
+      // notes from "./flows/notes"; .adopt({ main, notes })` — a namespace
+      // object keyed by unit, one key per flows folder, real modules loaded.
+      const generatedModule = (await import(generatedPath)) as {
+        main: { root: string };
+        notes: { create: string };
+      };
+      expect(Object.keys(generatedModule).sort()).toEqual(["main", "notes"]);
+      expect(generatedModule.main.root).toBe("main-flow");
+      expect(generatedModule.notes.create).toBe("notes-flow");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});