okengine 0.10.0 → 0.10.2

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

@@ -0,0 +1,204 @@
+/**
+ * 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(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,
+ * docs, publish), never the live boot path. Confirmed via real `oke()` boot
+ * + `app.fetch()`, not assumption.
+ *
+ * Also documents the sql:<table> (compiler inference) vs sql:<store-name>
+ * (kernel `gatedSqlHandle`) naming mismatch this stamping bridge surfaces:
+ * once inference actually reaches the runtime, a flow relying on it for a
+ * real `fx.store(db).insert(table)` write must not throw `UNDECLARED_WRITE`
+ * for touching the exact table it declared.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { gate } from "../elements/gate.ts";
+import { field, id, now, store } from "../elements/store.ts";
+import { oke } from "./app.ts";
+import { resetNoEffectsWarnForTests } from "./boot.ts";
+import { flow, resetFlowSeq } from "./flow.ts";
+import { on, resetBindings } from "./on.ts";
+import { createTestApp } from "../test/create-test-app.ts";
+import { http } from "./triggers.ts";
+
+afterEach(() => {
+  resetBindings();
+  resetFlowSeq();
+  resetNoEffectsWarnForTests();
+});
+
+const notes = store.schema.table("notes", {
+  id: field.text().primaryKey().defaultFn(id),
+  title: field.text().notNull(),
+  createdAt: field.integer().notNull().defaultFn(now),
+});
+
+const CreateIn = z.object({ id: z.string(), title: z.string() });
+const CreateOut = z.object({ ok: z.boolean() });
+
+function buildUnannotatedCreateFlow(db: ReturnType<typeof store.sql>) {
+  return on(
+    http.post("/notes").gate(gate.public),
+    flow("notes.create", {
+      in: CreateIn,
+      out: CreateOut,
+      // Deliberately no `effects` — the "let the compiler infer it" case.
+      do: async (input, fx) => {
+        await fx.store(db).insert(notes).values({ id: input.id, title: input.title, createdAt: 1 });
+        return { ok: true };
+      },
+    }),
+  );
+}
+
+describe("boot-level: undeclared-effects flow, no manifest / rootDir", () => {
+  test("local / test: open token — real insert succeeds (documented dev-loop fallback)", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    // `on(...)` (inside buildUnannotatedCreateFlow) must run BEFORE `oke(...)`
+    // is constructed — oke() synchronously drains the global on() registry
+    // at construction time; a binding created only as .adopt()'s argument
+    // (after oke() already ran) never gets wired to a route.
+    const create = buildUnannotatedCreateFlow(db);
+    const app = oke({ name: "stamp-open", gate: { policies: [gate.public] } }).adopt({ create });
+    Object.assign(app.$options, { stores: [db] });
+    await createTestApp(app); // createTestApp always boots env: "test"
+
+    const res = await app.fetch(
+      new Request("http://localhost/notes", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "x1", title: "hi" }),
+      }),
+    );
+    expect(res.status).toBe(200);
+  });
+
+  test("docker: hard fail at boot — OKE1008, never an open token in a deploy-shaped env", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    const create = buildUnannotatedCreateFlow(db);
+    const app = oke({ name: "stamp-docker", gate: { policies: [gate.public] } }).adopt({ create });
+
+    await expect(
+      app.boot({ env: "docker", stores: [db], unguardedHttp: "allow", startScheduler: false }),
+    ).rejects.toThrow(/OKE1008/);
+  });
+
+  test("prod: hard fail at boot — same posture as docker", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    const create = buildUnannotatedCreateFlow(db);
+    const app = oke({ name: "stamp-prod", gate: { policies: [gate.public] } }).adopt({ create });
+
+    await expect(
+      app.boot({ env: "prod", stores: [db], unguardedHttp: "allow", startScheduler: false }),
+    ).rejects.toThrow(/OKE1008/);
+  });
+});
+
+describe("boot-level: table-ref resolution stays backward compatible", () => {
+  test("older store-level effects (sql:<store>) still cover a schema-table op — every existing template's convention", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    const create = on(
+      http.post("/notes").gate(gate.public),
+      flow("notes.create", {
+        in: CreateIn,
+        out: CreateOut,
+        // The convention every template/test predates Direction B with —
+        // store-level, not table-level. Must keep working unchanged.
+        effects: { writes: ["sql:app"] },
+        do: async (input, fx) => {
+          await fx
+            .store(db)
+            .insert(notes)
+            .values({ id: input.id, title: input.title, createdAt: 1 });
+          return { ok: true };
+        },
+      }),
+    );
+    const app = oke({ name: "stamp-back-compat", gate: { policies: [gate.public] } }).adopt({
+      create,
+    });
+    Object.assign(app.$options, { stores: [db] });
+    await createTestApp(app);
+
+    const res = await app.fetch(
+      new Request("http://localhost/notes", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "x1", title: "hi" }),
+      }),
+    );
+    expect(res.status).toBe(200);
+  });
+});
+
+describe("boot-level: undeclared-effects flow, rootDir stamping from a real source tree", () => {
+  test("real fx.store(db).insert(table) write succeeds once inference is stamped onto the capability token", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const dir = await mkdtemp(join(tmpdir(), "oke-stamp-"));
+    try {
+      await mkdir(join(dir, "flows", "notes"), { recursive: true });
+      // A real source file with NO manual `effects:` — extractManifest infers
+      // `writes: ["sql:notes"]` for this from the real `fx.store(db).insert`
+      // call, exactly like the kernel test flow above.
+      await writeFile(
+        join(dir, "flows", "notes", "index.ts"),
+        `
+import { on, flow, http, gate } from "okengine";
+// Unresolved bindings are fine — extraction is AST-only, never executed.
+// What matters is the literal shape: fx.store(db).insert(notes) so the
+// same table-name inference that produced "sql:notes" earlier fires here.
+const db = {} as any;
+const notes = {} as any;
+export const create = on(
+  http.post("/notes").gate(gate.public),
+  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 };
+    },
+  }),
+);
+`,
+      );
+
+      const db = store.sql("app", { schema: { notes } });
+      const create = buildUnannotatedCreateFlow(db);
+      const app = oke({ name: "stamp-rootdir", gate: { policies: [gate.public] } }).adopt({
+        create,
+      });
+      Object.assign(app.$options, { stores: [db] });
+      await createTestApp(app, { boot: { rootDir: dir } });
+
+      const res = await app.fetch(
+        new Request("http://localhost/notes", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ id: "x1", title: "hi" }),
+        }),
+      );
+      const body = (await res.json()) as { data: unknown; error: { message?: string } | null };
+      expect(res.status, body.error?.message ?? "").toBe(200);
+      expect(body.data).toEqual({ ok: true });
+    } finally {
+      await rm(dir, { recursive: true, force: 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

@@ -142,6 +142,28 @@ export const OKE_ERRORS = {
     cause: 'Flow "{flow}" calls "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.calls.',
   },
+  /**
+   * Flow has no declared `effects` and no Manifest-derived effects were
+   * available to stamp at boot (docker / prod — never a silent open token).
+   */
+  NO_EFFECTS_DECLARED: {
+    code: 1008,
+    cause: 'Flow "{flow}" has no declared effects and no Manifest to derive them from.',
+    fix:
+      "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/fx.ts

@@ -10,6 +10,7 @@
  */
 
 import type { Effects, ResourceRef } from "../manifest/types.ts";
+import { schemaTableName, sqlTableRef } from "../manifest/sql-resource.ts";
 import type {
   FilesStoreDecl,
   FilesStoreFxHandle,
@@ -852,6 +853,34 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         );
       }
     };
+    /**
+     * Gate a table-scoped SQL operation. Prefers the precise `sql:<table>`
+     * ref (matches what the compiler's AST inference derives from the same
+     * call site — {@link "../manifest/sql-resource.ts"}); falls back to the
+     * store-level ref when the table ref isn't declared — every flow that
+     * hand-declared the older `effects: { writes: ["sql:<store>"] }`
+     * convention (every existing template, `upsert-app.test.ts`, …) must
+     * keep working unchanged. Ledger / journal record whichever ref the
+     * capability check actually matched, not always the coarser one.
+     *
+     * @param kind - Effect kind
+     * @param table - Table argument passed to a `SqlStoreHandle` method
+     * @param body - Work to run under the gate
+     */
+    const gatedTable = <T>(
+      kind: Parameters<CapabilityToken["assert"]>[0],
+      table: unknown,
+      body: () => T | Promise<T>,
+    ): Promise<T> => {
+      const name = schemaTableName(table);
+      if (name !== undefined) {
+        const perTable = sqlTableRef(name);
+        if (perTable !== ref && capability.allows(kind, perTable)) {
+          return gated(kind, perTable, body);
+        }
+      }
+      return gated(kind, ref, body);
+    };
 
     return {
       ref,
@@ -870,7 +899,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
               limit?: number;
               offset?: number;
             }): Promise<SqlRow[]> =>
-              gated("read", ref, async () => {
+              gatedTable("read", table, async () => {
                 const h = await ensure();
                 const from = h.select(columns).from(table);
                 const filtered = plan.where === undefined ? from : from.where(plan.where);
@@ -920,14 +949,14 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         return {
           values(row) {
             const runExecute = () =>
-              gated("write", ref, async () => {
+              gatedTable("write", table, async () => {
                 refuseDryRunWrite();
                 const h = await ensure();
                 await h.insert(table).values(row).execute();
               });
             return {
               returning() {
-                return gated("write", ref, async () => {
+                return gatedTable("write", table, async () => {
                   refuseDryRunWrite();
                   const h = await ensure();
                   return h.insert(table).values(row).returning();
@@ -946,7 +975,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
           set(row) {
             return {
               where(where) {
-                return gated("write", ref, async () => {
+                return gatedTable("write", table, async () => {
                   refuseDryRunWrite();
                   const h = await ensure();
                   return h.update(table).set(row).where(where);
@@ -957,14 +986,14 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         };
       },
       findById(table, id) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.findById(table, id);
         });
       },
       delete(table: Parameters<SqlStoreHandle["delete"]>[0], id?: string) {
         if (id !== undefined) {
-          return gated("write", ref, async () => {
+          return gatedTable("write", table, async () => {
             refuseDryRunWrite();
             const h = await ensure();
             return h.delete(table, id);
@@ -972,7 +1001,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         }
         return {
           where(where: unknown) {
-            return gated("write", ref, async () => {
+            return gatedTable("write", table, async () => {
               refuseDryRunWrite();
               const h = await ensure();
               return h.delete(table).where(where);
@@ -981,20 +1010,20 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         };
       },
       exists(table, idOrWhere) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.exists(table, idOrWhere);
         });
       },
       upsert(table, matchOn, values, upsertOptions) {
-        return gated("write", ref, async () => {
+        return gatedTable("write", table, async () => {
           refuseDryRunWrite();
           const h = await ensure();
           return h.upsert(table, matchOn, values, upsertOptions);
         });
       },
       increment(table, id, column, by) {
-        return gated("write", ref, async () => {
+        return gatedTable("write", table, async () => {
           refuseDryRunWrite();
           const h = await ensure();
           return h.increment(table, id, column, by);
@@ -1007,19 +1036,19 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         });
       },
       count(table, where) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.count(table, where);
         });
       },
       page(table, pageOptions) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.page(table, pageOptions);
         });
       },
       ensureTable(table) {
-        return gated("write", ref, async () => {
+        return gatedTable("write", table, async () => {
           refuseDryRunWrite();
           const h = await ensure();
           return h.ensureTable(table);

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: {},