okengine 0.2.6 → 0.3.2

package/src/kernel/hooks.test.ts

@@ -26,11 +26,9 @@ describe("hooks — order and composition", () => {
 
   test("mergeHooks is app → unit → flow, registration order within", () => {
     const order: string[] = [];
-    const mark =
-      (label: string) =>
-      () => {
-        order.push(label);
-      };
+    const mark = (label: string) => () => {
+      order.push(label);
+    };
 
     const merged = mergeHooks(
       { onRequest: [mark("app1"), mark("app2")] },
@@ -66,11 +64,13 @@ describe("hooks — order and composition", () => {
         order.push("handler");
         return { ok: true };
       },
-    }).hook("beforeHandle", () => {
-      order.push("flow:beforeHandle");
-    }).hook("afterHandle", () => {
-      order.push("flow:afterHandle");
-    });
+    })
+      .hook("beforeHandle", () => {
+        order.push("flow:beforeHandle");
+      })
+      .hook("afterHandle", () => {
+        order.push("flow:afterHandle");
+      });
 
     on(http.get("/ordered"), f);
 
@@ -146,6 +146,39 @@ describe("hooks — order and composition", () => {
     expect(order).toEqual(["onAuth", "onResponse"]);
   });
 
+  test("onResponse sees the serialized data response and may replace it", async () => {
+    let seenAtHook: Response | undefined;
+
+    on(
+      http.get("/data"),
+      flow({
+        name: "data",
+        do: () => ({ ok: true }),
+      }),
+    );
+
+    const app = oke({ name: "data-res" }).hook("onResponse", (ctx) => {
+      seenAtHook = ctx.response;
+      if (!ctx.response) return;
+      const headers = new Headers(ctx.response.headers);
+      headers.set("x-stamped", "yes");
+      ctx.response = new Response(ctx.response.body, {
+        status: ctx.response.status,
+        headers,
+      });
+    });
+
+    const res = await app.fetch(new Request("http://localhost/data"));
+    expect(res.status).toBe(200);
+    expect(res.headers.get("x-stamped")).toBe("yes");
+    // The hook saw the real serialized response, not undefined.
+    expect(seenAtHook).toBeDefined();
+    expect(seenAtHook!.headers.get("content-type")).toContain("application/json");
+    // The body survived the rebuild untouched.
+    const body = (await res.json()) as { data?: { ok: boolean } };
+    expect(body.data?.ok).toBe(true);
+  });
+
   test("hook short-circuits with FlowFailure and runs onError", async () => {
     const order: string[] = [];
 

package/src/kernel/hooks.ts

@@ -40,9 +40,7 @@ export const BEFORE_HANDLER_STAGES: readonly HookStage[] = [
 ] as const;
 
 /** Stages that run after a successful handler (before onResponse). */
-export const AFTER_HANDLER_STAGES: readonly HookStage[] = [
-  "afterHandle",
-] as const;
+export const AFTER_HANDLER_STAGES: readonly HookStage[] = ["afterHandle"] as const;
 
 /** All user-registrable stages in pipeline order. */
 export const HOOK_STAGES: readonly HookStage[] = [
@@ -97,11 +95,7 @@ export type HookFn = (
   ctx: InvocationContext,
   fxOrErr: Fx | unknown,
   fx?: Fx,
-) =>
-  | void
-  | Response
-  | FlowFailure
-  | Promise<void | Response | FlowFailure>;
+) => void | Response | FlowFailure | Promise<void | Response | FlowFailure>;
 
 /** Hook bag keyed by stage. */
 export type HookMap = Partial<Record<HookStage, HookFn[]>>;
@@ -156,19 +150,34 @@ export interface PipelineResult {
   readonly response: Response | undefined;
 }
 
+/** Serialize a pipeline outcome into an HTTP response (app-layer encoder). */
+export type PipelineEncoder = (result: {
+  readonly response?: Response | undefined;
+  readonly failure?: FlowFailure | undefined;
+  readonly output?: unknown;
+  readonly error?: unknown;
+}) => Response;
+
 /**
  * Run the seven-stage pipeline around `handler`.
  *
+ * When `encode` is given (HTTP triggers), the outcome is serialized into
+ * `ctx.response` **before** `onResponse`, so the last stage sees — and may
+ * replace — the final response, as {@link InvocationContext.response}
+ * documents. Without `encode` (non-HTTP triggers) behavior is unchanged.
+ *
  * @param ctx - Invocation context
  * @param fx - Fx door
  * @param hooks - Merged hooks
  * @param handler - Flow body (the `handler` stage)
+ * @param encode - HTTP response encoder (e.g. `encodeExecuteResult`)
  */
 export async function runPipeline(
   ctx: InvocationContext,
   fx: Fx,
   hooks: HookMap,
   handler: () => unknown | Promise<unknown>,
+  encode?: PipelineEncoder,
 ): Promise<PipelineResult> {
   let shortCircuit: "response" | "error" | undefined;
 
@@ -221,6 +230,13 @@ export async function runPipeline(
     await runStage("onError", hooks, ctx, fx);
   }
 
+  // Serialize before the last stage so `onResponse` sees the final response
+  // (short-circuit wins; encoder input mirrors the app layer exactly).
+  if (encode !== undefined && ctx.response === undefined) {
+    const failure = isFlowFailure(ctx.error) ? ctx.error : undefined;
+    ctx.response = encode({ failure, output: ctx.result, error: ctx.error });
+  }
+
   await runStage("onResponse", hooks, ctx, fx);
 
   const failure = isFlowFailure(ctx.error) ? ctx.error : undefined;
@@ -247,10 +263,7 @@ async function runStage(
     const started = pluginId !== undefined ? performance.now() : 0;
     try {
       // Spec apps use `.hook("onError", (ctx, err, fx) => …)`.
-      returned =
-        stage === "onError"
-          ? await fn(ctx, ctx.error, fx)
-          : await fn(ctx, fx);
+      returned = stage === "onError" ? await fn(ctx, ctx.error, fx) : await fn(ctx, fx);
     } catch (err) {
       if (pluginId !== undefined) {
         recordHookCost(pluginId, stage, performance.now() - started);

package/src/kernel/index.ts

@@ -50,11 +50,7 @@ export type {
   RoutesFromAdoptArgs,
 } from "./adopt-routes.ts";
 
-export {
-  createCapabilityToken,
-  effectsFieldOf,
-  type CapabilityToken,
-} from "./capability.ts";
+export { createCapabilityToken, effectsFieldOf, type CapabilityToken } from "./capability.ts";
 
 export {
   createEffectLedger,
@@ -107,6 +103,8 @@ export {
 export {
   createFx,
   createFxContext,
+  isJsonResult,
+  jsonResultBrand,
   resolveName,
   resolveStoreRef,
   type CreateFxOptions,
@@ -117,12 +115,14 @@ export {
   type FxCallHandler,
   type FxClock,
   type FxContext,
+  type FxJson,
   type FxLog,
   type FxOperator,
   type FxSearchOptions,
   type FxSendOptions,
   type FxStoreHandle,
   type FxTenant,
+  type JsonResult,
   type NamedRef,
 } from "./fx.ts";
 
@@ -181,12 +181,7 @@ export {
   type HookCostSummary,
 } from "./hook-timing.ts";
 
-export {
-  listBindings,
-  on,
-  resetBindings,
-  type Binding,
-} from "./on.ts";
+export { listBindings, on, resetBindings, type Binding } from "./on.ts";
 
 export {
   isPlugin,
@@ -205,6 +200,7 @@ export {
   type PluginOptions,
   type PluginRegistration,
   type TableContribution,
+  type PluginTableOptions,
 } from "./plugin.ts";
 
 export {
@@ -244,6 +240,7 @@ export {
   every,
   http,
   internal,
+  isResourceMount,
   isSignalTriggerSource,
   normalizeTrigger,
   table,
@@ -254,6 +251,8 @@ export {
   type HttpMethod,
   type HttpTrigger,
   type InternalTrigger,
+  type ResourceFlowBag,
+  type ResourceMount,
   type SignalAsTrigger,
   type SignalSource,
   type TableHandle,
@@ -270,11 +269,6 @@ export {
   type JourneySlo,
 } from "./journey.ts";
 
-export {
-  unit,
-  consumeUnitPlugins,
-  resetUnitPlugins,
-  type UnitBag,
-} from "./unit.ts";
+export { unit, consumeUnitPlugins, resetUnitPlugins, type UnitBag } from "./unit.ts";
 
 export { rateLimit, type RateLimitPluginOptions } from "./rate-limit.ts";

package/src/kernel/journal.ts

@@ -11,11 +11,7 @@ import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 
 /** Status of a durable run. */
-export type JournalRunStatus =
-  | "running"
-  | "sleeping"
-  | "completed"
-  | "failed";
+export type JournalRunStatus = "running" | "sleeping" | "completed" | "failed";
 
 /** A completed named step. */
 export interface JournalStepEntry {
@@ -44,10 +40,7 @@ export interface JournalEffectEntry {
 }
 
 /** One journaled event in call order. */
-export type JournalEntry =
-  | JournalStepEntry
-  | JournalSleepEntry
-  | JournalEffectEntry;
+export type JournalEntry = JournalStepEntry | JournalSleepEntry | JournalEffectEntry;
 
 /** Persisted durable run. */
 export interface JournalRun {
@@ -103,9 +96,7 @@ export interface JournalStore {
 }
 
 /** In-memory journal store. */
-export function createMemoryJournalStore(
-  seed?: readonly JournalRun[],
-): JournalStore {
+export function createMemoryJournalStore(seed?: readonly JournalRun[]): JournalStore {
   const runs = new Map<string, JournalRun>();
   for (const r of seed ?? []) {
     runs.set(r.id, cloneRun(r));
@@ -147,10 +138,7 @@ export function createFileJournalStore(path: string): JournalStore {
 
   async function flush(map: Map<string, JournalRun>): Promise<void> {
     await mkdir(dirname(path), { recursive: true });
-    await Bun.write(
-      path,
-      JSON.stringify({ runs: [...map.values()] }, null, 2),
-    );
+    await Bun.write(path, JSON.stringify({ runs: [...map.values()] }, null, 2));
   }
 
   return {
@@ -204,11 +192,7 @@ export interface JournalSession {
    * @param duration - Duration string (`7d`, `2m`, …)
    * @param parseMs - Duration → milliseconds
    */
-  sleep(
-    label: string,
-    duration: string,
-    parseMs: (duration: string) => number,
-  ): Promise<void>;
+  sleep(label: string, duration: string, parseMs: (duration: string) => number): Promise<void>;
   /**
    * Journal an arbitrary fx effect (replay returns recorded value).
    *
@@ -216,11 +200,7 @@ export interface JournalSession {
    * @param resource - Resource ref
    * @param execute - Side-effecting body
    */
-  effect<T>(
-    effectKind: string,
-    resource: string,
-    execute: () => T | Promise<T>,
-  ): Promise<T>;
+  effect<T>(effectKind: string, resource: string, execute: () => T | Promise<T>): Promise<T>;
   /** Persist current run status / output. */
   commit(
     status: JournalRunStatus,
@@ -327,11 +307,7 @@ export function createJournal(options: CreateJournalOptions): Journal {
       ): Promise<T> {
         for (let i = cursor; i < run.entries.length; i++) {
           const e = run.entries[i]!;
-          if (
-            e.kind === "effect" &&
-            e.effectKind === effectKind &&
-            e.resource === resource
-          ) {
+          if (e.kind === "effect" && e.effectKind === effectKind && e.resource === resource) {
             cursor = i + 1;
             return e.value as T;
           }

package/src/kernel/on.ts

@@ -6,15 +6,13 @@
  * The return type carries the bound trigger so `typeof app` can derive REST.
  */
 
+import { isFlow, type AnyFlowDef, type FlowDef, type FlowErrorMap } from "./flow.ts";
 import {
-  isFlow,
-  type AnyFlowDef,
-  type FlowDef,
-  type FlowErrorMap,
-} from "./flow.ts";
-import {
+  isResourceMount,
   normalizeTrigger,
   type BoundTriggerOf,
+  type ResourceFlowBag,
+  type ResourceMount,
   type SignalSource,
   type Trigger,
 } from "./triggers.ts";
@@ -44,17 +42,55 @@ export function on<
 >(
   trigger: T,
   flowDef: FlowDef<I, O, E, D, Trigger | undefined>,
-): FlowDef<I, O, E, D, BoundTriggerOf<T>> {
+): FlowDef<I, O, E, D, BoundTriggerOf<T>>;
+/**
+ * Mount a CRUD resource (`http.resource(path, ops)`): registers the five
+ * verb bindings and returns the ops bag (unit keys `list` · `create` ·
+ * `get` · `update` · `remove`) for `.adopt({ notes })`.
+ *
+ * @param mount - Branded {@link ResourceMount}
+ */
+export function on(mount: ResourceMount): ResourceFlowBag;
+export function on(
+  triggerOrMount: Trigger | SignalSource | ResourceMount,
+  flowDef?: FlowDef<any, any, any, any, Trigger | undefined>,
+): unknown {
+  if (isResourceMount(triggerOrMount)) {
+    if (flowDef !== undefined) {
+      throw new TypeError("on(http.resource(...)) takes no second argument");
+    }
+    const byIdVerb: Partial<Record<string, "get" | "update" | "remove">> = {
+      GET: "get",
+      PATCH: "update",
+      DELETE: "remove",
+    };
+    const baseVerb: Partial<Record<string, "list" | "create">> = {
+      GET: "list",
+      POST: "create",
+    };
+    const ops: Record<string, unknown> = {};
+    for (const { trigger, flow } of triggerOrMount.mounts) {
+      const key = trigger.path.endsWith("/:id")
+        ? byIdVerb[trigger.method]
+        : baseVerb[trigger.method];
+      if (key === undefined || !isFlow(flow)) {
+        throw new TypeError("on(http.resource(...)) expects the five CRUD FlowDefs");
+      }
+      on(trigger, flow as FlowDef<any, any, any, any, Trigger | undefined>);
+      ops[key] = flow;
+    }
+    return ops as unknown as ResourceFlowBag;
+  }
   if (!isFlow(flowDef)) {
     throw new TypeError("on() expected a flow() definition as the second argument");
   }
-  const normalized = normalizeTrigger(trigger);
+  const normalized = normalizeTrigger(triggerOrMount as Trigger | SignalSource);
   const list = flowDef.triggers as Trigger[];
   list.push(normalized);
   // Stamp runtime carrier for the first bound trigger (type follows BoundTriggerOf).
   (flowDef as { $trigger: Trigger }).$trigger = normalized;
   bindings.push({ trigger: normalized, flow: flowDef as AnyFlowDef });
-  return flowDef as unknown as FlowDef<I, O, E, D, BoundTriggerOf<T>>;
+  return flowDef;
 }
 
 /**

package/src/kernel/pipeline.test.ts

@@ -9,10 +9,7 @@
 
 import { describe, expect, test } from "bun:test";
 import { z } from "zod";
-import {
-  createSessionStore,
-  issueSessionWithScopes,
-} from "../auth/sessions.ts";
+import { createSessionStore, issueSessionWithScopes } from "../auth/sessions.ts";
 import { createClockRuntime } from "../elements/clock.ts";
 import { gate } from "../elements/gate.ts";
 import { createRunsRuntime, memoryRunsDriver } from "../runs/index.ts";
@@ -20,16 +17,11 @@ import { oke } from "./app.ts";
 import { flow, resetFlowSeq } from "./flow.ts";
 import { on, resetBindings } from "./on.ts";
 import { http } from "./triggers.ts";
-import {
-  gateDenialFailure,
-  recordGateEvaluations,
-} from "./pipeline.ts";
+import { gateDenialFailure, recordGateEvaluations } from "./pipeline.ts";
 import { createRunTelemetry } from "./run-telemetry.ts";
 
 const member = gate.policy("member", ({ auth }) => !!auth.verified);
-const canOrder = gate.policy("order:create", ({ auth }) =>
-  auth.scopes.has("order:create"),
-);
+const canOrder = gate.policy("order:create", ({ auth }) => auth.scopes.has("order:create"));
 
 describe("gateDenialFailure", () => {
   test("anonymous → Unauthorized; authed → Forbidden; rate → RateLimited", () => {
@@ -217,18 +209,17 @@ describe("pipeline — Bearer cryptographic verification", () => {
     const app = oke({
       name: "auth-forge",
       gates: [member],
-      env: "dev",
+      env: "local",
       auth: { secret: "hmac-secret-for-tests", sessions },
       startScheduler: false,
     });
-    await app.boot({ env: "dev", gates: [member], startScheduler: false });
+    await app.boot({ env: "local", gates: [member], startScheduler: false });
 
     const res = await app.fetch(
       new Request("http://localhost/secure", {
         method: "GET",
         headers: {
-          authorization:
-            "Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJoYWNrZXIifQ.forgedsignature",
+          authorization: "Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJoYWNrZXIifQ.forgedsignature",
         },
       }),
     );
@@ -272,13 +263,13 @@ describe("pipeline — Bearer cryptographic verification", () => {
     const app = oke({
       name: "auth-expired",
       gates: [member],
-      env: "dev",
+      env: "local",
       auth: { secret, sessions, now: () => nowMs },
       elements: { clock: clockRt },
       startScheduler: false,
     });
     await app.boot({
-      env: "dev",
+      env: "local",
       gates: [member],
       startScheduler: false,
       elements: { clock: clockRt },
@@ -324,10 +315,10 @@ describe("pipeline — Bearer cryptographic verification", () => {
     const app = oke({
       name: "no-inject",
       gates: [member],
-      env: "dev",
+      env: "local",
       startScheduler: false,
     });
-    await app.boot({ env: "dev", gates: [member], startScheduler: false });
+    await app.boot({ env: "local", gates: [member], startScheduler: false });
 
     const result = await app.execute(
       app.flow("orders.inject")!,

package/src/kernel/pipeline.ts

@@ -74,18 +74,14 @@ export type GateDenialCode = "Unauthorized" | "Forbidden" | "RateLimited";
  * @param evaluation - First denying evaluation
  * @param ctx - Policy context at denial time
  */
-export function gateDenialFailure(
-  evaluation: GateEvaluation,
-  ctx: GatePolicyContext,
-): FlowFailure {
+export function gateDenialFailure(evaluation: GateEvaluation, ctx: GatePolicyContext): FlowFailure {
   if (evaluation.kind === "rate" || evaluation.reason === "rate limited") {
     return fail("RateLimited", {
       retryAfterMs: evaluation.retryAfterMs ?? 0,
     });
   }
 
-  const authenticated =
-    ctx.auth.userId !== null && ctx.auth.userId !== undefined;
+  const authenticated = ctx.auth.userId !== null && ctx.auth.userId !== undefined;
   if (!authenticated) {
     return fail("Unauthorized", {});
   }
@@ -102,9 +98,7 @@ export function gateDenialFailure(
  */
 export function gateNamesOf(trigger: Trigger): string[] {
   if (trigger.kind !== "http") return [];
-  return (trigger as HttpTrigger).gates.map((g) =>
-    typeof g === "string" ? g : g.name,
-  );
+  return (trigger as HttpTrigger).gates.map((g) => (typeof g === "string" ? g : g.name));
 }
 
 /**
@@ -129,10 +123,7 @@ export function recordGateEvaluations(
  * @param bag - Mutable principal bag
  * @param resolved - Identity
  */
-export function applyPrincipal(
-  bag: PrincipalBag,
-  resolved: ResolvedPrincipal | undefined,
-): void {
+export function applyPrincipal(bag: PrincipalBag, resolved: ResolvedPrincipal | undefined): void {
   if (!resolved) return;
   if (resolved.plane === "operator" || resolved.operatorId !== undefined) {
     bag.operator.id = resolved.operatorId ?? null;
@@ -217,10 +208,7 @@ export function createElementPipelineHooks(deps: PipelineDeps): {
  * @param fx - Fx door
  * @param ctx - Invocation context (for IP / meta)
  */
-export function policyContextOf(
-  fx: Fx,
-  ctx: InvocationContext,
-): GatePolicyContext {
+export function policyContextOf(fx: Fx, ctx: InvocationContext): GatePolicyContext {
   const auth = fx.auth as FxAuth;
   const operator = fx.operator as FxOperator;
   const ip =

package/src/kernel/plug.ts

@@ -14,10 +14,7 @@
 
 import type { AnyFlowDef } from "./flow.ts";
 import { isPlugin, type DecorationsOf, type PluginDef } from "./plugin.ts";
-import {
-  type PluginRegistry,
-  type PluginScope,
-} from "./registry.ts";
+import { type PluginRegistry, type PluginScope } from "./registry.ts";
 
 /**
  * Apply a plugin to a registry at the given scope.
@@ -43,10 +40,8 @@ export function applyPlugin(
  * @typeParam Base - Existing decorations
  * @typeParam P - Plugin being plugged
  */
-export type AccumulateDecorations<
-  Base extends Record<string, unknown>,
-  P,
-> = Base & DecorationsOf<P>;
+export type AccumulateDecorations<Base extends Record<string, unknown>, P> = Base &
+  DecorationsOf<P>;
 
 /** Something that can receive `.plug()` with type accumulation. */
 export interface Pluggable<D extends Record<string, unknown> = {}> {
@@ -55,9 +50,7 @@ export interface Pluggable<D extends Record<string, unknown> = {}> {
    *
    * @param pluginDef - Plugin from {@link plugin}
    */
-  plug<P extends PluginDef>(
-    pluginDef: P,
-  ): Pluggable<AccumulateDecorations<D, P>>;
+  plug<P extends PluginDef>(pluginDef: P): Pluggable<AccumulateDecorations<D, P>>;
 }
 
 /**

package/src/kernel/plugin/conflicts.test.ts

@@ -10,19 +10,11 @@ describe("plugin conflict detection", () => {
   test("table-name collision fails the boot with both plugin names", () => {
     const registry = createPluginRegistry();
 
-    registry.plug(
-      plugin("audit", { version: "1.0.0" }).table("events"),
-      { kind: "app" },
-    );
+    registry.plug(plugin("audit", { version: "1.0.0" }).table("events"), { kind: "app" });
 
     expect(() =>
-      registry.plug(
-        plugin("billing", { version: "1.0.0" }).table("events"),
-        { kind: "app" },
-      ),
-    ).toThrow(
-      'Plugin conflict: table "events" claimed by "audit" and "billing"',
-    );
+      registry.plug(plugin("billing", { version: "1.0.0" }).table("events"), { kind: "app" }),
+    ).toThrow('Plugin conflict: table "events" claimed by "audit" and "billing"');
   });
 
   test("panel-id collision names both sides", () => {
@@ -79,28 +71,24 @@ describe("plugin conflict detection", () => {
       config: { max: 30 },
     }).hook("onRequest", () => {});
 
-    expect(
-      registry.plug(p, { kind: "unit", name: "orders" }),
-    ).toBeDefined();
-    expect(
-      registry.plug(p, { kind: "unit", name: "payments" }),
-    ).toBeDefined();
+    expect(registry.plug(p, { kind: "unit", name: "orders" })).toBeDefined();
+    expect(registry.plug(p, { kind: "unit", name: "payments" })).toBeDefined();
     expect(registry.installed).toHaveLength(2);
   });
 
   test("same plugin twice with conflicting config is a boot error", () => {
     const registry = createPluginRegistry();
 
-    registry.plug(
-      plugin("rate-limit", { version: "1.0.0", config: { max: 30 } }),
-      { kind: "unit", name: "orders" },
-    );
+    registry.plug(plugin("rate-limit", { version: "1.0.0", config: { max: 30 } }), {
+      kind: "unit",
+      name: "orders",
+    });
 
     expect(() =>
-      registry.plug(
-        plugin("rate-limit", { version: "1.0.0", config: { max: 60 } }),
-        { kind: "unit", name: "payments" },
-      ),
+      registry.plug(plugin("rate-limit", { version: "1.0.0", config: { max: 60 } }), {
+        kind: "unit",
+        name: "payments",
+      }),
     ).toThrow(/conflicting config/);
   });
 });

package/src/kernel/plugin/decorate.test.ts

@@ -15,8 +15,7 @@ beforeEach(() => {
 });
 
 /** Compile-time assert: `Actual` extends `Expected`. */
-type ExpectExtends<Actual, Expected> =
-  Actual extends Expected ? true : false;
+type ExpectExtends<Actual, Expected> = Actual extends Expected ? true : false;
 
 describe("plugin decorate — types and runtime", () => {
   test("decoration is visible in downstream handlers", async () => {
@@ -45,14 +44,12 @@ describe("plugin decorate — types and runtime", () => {
   });
 
   test("types accumulate through .plug()", () => {
-    const withAudit = plugin("audit", { version: "1.0.0" }).decorate(
-      "audit",
-      { enabled: true as const },
-    );
-    const withBilling = plugin("billing", { version: "1.0.0" }).decorate(
-      "billing",
-      { currency: "SAR" as const },
-    );
+    const withAudit = plugin("audit", { version: "1.0.0" }).decorate("audit", {
+      enabled: true as const,
+    });
+    const withBilling = plugin("billing", { version: "1.0.0" }).decorate("billing", {
+      currency: "SAR" as const,
+    });
 
     const app = oke({ name: "types" }).plug(withAudit).plug(withBilling);
 
@@ -98,9 +95,7 @@ describe("plugin decorate — types and runtime", () => {
     );
 
     const app = oke({ name: "deco-scope" });
-    app.unit("orders").plug(
-      plugin("flag", { version: "1.0.0" }).decorate("flag", "orders-only"),
-    );
+    app.unit("orders").plug(plugin("flag", { version: "1.0.0" }).decorate("flag", "orders-only"));
 
     await app.fetch(new Request("http://localhost/orders"));
     await app.fetch(new Request("http://localhost/payments"));