okengine 0.2.6 → 0.3.2

package/src/kernel/boot.ts

@@ -22,43 +22,19 @@
  */
 
 import type { ConfigEnv, OkeConfig } from "../config/index.ts";
-import type {
-  AiRuntime,
-  CreateAiRuntimeOptions,
-} from "../elements/ai.ts";
-import type {
-  ChannelRuntime,
-  CreateChannelRuntimeOptions,
-} from "../elements/channel.ts";
-import type {
-  ClockDecl,
-  ClockRuntime,
-} from "../elements/clock.ts";
-import type {
-  GateDecl,
-  GateRuntime,
-} from "../elements/gate.ts";
-import type {
-  SignalDecl,
-  SignalRuntime,
-} from "../elements/signal.ts";
-import type {
-  StoreDecl,
-  StoreRuntime,
-} from "../elements/store.ts";
+import type { AiRuntime, CreateAiRuntimeOptions } from "../elements/ai.ts";
+import type { ChannelRuntime, CreateChannelRuntimeOptions } from "../elements/channel.ts";
+import type { ClockDecl, ClockRuntime } from "../elements/clock.ts";
+import type { GateDecl, GateRuntime } from "../elements/gate.ts";
+import type { SignalDecl, SignalRuntime } from "../elements/signal.ts";
+import type { StoreDecl, StoreRuntime } from "../elements/store.ts";
 import type {
   CreateVaultRuntimeOptions,
   VaultRuntime,
   VaultSecretDecl,
 } from "../elements/vault.ts";
-import type {
-  CreateRunsRuntimeOptions,
-  RunsRuntime,
-} from "../runs/index.ts";
-import {
-  createCapabilityToken,
-  type CapabilityToken,
-} from "./capability.ts";
+import type { CreateRunsRuntimeOptions, RunsRuntime } from "../runs/index.ts";
+import { createCapabilityToken, type CapabilityToken } from "./capability.ts";
 import type { AnyFlowDef } from "./flow.ts";
 import type { Binding } from "./on.ts";
 
@@ -77,16 +53,16 @@ export interface ElementRuntimes {
 /** Declarations + options consumed by {@link bootApplication}. */
 export interface BootOptions {
   /**
-   * Active environment (defaults to `dev`, or `stack` when
-   * {@link stack} / `OKE_STACK=1`).
+   * Active environment (defaults to `local`, or `docker` when
+   * {@link docker} / `OKE_DOCKER=1`).
    */
   readonly env?: ConfigEnv;
   /**
-   * Local-server mode (`oke dev -s` / `OKE_STACK=1`): force driver maps to the
-   * `stack` profile and prefer compose URLs (`.env.stack`).
-   * When unset, derived from `process.env.OKE_STACK`.
+   * Docker mode (`oke dev -d` / `OKE_DOCKER=1`): force driver maps to the
+   * `docker` profile and prefer compose URLs (`docker/.env.docker`).
+   * When unset, derived from `process.env.OKE_DOCKER`.
    */
-  readonly stack?: boolean;
+  readonly docker?: boolean;
   /** Optional `oke.config.ts` document. */
   readonly config?: OkeConfig;
   /** Pre-built runtimes (skip construction when present). */
@@ -127,10 +103,7 @@ export interface BootOptions {
    * @param signal - Signal name
    * @param payload - Payload
    */
-  readonly onSignal?: (
-    signal: string,
-    payload: unknown,
-  ) => void | Promise<void>;
+  readonly onSignal?: (signal: string, payload: unknown) => void | Promise<void>;
   /** Injectable clock for test / frozen harnesses. */
   readonly now?: () => number;
   /** Instance id for leader election. */
@@ -185,8 +158,7 @@ export interface ElementNeeds {
 export function resolveElementNeeds(options: BootOptions): ElementNeeds {
   const pre = options.elements ?? {};
   let vault =
-    pre.vault !== undefined ||
-    (options.vault?.secrets ?? options.secrets ?? []).length > 0;
+    pre.vault !== undefined || (options.vault?.secrets ?? options.secrets ?? []).length > 0;
   let store = pre.store !== undefined || (options.stores?.length ?? 0) > 0;
   let signal = pre.signal !== undefined || (options.signals?.length ?? 0) > 0;
   let clock = pre.clock !== undefined || (options.clocks?.length ?? 0) > 0;
@@ -224,10 +196,7 @@ export function resolveElementNeeds(options: BootOptions): ElementNeeds {
 
   // AI agents share the gate runtime for tool checks.
   if (ai) gate = true;
-  if (
-    options.onSignal &&
-    (options.bindings ?? []).some((b) => b.trigger.kind === "signal")
-  ) {
+  if (options.onSignal && (options.bindings ?? []).some((b) => b.trigger.kind === "signal")) {
     signal = true;
   }
 
@@ -251,15 +220,12 @@ async function loadBind<T>(name: string): Promise<T> {
  *
  * @param options - Declarations, config, pre-built runtimes
  */
-export async function bootApplication(
-  input: BootOptions = {},
-): Promise<BootResult> {
-  const stack =
-    input.stack === true ||
-    (input.stack !== false && process.env.OKE_STACK === "1");
-  // `-s` always selects the `stack` driver profile — not a mix of test/dev +
+export async function bootApplication(input: BootOptions = {}): Promise<BootResult> {
+  const docker =
+    input.docker === true || (input.docker !== false && process.env.OKE_DOCKER === "1");
+  // `-d` always selects the `docker` driver profile — not a mix of test/local +
   // prod store overrides (templates often pin `env: "test"` for harnesses).
-  const env: ConfigEnv = stack ? "stack" : (input.env ?? "dev");
+  const env: ConfigEnv = docker ? "docker" : (input.env ?? "local");
   let config = input.config;
   if (config === undefined) {
     try {
@@ -269,7 +235,7 @@ export async function bootApplication(
       config = undefined;
     }
   }
-  const options: BootOptions = { ...input, config, env, stack };
+  const options: BootOptions = { ...input, config, env, docker };
   const pre = options.elements ?? {};
   const now = options.now ?? (() => Date.now());
   const needs = resolveElementNeeds(options);
@@ -278,9 +244,7 @@ export async function bootApplication(
   let vault = pre.vault;
   if (needs.vault) {
     if (!vault) {
-      const { bindVault } = await loadBind<
-        typeof import("./boot-bind/vault.ts")
-      >("vault");
+      const { bindVault } = await loadBind<typeof import("./boot-bind/vault.ts")>("vault");
       vault = await bindVault(options, env);
     } else if (!vault.booted) {
       await vault.boot();
@@ -347,11 +311,7 @@ export async function bootApplication(
       }),
     );
   }
-  if (
-    needs.runs &&
-    !pre.runs &&
-    !(options.runs && isRunsRuntime(options.runs))
-  ) {
+  if (needs.runs && !pre.runs && !(options.runs && isRunsRuntime(options.runs))) {
     binderLoads.push(
       loadBind<RunsBind>("runs").then((m) => {
         runsBind = m;
@@ -364,7 +324,7 @@ export async function bootApplication(
   let store = pre.store;
   if (needs.store) {
     if (!store) {
-      store = storeBind!.bindStore(options, env, now, stack);
+      store = storeBind!.bindStore(options, env, now, docker);
     } else {
       for (const decl of options.stores ?? []) {
         store.register?.(decl);
@@ -414,7 +374,7 @@ export async function bootApplication(
   // 5. Channel
   let channel = pre.channel;
   if (needs.channel && !channel) {
-    channel = channelBind!.bindChannel(options, now);
+    channel = channelBind!.bindChannel(options, env, now, docker);
   }
 
   // 6. AI
@@ -431,10 +391,7 @@ export async function bootApplication(
         runs = options.runs;
         if (!runs.store) await runs.open();
       } else {
-        const runsOpts =
-          options.runs && !isRunsRuntime(options.runs)
-            ? options.runs
-            : undefined;
+        const runsOpts = options.runs && !isRunsRuntime(options.runs) ? options.runs : undefined;
         runs = await runsBind!.bindRuns(runsOpts);
       }
     } else if (!runs.store) {
@@ -479,9 +436,7 @@ export async function bootApplication(
  *
  * @param flows - Adopted flows
  */
-export function mintCapabilities(
-  flows: readonly AnyFlowDef[],
-): Map<string, CapabilityToken> {
+export function mintCapabilities(flows: readonly AnyFlowDef[]): Map<string, CapabilityToken> {
   const map = new Map<string, CapabilityToken>();
   for (const f of flows) {
     map.set(f.name, createCapabilityToken(f.name, f.effects));
@@ -489,9 +444,7 @@ export function mintCapabilities(
   return map;
 }
 
-function isRunsRuntime(
-  value: RunsRuntime | CreateRunsRuntimeOptions,
-): value is RunsRuntime {
+function isRunsRuntime(value: RunsRuntime | CreateRunsRuntimeOptions): value is RunsRuntime {
   return (
     typeof value === "object" &&
     value !== null &&

package/src/kernel/budget.test.ts

@@ -10,9 +10,7 @@ import { measureKernelEdgeGzipBytes } from "../release/measure.ts";
 describe("kernel edge bundle budget", () => {
   test(`edge profile < ${KERNEL_EDGE_BUDGET_BYTES} bytes gzipped`, async () => {
     const size = await measureKernelEdgeGzipBytes();
-    console.log(
-      `kernel edge gzip=${size} budget=${KERNEL_EDGE_BUDGET_BYTES}`,
-    );
+    console.log(`kernel edge gzip=${size} budget=${KERNEL_EDGE_BUDGET_BYTES}`);
     expect(size).toBeGreaterThan(0);
     expect(size).toBeLessThan(KERNEL_EDGE_BUDGET_BYTES);
   });

package/src/kernel/capability.ts

@@ -11,9 +11,7 @@ import type { EffectKind } from "./effects.ts";
 import { OKE_ERRORS, throwOke } from "./errors.ts";
 
 /** Maps effect kind → the undeclared-access registry key. */
-const UNDECLARED_KEY: Readonly<
-  Record<EffectKind, keyof typeof OKE_ERRORS>
-> = {
+const UNDECLARED_KEY: Readonly<Record<EffectKind, keyof typeof OKE_ERRORS>> = {
   read: "UNDECLARED_READ",
   write: "UNDECLARED_WRITE",
   emit: "UNDECLARED_EMIT",
@@ -24,9 +22,7 @@ const UNDECLARED_KEY: Readonly<
 };
 
 /** Maps effect kind → the corresponding `Effects` field. */
-const EFFECTS_FIELD: Readonly<
-  Record<EffectKind, keyof Effects>
-> = {
+const EFFECTS_FIELD: Readonly<Record<EffectKind, keyof Effects>> = {
   read: "reads",
   write: "writes",
   emit: "emits",
@@ -72,10 +68,7 @@ export interface CapabilityToken {
  * @param flow - Flow id (used in error messages)
  * @param declared - Declared effect surface, or `undefined` for open
  */
-export function createCapabilityToken(
-  flow: string,
-  declared?: Effects,
-): CapabilityToken {
+export function createCapabilityToken(flow: string, declared?: Effects): CapabilityToken {
   const open = declared === undefined;
   const effects = declared ?? {};
   const sets: Record<EffectKind, ReadonlySet<string>> = {

package/src/kernel/dry-run.test.ts

@@ -1,9 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import type { ChannelRuntime } from "../elements/channel/runtime.ts";
-import {
-  isDryRun,
-  withDryRun,
-} from "./dry-run.ts";
+import { isDryRun, withDryRun } from "./dry-run.ts";
 import { createFx, type FxStubStoreHandle } from "./fx.ts";
 
 describe("fx dry-run stubbing", () => {

package/src/kernel/dry-run.ts

@@ -94,10 +94,7 @@ export function setDryRunMessageId(messageId: string): void {
  * @param kind - Irreversible kind
  * @param resource - Template / prompt name
  */
-export function recordWouldHaveFired(
-  kind: "send" | "ask",
-  resource: string,
-): void {
+export function recordWouldHaveFired(kind: "send" | "ask", resource: string): void {
   const ctx = storage.getStore();
   if (!ctx) return;
   ctx.wouldHaveFired.push({
@@ -115,19 +112,14 @@ export function recordWouldHaveFired(
  * @param ref - Store resource ref (`sql:inventory`, …)
  * @param table - Live in-memory table Map
  */
-export function touchDryRunStore(
-  ref: string,
-  table: Map<string, unknown>,
-): void {
+export function touchDryRunStore(ref: string, table: Map<string, unknown>): void {
   const ctx = storage.getStore();
   if (!ctx) return;
   if (ctx.storeSnapshots.has(ref)) return;
   ctx.storeRefs.set(ref, table);
   ctx.storeSnapshots.set(
     ref,
-    new Map(
-      [...table.entries()].map(([k, v]) => [k, structuredClone(v)]),
-    ),
+    new Map([...table.entries()].map(([k, v]) => [k, structuredClone(v)])),
   );
 }
 

package/src/kernel/edge.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Plugin edge handlers — the contribution that answers HTTP requests no
+ * flow owns (CORS preflight being the prime example), with the plain 404
+ * preserved as the floor.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+import { oke } from "./app.ts";
+import { flow, resetFlowSeq } from "./flow.ts";
+import { on, resetBindings } from "./on.ts";
+import { plugin } from "./plugin.ts";
+import { createPluginRegistry } from "./registry.ts";
+import { http } from "./triggers.ts";
+
+beforeEach(() => {
+  resetBindings();
+  resetFlowSeq();
+});
+
+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 }) }));
+    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" } });
+      }
+      return undefined;
+    });
+    const app = oke({ name: "edge" }).plug(edge);
+
+    const preflight = await app.fetch(new Request("http://localhost/x", { method: "OPTIONS" }));
+    expect(preflight.status).toBe(204);
+    expect(preflight.headers.get("x-edge")).toBe("yes");
+
+    const matched = await app.fetch(new Request("http://localhost/x"));
+    expect(matched.status).toBe(200);
+    expect(matched.headers.get("x-edge")).toBeNull();
+  });
+
+  test("returning undefined falls through to the next handler, then the plain 404", async () => {
+    const pass = plugin("edge-pass", { version: "0.0.1" }).edge(() => undefined);
+    const answer = plugin("edge-answer", { version: "0.0.1" }).edge(
+      () => new Response("answered", { status: 418 }),
+    );
+    const app = oke({ name: "edge-order" }).plug(pass).plug(answer);
+
+    const res = await app.fetch(new Request("http://localhost/nowhere", { method: "OPTIONS" }));
+    expect(res.status).toBe(418);
+    expect(await res.text()).toBe("answered");
+
+    const noPlugins = oke({ name: "edge-none" });
+    const missing = await noPlugins.fetch(
+      new Request("http://localhost/nowhere", { method: "OPTIONS" }),
+    );
+    expect(missing.status).toBe(404);
+    expect(await missing.text()).toBe("Not Found");
+  });
+
+  test("edge is recorded as an intercept capability", () => {
+    const registry = createPluginRegistry();
+    const registration = registry.plug(
+      plugin("edge-cap", { version: "0.0.1" }).edge(() => undefined),
+      { kind: "app" },
+    );
+    expect(registration?.capabilities.intercepts).toContain("edge");
+    expect(registry.edgeHandlers()).toHaveLength(1);
+  });
+});

package/src/kernel/effects.test.ts

@@ -46,11 +46,7 @@ describe("effects — ledger", () => {
     });
 
     expect(ledger.entries).toHaveLength(3);
-    expect(ledger.entries.map((e) => e.kind)).toEqual([
-      "read",
-      "write",
-      "emit",
-    ]);
+    expect(ledger.entries.map((e) => e.kind)).toEqual(["read", "write", "emit"]);
     expect(ledger.entries[0]).toMatchObject({
       kind: "read",
       resource: "sql:bookings",

package/src/kernel/effects.ts

@@ -6,14 +6,7 @@
  */
 
 /** The seven load-bearing effect kinds (manifest `effects` keys, singular). */
-export type EffectKind =
-  | "read"
-  | "write"
-  | "emit"
-  | "send"
-  | "ask"
-  | "secret"
-  | "call";
+export type EffectKind = "read" | "write" | "emit" | "send" | "ask" | "secret" | "call";
 
 /**
  * Reversibility tier — console §9.1 ranking, applied to all seven kinds.
@@ -135,6 +128,6 @@ export async function recordEffect<T>(
 export const EFFECT_KIND_TIERS: ReadonlyArray<{
   kind: EffectKind;
   reversibility: ReversibilityTier;
-}> = (
-  Object.entries(TIER_BY_KIND) as Array<[EffectKind, ReversibilityTier]>
-).map(([kind, reversibility]) => ({ kind, reversibility }));
+}> = (Object.entries(TIER_BY_KIND) as Array<[EffectKind, ReversibilityTier]>).map(
+  ([kind, reversibility]) => ({ kind, reversibility }),
+);

package/src/kernel/errors.registry.test.ts

@@ -6,11 +6,7 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import {
-  OKE_ERRORS,
-  OkeError,
-  type OkeErrorDefinition,
-} from "./errors.ts";
+import { OKE_ERRORS, OkeError, type OkeErrorDefinition } from "./errors.ts";
 
 describe("OKE error-code registry", () => {
   test("every code is unique", () => {
@@ -30,9 +26,7 @@ describe("OKE error-code registry", () => {
   test("OkeError docsUrl matches docs origin /e/{code}", () => {
     for (const def of Object.values(OKE_ERRORS) as OkeErrorDefinition[]) {
       const err = new OkeError(def);
-      expect(err.docsUrl).toBe(
-        `https://okengine.vercel.app/e/${def.code}`,
-      );
+      expect(err.docsUrl).toBe(`https://oke.omqkhafi.dev/e/${def.code}`);
       expect(err.message).toContain(err.docsUrl);
       expect(err.message).toContain(`OKE${def.code}`);
       expect(err.message).toContain("→");

package/src/kernel/errors.ts

@@ -99,50 +99,43 @@ export const OKE_ERRORS = {
   /** Flow reads a store resource not listed in `effects.reads`. */
   UNDECLARED_READ: {
     code: 1001,
-    cause:
-      'Flow "{flow}" reads "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" reads "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.reads.',
   },
   /** Flow writes a store resource not listed in `effects.writes`. */
   UNDECLARED_WRITE: {
     code: 1002,
-    cause:
-      'Flow "{flow}" writes "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" writes "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.writes.',
   },
   /** Flow emits a signal not listed in `effects.emits`. */
   UNDECLARED_EMIT: {
     code: 1003,
-    cause:
-      'Flow "{flow}" emits "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" emits "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.emits.',
   },
   /** Flow sends a channel template not listed in `effects.sends`. */
   UNDECLARED_SEND: {
     code: 1004,
-    cause:
-      'Flow "{flow}" sends "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" sends "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.sends.',
   },
   /** Flow asks a prompt not listed in `effects.asks`. */
   UNDECLARED_ASK: {
     code: 1005,
-    cause:
-      'Flow "{flow}" asks "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" asks "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.asks.',
   },
   /** Flow reads a secret not listed in `effects.secrets`. */
   UNDECLARED_SECRET: {
     code: 1006,
-    cause:
-      'Flow "{flow}" reads secret "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" reads secret "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.secrets.',
   },
   /** Flow calls another flow not listed in `effects.calls`. */
   UNDECLARED_CALL: {
     code: 1007,
-    cause:
-      'Flow "{flow}" calls "{resource}" without declaring it.',
+    cause: 'Flow "{flow}" calls "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.calls.',
   },
   /**
@@ -151,9 +144,17 @@ export const OKE_ERRORS = {
    */
   ORPHAN_EMIT: {
     code: 1042,
-    cause:
-      'Flow "{flow}" emits signal "{resource}" with no subscriber.',
-    fix: 'Add `on({resource}, …)` or mark the signal `{ optional: true }`.',
+    cause: 'Flow "{flow}" emits signal "{resource}" with no subscriber.',
+    fix: "Add `on({resource}, …)` or mark the signal `{ optional: true }`.",
+  },
+  /**
+   * Domain table/column missing under docker/prod (migrations not applied).
+   * Store/DDL band starts at 1100.
+   */
+  DOMAIN_SCHEMA_MISSING: {
+    code: 1101,
+    cause: "domain table not found — migrations have not been applied.",
+    fix: "run `oke db migrate` against this environment.",
   },
 } as const satisfies Record<string, OkeErrorDefinition>;
 
@@ -164,10 +165,7 @@ export const OKE_ERRORS = {
  * @param params - Interpolation params
  * @returns Never
  */
-export function throwOke(
-  key: keyof typeof OKE_ERRORS,
-  params: OkeErrorParams = {},
-): never {
+export function throwOke(key: keyof typeof OKE_ERRORS, params: OkeErrorParams = {}): never {
   throw new OkeError(OKE_ERRORS[key], params);
 }
 
@@ -176,9 +174,7 @@ export function throwOke(
  *
  * @param code - Permanent numeric code
  */
-export function lookupOkeError(
-  code: OkeErrorCode,
-): OkeErrorDefinition | undefined {
+export function lookupOkeError(code: OkeErrorCode): OkeErrorDefinition | undefined {
   for (const def of Object.values(OKE_ERRORS)) {
     if (def.code === code) return def;
   }
@@ -192,14 +188,9 @@ export function lookupOkeError(
  * @param data - Error payload
  * @param opts - Optional message override
  */
-export function fail<E>(
-  code: string,
-  data: E,
-  opts?: FailOptions,
-): FlowFailure<E> {
-  const error: FlowErrorValue<E> = opts?.message !== undefined
-    ? { code, data, message: opts.message }
-    : { code, data };
+export function fail<E>(code: string, data: E, opts?: FailOptions): FlowFailure<E> {
+  const error: FlowErrorValue<E> =
+    opts?.message !== undefined ? { code, data, message: opts.message } : { code, data };
   return { data: null, error };
 }
 

package/src/kernel/flow.test.ts

@@ -2,12 +2,7 @@ import { describe, expect, test, beforeEach } from "bun:test";
 import { oke } from "./app.ts";
 import { flow, isFlow, resetFlowSeq } from "./flow.ts";
 import { on, resetBindings } from "./on.ts";
-import {
-  every,
-  http,
-  internal,
-  table,
-} from "./triggers.ts";
+import { every, http, internal, table } from "./triggers.ts";
 
 beforeEach(() => {
   resetBindings();
@@ -55,11 +50,7 @@ describe("flow — one species", () => {
     expect(app.bindings[0]?.flow).toBe(shared);
     expect(app.bindings[1]?.flow).toBe(shared);
 
-    const httpResult = await app.execute(
-      shared,
-      { n: 3 },
-      shared.triggers[0]!,
-    );
+    const httpResult = await app.execute(shared, { n: 3 }, shared.triggers[0]!);
     const signalResults = await app.dispatchSignal("order-placed", { n: 4 });
 
     expect(httpResult.output).toEqual({ n: 6 });
@@ -126,29 +117,25 @@ describe("five trigger kinds", () => {
 
     const app = oke({ name: "five" });
 
-    const res = await app.fetch(
-      new Request("http://localhost/abc", { method: "GET" }),
-    );
+    const res = await app.fetch(new Request("http://localhost/abc", { method: "GET" }));
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ data: { code: "abc" }, error: null });
 
     await app.dispatchEvery("1h");
     await app.dispatchSignal("link-clicked", { code: "sa" });
-    await app.dispatchCdc("orders", {
-      before: { status: "open" },
-      after: { status: "paid" },
-    }, "status");
+    await app.dispatchCdc(
+      "orders",
+      {
+        before: { status: "open" },
+        after: { status: "paid" },
+      },
+      "status",
+    );
 
     const internalResult = await app.call("t.internal");
     expect(internalResult).toEqual({ ok: true });
 
-    expect(seen).toEqual([
-      "http:abc",
-      "every",
-      "signal:sa",
-      "cdc:open->paid",
-      "internal",
-    ]);
+    expect(seen).toEqual(["http:abc", "every", "signal:sa", "cdc:open->paid", "internal"]);
     expect(httpFlow.triggers[0]?.kind).toBe("http");
   });
 });