okengine 0.10.1 → 0.10.2

package/src/kernel/auto-registry.test.ts

@@ -0,0 +1,198 @@
+/**
+ * `oke({...})` auto-populates `stores` / `secrets` / `signals` /
+ * `channel.templates` from the same kind of module-evaluation registry
+ * already proven for `on()`'s trigger drain (`registry-isolation.test.ts`).
+ *
+ * `store.sql` / `store.files`, `vault.secret`, `signal()`, and medium-binder
+ * `.template()` push into a shared registry (`src/kernel/element-registries.ts`)
+ * at call time — zero change to how developers call them. `oke()` drains it
+ * at construction under the same `registry: "consume" | "keep" | "ignore"`
+ * switch that already governs bindings.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { channel } from "../elements/channel/declare.ts";
+import { signal } from "../elements/signal/declare.ts";
+import { store } from "../elements/store/declare.ts";
+import { vault } from "../elements/vault/declare.ts";
+import { oke } from "./app.ts";
+import { flow } from "./flow.ts";
+import { on, resetBindings } from "./on.ts";
+import { http } from "./triggers.ts";
+
+describe("oke() auto-registry — stores/secrets/signals/channel.templates", () => {
+  test("before/after: zero explicit arrays boots identically to the explicit-array form", async () => {
+    resetBindings();
+
+    // "before" — today's explicit-array form (registry: "ignore" so this
+    // app cannot see anything auto-drained; proves the old path is unchanged).
+    const dbBefore = store.sql("before-app", { schema: {} });
+    const filesBefore = store.files("before-uploads");
+    const secretBefore = vault.secret("BEFORE_WEBHOOK_SECRET", { dev: "dev-secret-before" });
+    const signalBefore = signal("before-note-created", { delivery: "once", optional: true });
+    const mailBefore = channel.email({ from: "Before <before@localhost>" });
+    const templateBefore = mailBefore.template("before-note-created");
+
+    const beforeFlow = flow("before.onCreated", {
+      effects: {
+        secrets: ["BEFORE_WEBHOOK_SECRET"],
+        emits: ["before-note-created"],
+        sends: ["before-note-created"],
+      },
+      do: async (_input, fx) => {
+        const secret = fx.vault(secretBefore);
+        await fx.emit(signalBefore, {});
+        await fx.send(templateBefore, { to: "you@localhost", data: {} });
+        return { secret };
+      },
+    });
+    on(http.post("/before"), beforeFlow);
+
+    const appBefore = oke({
+      name: "before-app",
+      registry: "ignore",
+      bindings: [{ trigger: http.post("/before"), flow: beforeFlow }],
+      gate: { unguardedHttp: "allow" },
+      vault: { allowDevFallbacks: true },
+      stores: [dbBefore, filesBefore],
+      secrets: [secretBefore],
+      signals: [signalBefore],
+      channel: { templates: [templateBefore] },
+      startScheduler: false,
+    });
+
+    // "after" — same shape, zero explicit arrays; registry auto-populates.
+    // Declared (and registered) for their side effect only — never passed
+    // to `oke()` directly, proving the registry alone carries them.
+    store.sql("after-app", { schema: {} });
+    store.files("after-uploads");
+    const secretAfter = vault.secret("AFTER_WEBHOOK_SECRET", { dev: "dev-secret-after" });
+    const signalAfter = signal("after-note-created", { delivery: "once", optional: true });
+    const mailAfter = channel.email({ from: "After <after@localhost>" });
+    const templateAfter = mailAfter.template("after-note-created");
+
+    const afterFlow = flow("after.onCreated", {
+      effects: {
+        secrets: ["AFTER_WEBHOOK_SECRET"],
+        emits: ["after-note-created"],
+        sends: ["after-note-created"],
+      },
+      do: async (_input, fx) => {
+        const secret = fx.vault(secretAfter);
+        await fx.emit(signalAfter, {});
+        await fx.send(templateAfter, { to: "you@localhost", data: {} });
+        return { secret };
+      },
+    });
+    resetBindings();
+    on(http.post("/after"), afterFlow);
+
+    const appAfter = oke({
+      name: "after-app",
+      gate: { unguardedHttp: "allow" },
+      vault: { allowDevFallbacks: true },
+      startScheduler: false,
+      // No stores / secrets / signals / channel — registry supplies them.
+    });
+
+    await appBefore.boot({ env: "test", unguardedHttp: "allow" });
+    await appAfter.boot({ env: "test", unguardedHttp: "allow" });
+
+    // Both boots resolved the same shape from stores → secrets → signals → channel.
+    expect(appBefore.bootResult?.store?.declarations.has("sql:before-app")).toBe(true);
+    expect(appBefore.bootResult?.store?.declarations.has("files:before-uploads")).toBe(true);
+    expect(appAfter.bootResult?.store?.declarations.has("sql:after-app")).toBe(true);
+    expect(appAfter.bootResult?.store?.declarations.has("files:after-uploads")).toBe(true);
+
+    expect(appBefore.bootResult?.vault?.contracts.has("BEFORE_WEBHOOK_SECRET")).toBe(true);
+    expect(appAfter.bootResult?.vault?.contracts.has("AFTER_WEBHOOK_SECRET")).toBe(true);
+    expect(appBefore.bootResult?.vault?.read("BEFORE_WEBHOOK_SECRET")).toBe("dev-secret-before");
+    expect(appAfter.bootResult?.vault?.read("AFTER_WEBHOOK_SECRET")).toBe("dev-secret-after");
+
+    expect(appBefore.bootResult?.signal?.declarations.has("before-note-created")).toBe(true);
+    expect(appAfter.bootResult?.signal?.declarations.has("after-note-created")).toBe(true);
+
+    expect(appBefore.bootResult?.channel?.templates.has("before-note-created")).toBe(true);
+    expect(appAfter.bootResult?.channel?.templates.has("after-note-created")).toBe(true);
+
+    // Same flow execution shape through the real HTTP path either way —
+    // both resolve, emit, and send successfully; the secret value itself
+    // comes back redacted (fx output redaction), same on both sides.
+    const resBefore = await appBefore.fetch(
+      new Request("http://localhost/before", { method: "POST" }),
+    );
+    const resAfter = await appAfter.fetch(
+      new Request("http://localhost/after", { method: "POST" }),
+    );
+    expect(resBefore.status).toBe(200);
+    expect(resAfter.status).toBe(200);
+    const bodyBefore = (await resBefore.json()) as { data: { secret: string } };
+    const bodyAfter = (await resAfter.json()) as { data: { secret: string } };
+    expect(bodyBefore.data.secret).toBe(bodyAfter.data.secret);
+  });
+
+  test("explicit passing is additive, never silently ignored — same object via both paths is deduped, not doubled", async () => {
+    const db = store.sql("dedup-app", { schema: {} });
+
+    // `db` is already sitting in the registry from the call above *and*
+    // passed explicitly — must not double-register / conflict.
+    const app = oke({
+      name: "dedup-app",
+      autoBoot: false,
+      stores: [db],
+      startScheduler: false,
+    });
+
+    await app.boot({ env: "test", unguardedHttp: "allow" });
+    expect(app.bootResult?.store?.declarations.has("sql:dedup-app")).toBe(true);
+  });
+
+  test('registry: "ignore" does not auto-populate', async () => {
+    vault.secret("IGNORED_SECRET", { description: "never passed, never auto-read" });
+
+    const app = oke({
+      name: "ignore-mode-app",
+      registry: "ignore",
+      startScheduler: false,
+    });
+    // Nothing requires the secret, so boot succeeds — but it must not have
+    // silently picked up IGNORED_SECRET from the registry either way.
+    await app.boot({ env: "test", unguardedHttp: "allow" });
+    expect(app.bootResult?.vault?.contracts.has("IGNORED_SECRET")).toBeFalsy();
+  });
+
+  test('registry: "consume" (default) drains stores/secrets/signals/channel.templates — a later app does not inherit them', async () => {
+    store.sql("leak-app", { schema: {} });
+    vault.secret("LEAK_SECRET", { dev: "dev-leak" });
+    signal("leak-signal", { delivery: "once" });
+    channel.email().template("leak-template");
+
+    const appA = oke({
+      name: "leak-app-a",
+      autoBoot: false,
+      vault: { allowDevFallbacks: true },
+      startScheduler: false,
+    });
+    await appA.boot({ env: "test", unguardedHttp: "allow" });
+    expect(appA.bootResult?.store?.declarations.has("sql:leak-app")).toBe(true);
+    expect(appA.bootResult?.vault?.contracts.has("LEAK_SECRET")).toBe(true);
+
+    // Second app, constructed after the first drained the registry.
+    const appB = oke({
+      name: "leak-app-b",
+      autoBoot: false,
+      startScheduler: false,
+    });
+    await appB.boot({ env: "test", unguardedHttp: "allow" });
+    // Nothing was passed and nothing was left in the registry (App A drained
+    // it) — App B needed store/vault/signal not at all, so no runtime was
+    // built for them. Channel boots unconditionally regardless of registry
+    // content (pre-existing, unrelated to this feature — `resolveElementNeeds`
+    // gates channel on object *presence*, not template count) — assert its
+    // template map, not runtime absence.
+    expect(appB.bootResult?.store).toBeUndefined();
+    expect(appB.bootResult?.vault).toBeUndefined();
+    expect(appB.bootResult?.signal).toBeUndefined();
+    expect(appB.bootResult?.channel?.templates.has("leak-template") ?? false).toBe(false);
+  });
+});

package/src/kernel/boot-bind/honor-config.test.ts

@@ -157,7 +157,7 @@ describe("boot binders honour drivers.* config", () => {
     const result = await bootApplication({
       env: "local",
       startScheduler: false,
-      flows: [flow({ name: "charge", durable: true, do: () => ({ ok: true }) })],
+      flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
     });
     try {
       expect(result.journal?.driverId).toBe("memory");
@@ -172,7 +172,7 @@ describe("boot binders honour drivers.* config", () => {
     const result = await bootApplication({
       env: "local",
       startScheduler: false,
-      flows: [flow({ name: "plain", do: () => ({ ok: true }) })],
+      flows: [flow("plain", { do: () => ({ ok: true }) })],
     });
     try {
       expect(result.journal).toBeUndefined();
@@ -187,7 +187,7 @@ describe("boot binders honour drivers.* config", () => {
     const result = await bootApplication({
       env: "local",
       startScheduler: false,
-      flows: [flow({ name: "charge", durable: true, do: () => ({ ok: true }) })],
+      flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
       config: {
         drivers: {
           journal: { local: "file", docker: "postgres", test: "memory", prod: "postgres" },
@@ -211,7 +211,7 @@ describe("boot binders honour drivers.* config", () => {
         bootApplication({
           env: "local",
           startScheduler: false,
-          flows: [flow({ name: "charge", durable: true, do: () => ({ ok: true }) })],
+          flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
           config: {
             drivers: {
               journal: { local: "postgres" },
@@ -232,7 +232,7 @@ describe("boot binders honour drivers.* config", () => {
       bootApplication({
         env: "local",
         startScheduler: false,
-        flows: [flow({ name: "charge", durable: true, do: () => ({ ok: true }) })],
+        flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
         config: {
           drivers: {
             journal: { local: "neon" },

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.