okengine 0.2.6 → 0.2.8

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");
   });
 });

package/src/kernel/flow.ts

@@ -7,20 +7,14 @@
  */
 
 import type { Effects, FlowPlane, Slo } from "../manifest/types.ts";
-import type {
-  InferSchemaOutput,
-  SchemaInput,
-} from "../validation/standard-schema.ts";
+import type { InferSchemaOutput, SchemaInput } from "../validation/standard-schema.ts";
 import type { FlowFailure } from "./errors.ts";
 import type { Fx } from "./fx.ts";
 import type { HookFn, HookStage } from "./hooks.ts";
 import type { PluginDef } from "./plugin.ts";
 import type { Trigger } from "./triggers.ts";
 
-export type {
-  SchemaInput,
-  StandardSchemaV1,
-} from "../validation/standard-schema.ts";
+export type { SchemaInput, StandardSchemaV1 } from "../validation/standard-schema.ts";
 
 /** Result of a Standard Schema validate call (re-export shape). */
 export type StandardSchemaResult<Output> =
@@ -42,11 +36,7 @@ export type FlowHandler<I = unknown, O = unknown> = (
 ) => O | FlowFailure | Promise<O | FlowFailure>;
 
 /** Options for {@link flow}. */
-export interface FlowOptions<
-  I = unknown,
-  O = unknown,
-  E extends FlowErrorMap = FlowErrorMap,
-> {
+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. */
@@ -192,13 +182,7 @@ export interface FlowDef<
    */
   plug<P extends PluginDef>(
     pluginDef: P,
-  ): FlowDef<
-    I,
-    O,
-    E,
-    D & (P extends PluginDef<infer PD> ? PD : Record<string, never>),
-    T
-  >;
+  ): FlowDef<I, O, E, D & (P extends PluginDef<infer PD> ? PD : Record<string, never>), T>;
 }
 
 /** Unique brand symbol for {@link FlowDef}. */
@@ -222,11 +206,7 @@ export function flow<Opts extends FlowOptions<any, any, any>>(
   const hooks: Partial<Record<HookStage, HookFn[]>> = {};
   const pendingPlugins: PluginDef[] = [];
 
-  const def: FlowDef<
-    InferFlowIn<Opts>,
-    InferFlowOut<Opts>,
-    InferFlowErrors<Opts>
-  > = {
+  const def: FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>, InferFlowErrors<Opts>> = {
     [flowBrand]: true,
     name,
     unit: options.unit,

package/src/kernel/fx.test.ts

@@ -1,19 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import { createCapabilityToken } from "./capability.ts";
 import { createEffectLedger, reversibilityOf } from "./effects.ts";
-import {
-  fail,
-  formatOkeMessage,
-  lookupOkeError,
-  OKE_ERRORS,
-  OkeError,
-} from "./errors.ts";
-import {
-  createFx,
-  createFxContext,
-  type Fx,
-  type FxStubStoreHandle,
-} from "./fx.ts";
+import { fail, formatOkeMessage, lookupOkeError, OKE_ERRORS, OkeError } from "./errors.ts";
+import { createFx, createFxContext, type Fx, type FxStubStoreHandle } from "./fx.ts";
 
 /** Narrow stub handle for tests that exercise the in-memory store. */
 function stub(fx: Fx, ref: string): FxStubStoreHandle {
@@ -37,16 +26,10 @@ describe("fx — capability enforcement", () => {
     expect(err).toBeInstanceOf(OkeError);
     const oke = err as OkeError;
     expect(oke.code).toBe(1001);
-    expect(oke.causeText).toBe(
-      'Flow "bookings.create" reads "sql:users" without declaring it.',
-    );
-    expect(oke.fix).toBe(
-      'Add "sql:users" to this flow\'s effects.reads.',
-    );
+    expect(oke.causeText).toBe('Flow "bookings.create" reads "sql:users" without declaring it.');
+    expect(oke.fix).toBe('Add "sql:users" to this flow\'s effects.reads.');
     expect(oke.docsUrl).toBe("https://okengine.vercel.app/e/1001");
-    expect(oke.message).toBe(
-      formatOkeMessage(1001, oke.causeText, oke.fix, oke.docsUrl),
-    );
+    expect(oke.message).toBe(formatOkeMessage(1001, oke.causeText, oke.fix, oke.docsUrl));
   });
 
   test("declared store read succeeds", async () => {
@@ -79,21 +62,13 @@ describe("fx — effect ledger", () => {
     await fx.emit("order-placed", { orderId: "o1" });
 
     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.map((e) => e.resource)).toEqual([
       "sql:bookings",
       "sql:bookings",
       "order-placed",
     ]);
-    expect(ledger.entries.map((e) => e.reversibility)).toEqual([
-      "none",
-      "reversible",
-      "deferred",
-    ]);
+    expect(ledger.entries.map((e) => e.reversibility)).toEqual(["none", "reversible", "deferred"]);
   });
 
   test("all seven kinds receive the correct reversibility tier via fx", async () => {
@@ -123,15 +98,7 @@ describe("fx — effect ledger", () => {
 
     expect(ledger.entries).toHaveLength(7);
     const kinds = ledger.entries.map((e) => e.kind);
-    expect(kinds).toEqual([
-      "read",
-      "write",
-      "emit",
-      "send",
-      "ask",
-      "secret",
-      "call",
-    ]);
+    expect(kinds).toEqual(["read", "write", "emit", "send", "ask", "secret", "call"]);
     for (const entry of ledger.entries) {
       expect(entry.reversibility).toBe(reversibilityOf(entry.kind));
     }
@@ -224,9 +191,13 @@ describe("errors — registry", () => {
 
   test("fx.fail returns a value, not an exception", () => {
     const fx = createFx({ flow: "x", effects: {} });
-    const result = fx.fail("FlightFull", { seatsLeft: 0 }, {
-      message: "full",
-    });
+    const result = fx.fail(
+      "FlightFull",
+      { seatsLeft: 0 },
+      {
+        message: "full",
+      },
+    );
     expect(result).toEqual({
       data: null,
       error: { code: "FlightFull", data: { seatsLeft: 0 }, message: "full" },

package/src/kernel/fx.ts

@@ -10,27 +10,14 @@
  */
 
 import type { Effects, ResourceRef } from "../manifest/types.ts";
-import type {
-  StoreDecl,
-  StoreHandle,
-  StoreRuntime,
-  SqlStoreHandle,
-} from "../elements/store.ts";
+import type { StoreDecl, StoreHandle, StoreRuntime, SqlStoreHandle } from "../elements/store.ts";
 import type { SignalRuntime } from "../elements/signal.ts";
 import type { VaultRuntime } from "../elements/vault.ts";
 import type { ChannelRuntime } from "../elements/channel.ts";
 import type { AiRuntime } from "../elements/ai.ts";
 import { parseDurationMs } from "../elements/clock/duration.ts";
-import {
-  createCapabilityToken,
-  type CapabilityToken,
-} from "./capability.ts";
-import {
-  createEffectLedger,
-  recordEffect,
-  reversibilityOf,
-  type EffectLedger,
-} from "./effects.ts";
+import { createCapabilityToken, type CapabilityToken } from "./capability.ts";
+import { createEffectLedger, recordEffect, reversibilityOf, type EffectLedger } from "./effects.ts";
 import {
   DryRunWriteIsolationError,
   isDryRun,
@@ -202,17 +189,15 @@ export interface FxSearchOptions {
  * Implementations must be plain objects so tests can replace `fx` wholesale.
  */
 export interface Fx {
-/**
- * Open a store handle for `ref` (capability checked on each op).
- *
- * When a {@link CreateFxOptions.storeRuntime} is bound and `ref` is a
- * registered store declaration, returns the driver-backed handle.
- *
- * @param ref - Store resource ref, named handle, or store declaration
- */
-  store(
-    ref: NamedRef | { readonly ref: ResourceRef } | StoreDecl,
-  ): FxStoreHandle;
+  /**
+   * Open a store handle for `ref` (capability checked on each op).
+   *
+   * When a {@link CreateFxOptions.storeRuntime} is bound and `ref` is a
+   * registered store declaration, returns the driver-backed handle.
+   *
+   * @param ref - Store resource ref, named handle, or store declaration
+   */
+  store(ref: NamedRef | { readonly ref: ResourceRef } | StoreDecl): FxStoreHandle;
   /**
    * Emit a signal (records `emit`).
    *
@@ -251,11 +236,7 @@ export interface Fx {
    * @param input - Prompt input
    * @param opts - Model routing opts
    */
-  ask(
-    prompt: NamedRef,
-    input?: unknown,
-    opts?: FxAskOptions,
-  ): Promise<Record<string, unknown>>;
+  ask(prompt: NamedRef, input?: unknown, opts?: FxAskOptions): Promise<Record<string, unknown>>;
   /**
    * Similarity search over an index/embed (records `read` on the embed ref).
    *
@@ -263,21 +244,14 @@ export interface Fx {
    * @param query - Query text or vector
    * @param opts - Search options
    */
-  search(
-    embed: NamedRef,
-    query: unknown,
-    opts?: FxSearchOptions,
-  ): Promise<unknown[]>;
+  search(embed: NamedRef, query: unknown, opts?: FxSearchOptions): Promise<unknown[]>;
   /**
    * Run a bounded AI agent (records `ask`).
    *
    * @param agent - Agent name or handle
    * @param input - Agent input (`{ message }` or string)
    */
-  run(
-    agent: NamedRef,
-    input?: unknown,
-  ): Promise<unknown>;
+  run(agent: NamedRef, input?: unknown): Promise<unknown>;
   /**
    * Stream model tokens (records `ask`). Returns an async iterable of chunks.
    *
@@ -326,10 +300,7 @@ export interface Fx {
  * Dispatch target for {@link Fx.call}. Wired by the app so untriggered
  * flows execute through the same pipeline as triggered ones.
  */
-export type FxCallHandler = (
-  name: string,
-  input: unknown,
-) => Promise<unknown>;
+export type FxCallHandler = (name: string, input: unknown) => Promise<unknown>;
 
 /** Options for {@link createFx}. */
 export interface CreateFxOptions {
@@ -352,9 +323,7 @@ export interface CreateFxOptions {
   /** Secret name → value map for `fx.vault`. */
   readonly secrets?: Readonly<Record<string, string>>;
   /** Seed data for in-memory stores: ref → key → value. */
-  readonly storeData?: Readonly<
-    Record<string, Readonly<Record<string, unknown>>>
-  >;
+  readonly storeData?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
   /** Optional log sink (defaults to no-op). */
   readonly onLog?: (
     level: "debug" | "info" | "warn" | "error",
@@ -435,9 +404,7 @@ export function createFx(options: CreateFxOptions): Fx {
  */
 export function createFxContext(options: CreateFxOptions): FxContext {
   const ledger = options.ledger ?? createEffectLedger();
-  const capability =
-    options.capability ??
-    createCapabilityToken(options.flow, options.effects);
+  const capability = options.capability ?? createCapabilityToken(options.flow, options.effects);
   const now = options.now ?? (() => Date.now());
   const secrets = options.secrets ?? {};
   const onLog = options.onLog;
@@ -499,15 +466,12 @@ export function createFxContext(options: CreateFxOptions): FxContext {
       select(): Promise<unknown[]> {
         return gated("read", ref, () => {
           const values = [...table().values()];
-          return isDryRun()
-            ? values.map((v) => structuredClone(v))
-            : values;
+          return isDryRun() ? values.map((v) => structuredClone(v)) : values;
         });
       },
       insert(row: Record<string, unknown>): Promise<{ id: string }> {
         return gated("write", ref, () => {
-          const id =
-            typeof row.id === "string" ? row.id : crypto.randomUUID();
+          const id = typeof row.id === "string" ? row.id : crypto.randomUUID();
           table().set(id, { ...row, id });
           return { id };
         });
@@ -532,10 +496,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
    * @param decl - Store declaration
    * @param open - Opens (and caches) the runtime handle
    */
-  function gatedSqlHandle(
-    decl: StoreDecl,
-    open: () => Promise<SqlStoreHandle>,
-  ): SqlStoreHandle {
+  function gatedSqlHandle(decl: StoreDecl, open: () => Promise<SqlStoreHandle>): SqlStoreHandle {
     const ref = decl.ref as `sql:${string}`;
     let cached: SqlStoreHandle | undefined;
     const ensure = async (): Promise<SqlStoreHandle> => {
@@ -684,9 +645,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
     } as SqlStoreHandle;
   }
 
-  function storeHandle(
-    ref: NamedRef | { readonly ref: ResourceRef } | StoreDecl,
-  ): FxStoreHandle {
+  function storeHandle(ref: NamedRef | { readonly ref: ResourceRef } | StoreDecl): FxStoreHandle {
     const runtime = options.storeRuntime;
     if (runtime && typeof ref === "object" && ref !== null && "facet" in ref) {
       const decl = ref;
@@ -714,8 +673,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         get(_t, prop) {
           if (prop === "ref") return baseRef;
           if (prop === "then") return undefined;
-          const isRead =
-            prop === "get" || prop === "search" || prop === "list";
+          const isRead = prop === "get" || prop === "search" || prop === "list";
           return (...args: unknown[]) =>
             gated(isRead ? "read" : "write", baseRef, async () => {
               if (!isRead && isDryRun()) {
@@ -724,18 +682,14 @@ export function createFxContext(options: CreateFxOptions): FxContext {
                 );
               }
               const h = await open();
-              const fn = (h as unknown as Record<string | symbol, unknown>)[
-                prop
-              ];
+              const fn = (h as unknown as Record<string | symbol, unknown>)[prop];
               if (typeof fn !== "function") return undefined;
               return (fn as (...a: unknown[]) => unknown).apply(h, args);
             });
         },
       });
     }
-    return stubStoreHandle(
-      resolveStoreRef(ref as NamedRef | { readonly ref: ResourceRef }),
-    );
+    return stubStoreHandle(resolveStoreRef(ref as NamedRef | { readonly ref: ResourceRef }));
   }
 
   const clock: FxClock = {
@@ -768,11 +722,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
       if (aiDisablesCache) return;
       cacheStore.set(key, value);
     },
-    async getOrSet<T>(
-      key: string,
-      _ttl: string,
-      produce: () => T | Promise<T>,
-    ): Promise<T> {
+    async getOrSet<T>(key: string, _ttl: string, produce: () => T | Promise<T>): Promise<T> {
       if (aiDisablesCache) return await produce();
       if (cacheStore.has(key)) {
         if (telemetry) telemetry.cacheHits += 1;
@@ -792,9 +742,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
     const vault = options.vaultRuntime;
     if (!vault) return { message, data };
     const safeMessage = vault.redactString(message);
-    const safeData = data
-      ? (vault.redact(data) as Record<string, unknown>)
-      : undefined;
+    const safeData = data ? (vault.redact(data) as Record<string, unknown>) : undefined;
     return { message: safeMessage, data: safeData };
   }
 

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

@@ -49,12 +49,9 @@ describe("hook timing", () => {
 
   test("registry tags hooks at plug time", async () => {
     const registry = createPluginRegistry();
-    const p = plugin("metered", { version: "1.0.0" }).hook(
-      "onRequest",
-      async () => {
-        await Bun.sleep(1);
-      },
-    );
+    const p = plugin("metered", { version: "1.0.0" }).hook("onRequest", async () => {
+      await Bun.sleep(1);
+    });
     applyPlugin(registry, p, appPluginScope);
     const hooks = registry.hooksAt("app", undefined, "x");
     const ctx: InvocationContext = {

package/src/kernel/hook-timing.ts

@@ -132,10 +132,7 @@ export function resetHookCosts(): void {
   filled = 0;
 }
 
-function summarize(
-  pluginId: string,
-  mine: readonly HookCostSample[],
-): HookCostSummary {
+function summarize(pluginId: string, mine: readonly HookCostSample[]): HookCostSummary {
   if (mine.length === 0) {
     return {
       pluginId,
@@ -149,18 +146,15 @@ function summarize(
   }
   const durations = mine.map((s) => s.durationMs).sort((a, b) => a - b);
   const sum = durations.reduce((a, b) => a + b, 0);
-  const byStageAcc: Partial<
-    Record<HookStage, { count: number; total: number }>
-  > = {};
+  const byStageAcc: Partial<Record<HookStage, { count: number; total: number }>> = {};
   for (const s of mine) {
     const cur = byStageAcc[s.stage] ?? { count: 0, total: 0 };
     cur.count++;
     cur.total += s.durationMs;
     byStageAcc[s.stage] = cur;
   }
-  const byStage: Partial<
-    Record<HookStage, { readonly count: number; readonly meanMs: number }>
-  > = {};
+  const byStage: Partial<Record<HookStage, { readonly count: number; readonly meanMs: number }>> =
+    {};
   for (const [stage, acc] of Object.entries(byStageAcc) as Array<
     [HookStage, { count: number; total: number }]
   >) {
@@ -182,9 +176,6 @@ function summarize(
 
 function percentile(sorted: readonly number[], p: number): number {
   if (sorted.length === 0) return 0;
-  const idx = Math.min(
-    sorted.length - 1,
-    Math.max(0, Math.ceil(p * sorted.length) - 1),
-  );
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p * sorted.length) - 1));
   return sorted[idx]!;
 }

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);