okengine 0.10.1 → 0.10.3

package/src/kernel/boot.test.ts

@@ -79,7 +79,7 @@ describe("boot — lazy element needs", () => {
     expect(needs.signal).toBe(false);
   });
 
-  test("oke() Store-only graph stays under the prior 54 kB baseline", async () => {
+  test("oke() Store-only graph stays under the prior 54.3 kB baseline", async () => {
     const dir = await mkdtemp(join(tmpdir(), "oke-store-only-"));
     const entry = join(dir, "entry.ts");
     const appPath = join(import.meta.dir, "app.ts");
@@ -120,8 +120,18 @@ describe("boot — lazy element needs", () => {
       // gzip), durable-journal lease surface (~51.2 kB), fx.deliverOtp +
       // unified otp() (~50.9 kB → 53 kB), then fx.runs / SLO window on the
       // shared surface (~53.3 kB → 54 kB cap). Clock/channel/journal drivers
-      // stay lazy-bound; far below eager bind.
-      expect(total).toBeLessThan(54_000);
+      // stay lazy-bound; far below eager bind. Rebased again for the
+      // store/vault/signal/channel auto-registry drain (`element-registries.ts`
+      // + the `oke()` merge/dedup logic) — every app now carries this
+      // regardless of which elements it uses, since the drain must run
+      // synchronously at construction (same isolation guarantee as the
+      // `on()` binding registry) and can't be deferred behind a lazy import
+      // (~54.0 kB → 54.3 kB cap). Rebased again for `assertAdoptBarrelFresh`
+      // + `tryListFlowsUnits` in `boot.ts` (`.adopt()` barrel staleness
+      // check, OKE1009) — part of the already-lazily-loaded boot graph, not
+      // the `oke()` construction path, but `Bun.build` still traces and
+      // sums the dynamic-import chunk (~54.3 kB → 54.7 kB cap).
+      expect(total).toBeLessThan(54_700);
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
@@ -130,8 +140,7 @@ describe("boot — lazy element needs", () => {
 
 describe("boot — capabilities from Manifest effects", () => {
   test("tokens cover declared effects only", async () => {
-    const charge = flow({
-      name: "payments.charge",
+    const charge = flow("payments.charge", {
       effects: { secrets: ["STRIPE_KEY"], writes: ["sql:orders"] },
       do: () => ({ ok: true }),
     });
@@ -158,8 +167,7 @@ describe("boot — cron fires without manual dispatch", () => {
     let ran = 0;
     on(
       every("1h"),
-      flow({
-        name: "cleanup.expire",
+      flow("cleanup.expire", {
         do: () => {
           ran += 1;
         },
@@ -200,8 +208,7 @@ describe("boot — HTTP gate wiring on the default path", () => {
     resetFlowSeq();
     on(
       http.get("/ping"),
-      flow({
-        name: "ping",
+      flow("ping", {
         do: () => ({ ok: true }),
       }),
     );
@@ -217,8 +224,7 @@ describe("boot — HTTP gate wiring on the default path", () => {
     const { GateBootError } = await import("../elements/gate/boot.ts");
     on(
       http.get("/ping"),
-      flow({
-        name: "ping",
+      flow("ping", {
         do: () => ({ ok: true }),
       }),
     );
@@ -235,8 +241,7 @@ describe("boot — HTTP gate wiring on the default path", () => {
     const { gate } = await import("../elements/gate.ts");
     on(
       http.get("/ping").gate(gate.public),
-      flow({
-        name: "ping-public",
+      flow("ping-public", {
         do: () => ({ ok: true }),
       }),
     );
@@ -261,8 +266,7 @@ describe("boot — cron autostart via real timer loop", () => {
     let ran = 0;
     on(
       every("10m"),
-      flow({
-        name: "cleanup.autostart",
+      flow("cleanup.autostart", {
         do: () => {
           ran += 1;
         },

package/src/kernel/boot.ts

@@ -285,7 +285,7 @@ export async function bootApplication(input: BootOptions = {}): Promise<BootResu
     input.docker === true || (input.docker !== false && process.env.OKE_DOCKER === "1");
   // `-d` always selects the `docker` driver profile — not a mix of local/test +
   // prod store overrides when `$options.env` is unset.
-  const env: ConfigEnv = docker ? "docker" : (input.env ?? "local");
+  const env: ConfigEnv = input.env ?? (docker ? "docker" : "local");
   let config = input.config;
   if (config === undefined) {
     try {
@@ -484,6 +484,11 @@ export async function bootApplication(input: BootOptions = {}): Promise<BootResu
     rootDir: options.rootDir,
   });
 
+  // 9. `.adopt()` barrel freshness — opt-in only (same `rootDir` gate as
+  // capability minting above; never a filesystem read the kernel performs
+  // on its own).
+  await assertAdoptBarrelFresh(options.flows ?? [], env, options.rootDir);
+
   return {
     vault,
     store,
@@ -603,6 +608,81 @@ export async function mintCapabilities(
   return map;
 }
 
+/** Per-process guard so the stale-barrel boot warning fires once. */
+let staleAdoptBarrelWarned = false;
+
+/** Reset the once-per-process stale-barrel warn latch (tests only). */
+export function resetStaleAdoptBarrelWarnForTests(): void {
+  staleAdoptBarrelWarned = false;
+}
+
+/**
+ * Best-effort disk scan for `<rootDir>/src/flows/*` unit folders — mirrors
+ * {@link tryAutoExtractManifest}'s lazy, defensive, never-throws posture and
+ * the same `new URL` trick so the generator never enters the bundler graph
+ * for apps that never opt into `rootDir`.
+ *
+ * @param rootDir - Project root to scan
+ */
+async function tryListFlowsUnits(rootDir: string): Promise<readonly string[] | undefined> {
+  try {
+    const url = new URL("../compiler/generate-adopt.ts", import.meta.url);
+    const { generateAdoptBarrel } = (await import(
+      url.href
+    )) as typeof import("../compiler/generate-adopt.ts");
+    return (await generateAdoptBarrel({ rootDir })).units;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Confirm every `src/flows/<unit>` folder on disk actually reached this
+ * boot's adopted flows — the disk-file counterpart of a stale/missing
+ * generated `.adopt()` barrel (`src/flows/generated.ts`). A folder present
+ * on disk with zero adopted flows under that unit means the barrel wasn't
+ * regenerated (or was hand-edited) after the folder was added.
+ *
+ * Opt-in only via {@link BootOptions.rootDir} / `OKE_ROOT_DIR` (same gate as
+ * {@link mintCapabilities}'s Manifest fallback) — never a filesystem read
+ * the kernel performs on its own. `local` / `test` warn once per process;
+ * `docker` / `prod` fail loud (`OKE1009`) — same class as `NO_EFFECTS_DECLARED`,
+ * never a silently-incomplete route table in a deploy-shaped environment.
+ *
+ * @param flows - Adopted flows
+ * @param env - Resolved {@link ConfigEnv}
+ * @param rootDir - Explicit project root (falls back to `OKE_ROOT_DIR`)
+ */
+export async function assertAdoptBarrelFresh(
+  flows: readonly AnyFlowDef[],
+  env: ConfigEnv = "local",
+  rootDir?: string,
+): Promise<void> {
+  const dir = rootDir ?? process.env["OKE_ROOT_DIR"];
+  if (!dir) return;
+
+  const diskUnits = await tryListFlowsUnits(dir);
+  if (diskUnits === undefined || diskUnits.length === 0) return;
+
+  const adoptedUnits = new Set(
+    flows.map((f) => f.unit).filter((u): u is string => u !== undefined),
+  );
+  const missing = diskUnits.filter((u) => !adoptedUnits.has(u));
+  if (missing.length === 0) return;
+
+  if (env === "docker" || env === "prod") {
+    throwOke("ADOPT_BARREL_STALE", { unit: missing[0]! });
+  }
+  if (!staleAdoptBarrelWarned) {
+    staleAdoptBarrelWarned = true;
+    emitBootWarn(
+      `oke boot: src/flows/${missing[0]} exists on disk but adopted no flows — the ` +
+        '.adopt() barrel ("src/flows/generated.ts") is stale. Run `oke dev` or `oke build` ' +
+        "to regenerate it — docker/prod refuse to boot this way.",
+    );
+  }
+}
+
 function isRunsRuntime(value: RunsRuntime | CreateRunsRuntimeOptions): value is RunsRuntime {
   return (
     typeof value === "object" &&

package/src/kernel/call.test.ts

@@ -11,15 +11,13 @@ beforeEach(() => {
 
 describe("fx.call — untriggered flows", () => {
   test("untriggered flow is callable via app.call and fx.call", async () => {
-    const stats = flow({
-      name: "links.stats",
+    const stats = flow("links.stats", {
       do: ({ code }: { code: string }) => ({ code, clicks: 7 }),
     });
 
     const parent = on(
       http.post("/run"),
-      flow({
-        name: "links.run",
+      flow("links.run", {
         effects: { calls: ["links.stats"] },
         do: async ({ code }: { code: string }, fx) => {
           const result = await fx.call("links.stats", { code });
@@ -54,8 +52,7 @@ describe("fx.call — untriggered flows", () => {
   });
 
   test("fx.call propagates fx.principal without filling fx.auth", async () => {
-    const audit = flow({
-      name: "audit.log",
+    const audit = flow("audit.log", {
       do: (_input: { event: string }, fx) => ({
         authUserId: fx.auth.userId,
         principalUserId: fx.principal.userId,
@@ -65,8 +62,7 @@ describe("fx.call — untriggered flows", () => {
 
     const act = on(
       http.post("/act"),
-      flow({
-        name: "act",
+      flow("act", {
         effects: { calls: ["audit.log"] },
         do: async (_input: Record<string, never>, fx) => {
           return fx.call("audit.log", { event: "act" });
@@ -99,8 +95,7 @@ describe("fx.call — untriggered flows", () => {
 
   test("http and signal invocations of the same flow execute identically", async () => {
     let runs = 0;
-    const work = flow({
-      name: "work",
+    const work = flow("work", {
       do: (input: { v: number }) => {
         runs += 1;
         return { out: input.v + 1 };

package/src/kernel/compensate.test.ts

@@ -24,8 +24,7 @@ describe("durable compensate", () => {
     const store = createMemoryJournalStore();
     const undos: string[] = [];
 
-    const pay = flow({
-      name: "pay.charge",
+    const pay = flow("pay.charge", {
       durable: true,
       do: async (_input: { amount: number }, fx) => {
         await fx.step("reserve", async () => "reserved");
@@ -72,8 +71,7 @@ describe("durable compensate", () => {
   test("compensate does not run on successful path", async () => {
     let compensated = 0;
     const store = createMemoryJournalStore();
-    const ok = flow({
-      name: "pay.ok",
+    const ok = flow("pay.ok", {
       durable: true,
       do: async (_input, fx) => {
         await fx.step("a", () => "done");
@@ -103,8 +101,7 @@ describe("durable compensate", () => {
     await runs.open();
     const store = createMemoryJournalStore();
 
-    const boom = flow({
-      name: "pay.boom",
+    const boom = flow("pay.boom", {
       durable: true,
       do: async () => {
         throw new Error("boom");

package/src/kernel/concurrency.test.ts

@@ -218,8 +218,7 @@ describe("retry + durable journal", () => {
     let attempts = 0;
     let crash = true;
 
-    const f = flow({
-      name: "pay.retry",
+    const f = flow("pay.retry", {
       durable: true,
       do: async (_input, fx) => {
         const charged = await fx.step("charge", () =>
@@ -250,13 +249,12 @@ describe("retry + durable journal", () => {
     expect(attempts).toBe(1);
   });
 
-  test("flow({ retry }) reuses journal — completed steps do not re-run", async () => {
+  test("flow(name, { retry }) reuses journal — completed steps do not re-run", async () => {
     const journalStore = createMemoryJournalStore();
     const calls: string[] = [];
     let failOnce = true;
 
-    const f = flow({
-      name: "flow.retry",
+    const f = flow("flow.retry", {
       durable: true,
       retry: { retries: 2, delay: 0, jitter: false },
       do: async (_input, fx) => {

package/src/kernel/correlation.test.ts

@@ -17,8 +17,7 @@ describe("correlation — parentId across Flow → Signal → Flow", () => {
     const runs = createRunsRuntime({ driver: "memory" });
     await runs.open();
 
-    const producer = flow({
-      name: "orders.create",
+    const producer = flow("orders.create", {
       effects: { emits: ["corr-order-placed"] },
       do: async (input: { id: string }, fx) => {
         await fx.emit(orderPlaced, { id: input.id });
@@ -26,8 +25,7 @@ describe("correlation — parentId across Flow → Signal → Flow", () => {
       },
     });
 
-    const consumer = flow({
-      name: "orders.notify",
+    const consumer = flow("orders.notify", {
       do: async (_input: { id: string }) => ({ notified: true as const }),
     });
 
@@ -72,13 +70,11 @@ describe("correlation — parentId across Flow → Signal → Flow", () => {
     const runs = createRunsRuntime({ driver: "memory" });
     await runs.open();
 
-    const child = flow({
-      name: "inner.work",
+    const child = flow("inner.work", {
       do: () => ({ done: true as const }),
     });
 
-    const parent = flow({
-      name: "outer.work",
+    const parent = flow("outer.work", {
       effects: { calls: ["inner.work"] },
       do: async (_input, fx) => {
         await fx.call(child, {});

package/src/kernel/edge.test.ts

@@ -19,7 +19,7 @@ beforeEach(() => {
 
 describe("plugin edge handlers", () => {
   test("an edge handler answers an unmatched request; the flow still owns matched ones", async () => {
-    on(http.get("/x"), flow({ name: "x.get", do: () => ({ ok: true }) }));
+    on(http.get("/x"), flow("x.get", { do: () => ({ ok: true }) }));
     const edge = plugin("edge-test", { version: "0.0.1" }).edge((_request, info) => {
       if (info.method === "OPTIONS") {
         return new Response(null, { status: 204, headers: { "x-edge": "yes" } });

package/src/kernel/effects-stamping.test.ts

@@ -2,7 +2,7 @@
  * Boot-level proof: compiled/inferred effects reaching a REAL running app's
  * capability token — not an isolated compiler-only or kernel-only test.
  *
- * Before this file existed, `flow({...})` with no hand-declared `effects`
+ * Before this file existed, `flow(name, {...})` with no hand-declared `effects`
  * always minted an OPEN capability token (every access allowed, no gate at
  * all) in every environment, including `docker` / `prod` — `extractManifest`
  * inference only ever fed the static `manifest.oke.json` artifact (Console,
@@ -48,8 +48,7 @@ const CreateOut = z.object({ ok: z.boolean() });
 function buildUnannotatedCreateFlow(db: ReturnType<typeof store.sql>) {
   return on(
     http.post("/notes").gate(gate.public),
-    flow({
-      name: "notes.create",
+    flow("notes.create", {
       in: CreateIn,
       out: CreateOut,
       // Deliberately no `effects` — the "let the compiler infer it" case.
@@ -117,8 +116,7 @@ describe("boot-level: table-ref resolution stays backward compatible", () => {
     const db = store.sql("app", { schema: { notes } });
     const create = on(
       http.post("/notes").gate(gate.public),
-      flow({
-        name: "notes.create",
+      flow("notes.create", {
         in: CreateIn,
         out: CreateOut,
         // The convention every template/test predates Direction B with —
@@ -171,8 +169,7 @@ const db = {} as any;
 const notes = {} as any;
 export const create = on(
   http.post("/notes").gate(gate.public),
-  flow({
-    name: "notes.create",
+  flow("notes.create", {
     do: async (input, fx) => {
       await fx.store(db).insert(notes).values({ id: input.id, title: input.title, createdAt: 1 });
       return { ok: true };

package/src/kernel/element-registries.ts

@@ -0,0 +1,27 @@
+/**
+ * Module-evaluation registries for `store.sql` / `store.files`, `vault.secret`,
+ * `signal()`, and `channel.<medium>().template()` — the plain arrays behind
+ * each declare module's `listX()` / `resetX()` pair (mirrors `on.ts`'s
+ * trigger-drain `bindings` array).
+ *
+ * Lives here, not in the declare modules themselves, so {@link oke} can read
+ * every registry with one lightweight import instead of statically pulling
+ * in all four element `declare.ts` modules (and every unrelated export they
+ * carry) into every app's bundle — see the `oke()` Store-only bundle-size
+ * budget in `boot.test.ts`. Only type imports cross back to the declare
+ * modules, so this file has zero runtime dependencies of its own.
+ */
+
+import type { StoreDecl } from "../elements/store/declare.ts";
+import type { VaultSecretDecl } from "../elements/vault/declare.ts";
+import type { SignalDecl } from "../elements/signal/declare.ts";
+import type { ChannelTemplateDecl } from "../elements/channel/declare.ts";
+
+/** `store.sql` / `store.files` declarations since the last reset. */
+export const storeRegistry: StoreDecl[] = [];
+/** `vault.secret` declarations since the last reset. */
+export const secretRegistry: VaultSecretDecl[] = [];
+/** `signal()` declarations since the last reset. */
+export const signalRegistry: SignalDecl[] = [];
+/** Medium-binder `.template()` declarations since the last reset. */
+export const channelTemplateRegistry: ChannelTemplateDecl[] = [];

package/src/kernel/errors.ts

@@ -153,6 +153,17 @@ export const OKE_ERRORS = {
       "Add explicit `effects` to this flow, or boot with a Manifest (`oke build`) / " +
       "`rootDir` so effects can be derived. docker/prod refuse an open capability token.",
   },
+  /**
+   * A `src/flows/<unit>` folder exists on disk but no adopted flow carries
+   * that unit — the generated `.adopt()` barrel (`src/flows/generated.ts`)
+   * is stale or was hand-edited. docker/prod — never a silently-incomplete
+   * route table in a deploy-shaped environment.
+   */
+  ADOPT_BARREL_STALE: {
+    code: 1009,
+    cause: "src/flows/{unit} exists on disk but adopted no flows — the .adopt() barrel is stale.",
+    fix: "Run `oke dev` or `oke build` to regenerate `src/flows/generated.ts`.",
+  },
   /**
    * Emit target has no subscriber (unified-theory §21).
    * Thrown at emit when `optional` is false and nobody is subscribed.

package/src/kernel/flow.test.ts

@@ -11,8 +11,7 @@ beforeEach(() => {
 
 describe("flow — one species", () => {
   test("flow() returns a branded FlowDef", () => {
-    const f = flow({
-      name: "ping",
+    const f = flow("ping", {
       do: () => ({ ok: true }),
     });
     expect(isFlow(f)).toBe(true);
@@ -22,7 +21,7 @@ describe("flow — one species", () => {
   });
 
   test("on() returns the same flow object and records the trigger", () => {
-    const f = flow({ name: "create", do: () => 1 });
+    const f = flow("create", { do: () => 1 });
     const bound = on(http.post("/notes"), f);
     // Same runtime object; trigger stamp is type-only so identities differ at the type level.
     expect(bound as object).toBe(f);
@@ -33,8 +32,7 @@ describe("flow — one species", () => {
 
   test("the same flow object is reachable from HTTP and signal triggers", async () => {
     const calls: string[] = [];
-    const shared = flow({
-      name: "shared.work",
+    const shared = flow("shared.work", {
       do: (input: { n: number }) => {
         calls.push(`n=${input.n}`);
         return { n: input.n * 2 };
@@ -65,8 +63,7 @@ describe("five trigger kinds", () => {
 
     const httpFlow = on(
       http.get("/:code"),
-      flow({
-        name: "t.http",
+      flow("t.http", {
         do: ({ code }: { code: string }) => {
           seen.push(`http:${code}`);
           return { code };
@@ -76,8 +73,7 @@ describe("five trigger kinds", () => {
 
     on(
       every("1h"),
-      flow({
-        name: "t.every",
+      flow("t.every", {
         do: () => {
           seen.push("every");
         },
@@ -86,8 +82,7 @@ describe("five trigger kinds", () => {
 
     on(
       { name: "link-clicked", delivery: "once" },
-      flow({
-        name: "t.signal",
+      flow("t.signal", {
         do: ({ code }: { code: string }) => {
           seen.push(`signal:${code}`);
         },
@@ -96,8 +91,7 @@ describe("five trigger kinds", () => {
 
     on(
       table("orders").changed("status"),
-      flow({
-        name: "t.cdc",
+      flow("t.cdc", {
         do: (p: { before: { status: string }; after: { status: string } }) => {
           seen.push(`cdc:${p.before.status}->${p.after.status}`);
         },
@@ -106,8 +100,7 @@ describe("five trigger kinds", () => {
 
     on(
       internal,
-      flow({
-        name: "t.internal",
+      flow("t.internal", {
         do: () => {
           seen.push("internal");
           return { ok: true };

package/src/kernel/flow.ts

@@ -38,10 +38,6 @@ export type FlowHandler<I = unknown, O = unknown> = (
 
 /** Options for {@link flow}. */
 export interface FlowOptions<I = unknown, O = unknown, E extends FlowErrorMap = FlowErrorMap> {
-  /** Optional stable name (used by `fx.call` and the Manifest). */
-  readonly name?: string;
-  /** Optional unit scope for unit-level hooks. */
-  readonly unit?: string;
   /** Input schema (Standard Schema when present). */
   readonly in?: SchemaInput;
   /** Output schema (Standard Schema when present). */
@@ -155,7 +151,7 @@ export interface FlowDef<
   readonly [triggerPhantom]?: T;
   /** Stable name (auto-assigned when omitted). */
   readonly name: string;
-  /** Optional unit scope. */
+  /** Unit scope — derived from `name`'s first dot segment (e.g. `"auth.refresh"` → `"auth"`). */
   readonly unit: string | undefined;
   /** Input schema. */
   readonly in: SchemaInput | undefined;
@@ -231,28 +227,30 @@ export interface FlowDef<
 /** Unique brand symbol for {@link FlowDef}. */
 export const flowBrand: unique symbol = Symbol("oke.flow");
 
-let flowSeq = 0;
-
 /**
  * Define a Flow — the one species of backend behavior.
  *
  * Input / output types are inferred from Standard Schema `in` / `out` when
  * present; otherwise from the `do` handler signature.
  *
+ * @param name - Stable name (used by `fx.call` and the Manifest)
  * @param options - Contract and handler
  */
 export function flow<Opts extends FlowOptions<any, any, any>>(
-  options: Opts,
+  name: string,
+  options: Opts & { readonly name?: never },
 ): FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>, InferFlowErrors<Opts>> {
-  const name = options.name ?? `flow_${++flowSeq}`;
   const triggers: Trigger[] = [];
   const hooks: Partial<Record<HookStage, HookFn[]>> = {};
   const pendingPlugins: PluginDef[] = [];
 
+  const dot = name.indexOf(".");
+  const unit = dot > 0 ? name.slice(0, dot) : undefined;
+
   const def: FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>, InferFlowErrors<Opts>> = {
     [flowBrand]: true,
     name,
-    unit: options.unit,
+    unit,
     in: options.in,
     out: options.out,
     errors: (options.errors ?? undefined) as InferFlowErrors<Opts> | undefined,
@@ -316,10 +314,10 @@ export function isFlow(value: unknown): value is AnyFlowDef {
 }
 
 /**
- * Reset the auto-name sequence (tests only).
+ * No-op. `name` is a required positional argument now, so there is no
+ * auto-name sequence left to reset — kept so existing test `beforeEach`
+ * blocks don't need touching.
  *
  * @internal
  */
-export function resetFlowSeq(): void {
-  flowSeq = 0;
-}
+export function resetFlowSeq(): void {}

package/src/kernel/hook-timing.test.ts

@@ -27,7 +27,7 @@ describe("hook timing", () => {
     });
     const ctx: InvocationContext = {
       trigger: { kind: "internal" },
-      flow: flow({ name: "t", do: () => ({ ok: true }) }),
+      flow: flow("t", { do: () => ({ ok: true }) }),
       input: undefined,
       params: {},
       state: {},
@@ -56,7 +56,7 @@ describe("hook timing", () => {
     const hooks = registry.hooksAt("app", undefined, "x");
     const ctx: InvocationContext = {
       trigger: { kind: "internal" },
-      flow: flow({ name: "x", do: () => undefined }),
+      flow: flow("x", { do: () => undefined }),
       input: undefined,
       params: {},
       state: {},

package/src/kernel/hooks.test.ts

@@ -40,7 +40,7 @@ describe("hooks — order and composition", () => {
       void fn(
         {
           trigger: { kind: "internal" },
-          flow: flow({ name: "x", do: () => undefined }),
+          flow: flow("x", { do: () => undefined }),
           input: undefined,
           params: {},
           state: {},
@@ -57,9 +57,7 @@ describe("hooks — order and composition", () => {
   test("pipeline fires stages in order around the handler", async () => {
     const order: string[] = [];
 
-    const f = flow({
-      name: "ordered",
-      unit: "links",
+    const f = flow("links.ordered", {
       do: () => {
         order.push("handler");
         return { ok: true };
@@ -119,8 +117,7 @@ describe("hooks — order and composition", () => {
 
     on(
       http.get("/sc"),
-      flow({
-        name: "sc",
+      flow("sc", {
         do: () => {
           order.push("handler");
           return { ok: true };
@@ -151,8 +148,7 @@ describe("hooks — order and composition", () => {
 
     on(
       http.get("/data"),
-      flow({
-        name: "data",
+      flow("data", {
         do: () => ({ ok: true }),
       }),
     );
@@ -184,8 +180,7 @@ describe("hooks — order and composition", () => {
 
     on(
       http.get("/fail"),
-      flow({
-        name: "fail-flow",
+      flow("fail-flow", {
         do: () => {
           order.push("handler");
         },