okengine 0.2.6 → 0.3.2

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. */
@@ -72,6 +62,11 @@ export interface FlowOptions<
    * Cross-plane invocation is a compile error.
    */
   readonly plane?: FlowPlane;
+  /**
+   * Acknowledge intentional Manifest contract breaks for this flow
+   * (`oke doctor --diff` / CI gate).
+   */
+  readonly breaking?: boolean;
   /** The behavior. */
   readonly do: FlowHandler<I, O>;
 }
@@ -160,6 +155,8 @@ export interface FlowDef<
   readonly slo: Slo | undefined;
   /** Plane (user vs operator). */
   readonly plane: FlowPlane | undefined;
+  /** Intentional contract-break acknowledgement for Manifest Diff. */
+  readonly breaking: boolean;
   /** Handler body. */
   readonly do: FlowHandler<I, O>;
   /** Triggers bound via {@link on} (zero or more). */
@@ -192,13 +189,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 +213,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,
@@ -239,6 +226,7 @@ export function flow<Opts extends FlowOptions<any, any, any>>(
     cache: options.cache,
     slo: options.slo,
     plane: options.plane,
+    breaking: options.breaking ?? false,
     do: options.do as FlowHandler<InferFlowIn<Opts>, InferFlowOut<Opts>>,
     triggers,
     $trigger: undefined,

package/src/kernel/fx.test.ts

@@ -1,16 +1,11 @@
 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 { fail, formatOkeMessage, lookupOkeError, OKE_ERRORS, OkeError } from "./errors.ts";
 import {
   createFx,
   createFxContext,
+  jsonResultBrand,
   type Fx,
   type FxStubStoreHandle,
 } from "./fx.ts";
@@ -37,16 +32,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.docsUrl).toBe("https://okengine.vercel.app/e/1001");
-    expect(oke.message).toBe(
-      formatOkeMessage(1001, oke.causeText, oke.fix, oke.docsUrl),
-    );
+    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://oke.omqkhafi.dev/e/1001");
+    expect(oke.message).toBe(formatOkeMessage(1001, oke.causeText, oke.fix, oke.docsUrl));
   });
 
   test("declared store read succeeds", async () => {
@@ -79,21 +68,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 +104,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));
     }
@@ -191,6 +164,20 @@ describe("fx — wholesale swap", () => {
       operator: { id: null },
       tenant: { id: "t1" },
       fail,
+      json: {
+        ok(value, opts) {
+          return { [jsonResultBrand]: true, status: 200, value, meta: opts?.meta };
+        },
+        create(value) {
+          return { [jsonResultBrand]: true, status: 201, value };
+        },
+        empty() {
+          return { [jsonResultBrand]: true, status: 204 };
+        },
+        with(data, meta) {
+          return { [jsonResultBrand]: true, status: 200, value: data, meta };
+        },
+      },
       async step(_name, fn) {
         return fn();
       },
@@ -218,15 +205,19 @@ describe("errors — registry", () => {
     });
     expect(err.message).toContain("OKE1042");
     expect(err.message).toContain("no subscriber");
-    expect(err.message).toContain("https://okengine.vercel.app/e/1042");
+    expect(err.message).toContain("https://oke.omqkhafi.dev/e/1042");
     expect(err.message).toContain("→");
   });
 
   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

@@ -11,26 +11,20 @@
 
 import type { Effects, ResourceRef } from "../manifest/types.ts";
 import type {
+  SelectOrderBuilder,
   StoreDecl,
   StoreHandle,
   StoreRuntime,
   SqlStoreHandle,
 } from "../elements/store.ts";
+import type { SqlRow } from "../drivers/types.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,
@@ -196,23 +190,55 @@ export interface FxSearchOptions {
   readonly topK?: number;
 }
 
+/** Brand for {@link JsonResult} (kept internal — flows never construct it). */
+export const jsonResultBrand: unique symbol = Symbol.for("oke.json");
+
+/** Carrier from {@link FxJson} — status + body read by the response encoder. */
+export interface JsonResult<T = unknown> {
+  readonly [jsonResultBrand]: true;
+  readonly status: number;
+  readonly value?: T;
+  readonly meta?: Record<string, unknown>;
+}
+
+/** True when `value` is an {@link FxJson} carrier. */
+export function isJsonResult(value: unknown): value is JsonResult {
+  return (
+    typeof value === "object" && value !== null && (value as JsonResult)[jsonResultBrand] === true
+  );
+}
+
+/**
+ * JSON response helpers. `fx.json.create` answers 201; `fx.json.ok` can carry
+ * a top-level `meta` (Stripe-style `{ data, meta?, error }`);
+ * `fx.json.empty` answers 204.
+ */
+export interface FxJson {
+  /** 200 — body `{ data: value, meta?, error: null }`. */
+  ok<T>(value: T, opts?: { readonly meta?: Record<string, unknown> }): JsonResult<T>;
+  /** 201 — body `{ data: value, error: null }`. */
+  create<T>(value: T): JsonResult<T>;
+  /** 204 — no body. */
+  empty(): JsonResult<never>;
+  /** 200 — body `{ data, meta, error: null }` (paginated lists). */
+  with<T>(data: T, meta: Record<string, unknown>): JsonResult<T>;
+}
+
 /**
  * The `fx` context object — v1 surface.
  *
  * 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 +277,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 +285,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.
    *
@@ -313,6 +328,8 @@ export interface Fx {
    * @param opts - Optional message
    */
   fail<E>(code: string, data: E, opts?: FailOptions): FlowFailure<E>;
+  /** JSON response helpers (status + Stripe-style envelope). */
+  readonly json: FxJson;
   /**
    * Named durable step — never re-runs on journal replay.
    *
@@ -326,10 +343,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 +366,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 +447,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 +509,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 +539,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> => {
@@ -562,30 +566,53 @@ export function createFxContext(options: CreateFxOptions): FxContext {
       select(columns?) {
         return {
           from(table) {
-            const all = gated("read", ref, async () => {
-              const h = await ensure();
-              return h.select(columns).from(table);
+            const run = (plan: {
+              where?: unknown;
+              orders?: readonly unknown[];
+              limit?: number;
+              offset?: number;
+            }): Promise<SqlRow[]> =>
+              gated("read", ref, async () => {
+                const h = await ensure();
+                const from = h.select(columns).from(table);
+                const filtered = plan.where === undefined ? from : from.where(plan.where);
+                const ordered =
+                  plan.orders === undefined ? filtered : filtered.orderBy(...plan.orders);
+                if (plan.offset !== undefined) return ordered.offset(plan.offset);
+                return plan.limit === undefined ? ordered : ordered.limit(plan.limit);
+              });
+
+            const tail = (plan: {
+              where?: unknown;
+              orders?: readonly unknown[];
+            }): SelectOrderBuilder => ({
+              limit(n) {
+                return run({ ...plan, limit: n });
+              },
+              offset(n) {
+                return run({ ...plan, offset: n });
+              },
+              then(onfulfilled, onrejected) {
+                return run(plan).then(onfulfilled, onrejected);
+              },
             });
+
             return {
               where(where) {
-                const filtered = gated("read", ref, async () => {
-                  const h = await ensure();
-                  return h.select(columns).from(table).where(where);
-                });
                 return {
-                  limit(n) {
-                    return gated("read", ref, async () => {
-                      const h = await ensure();
-                      return h.select(columns).from(table).where(where).limit(n);
-                    });
-                  },
-                  then(onfulfilled, onrejected) {
-                    return filtered.then(onfulfilled, onrejected);
-                  },
+                  ...tail({ where }),
+                  orderBy: (...orders: readonly unknown[]) => tail({ where, orders }),
                 };
               },
+              orderBy: (...orders: readonly unknown[]) => tail({ orders }),
+              limit(n: number) {
+                return run({ limit: n });
+              },
+              offset(n: number) {
+                return run({ offset: n });
+              },
               then(onfulfilled, onrejected) {
-                return all.then(onfulfilled, onrejected);
+                return run({}).then(onfulfilled, onrejected);
               },
             };
           },
@@ -674,6 +701,18 @@ export function createFxContext(options: CreateFxOptions): FxContext {
           return h.raw(sql, params);
         });
       },
+      count(table, where) {
+        return gated("read", ref, async () => {
+          const h = await ensure();
+          return h.count(table, where);
+        });
+      },
+      page(table, pageOptions) {
+        return gated("read", ref, async () => {
+          const h = await ensure();
+          return h.page(table, pageOptions);
+        });
+      },
       ensureTable(table) {
         return gated("write", ref, async () => {
           refuseDryRunWrite();
@@ -684,9 +723,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 +751,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 +760,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 +800,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 +820,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 };
   }
 
@@ -984,6 +1010,25 @@ export function createFxContext(options: CreateFxOptions): FxContext {
     operator,
     tenant,
     fail,
+    json: {
+      ok<T>(value: T, opts?: { readonly meta?: Record<string, unknown> }): JsonResult<T> {
+        return {
+          [jsonResultBrand]: true,
+          status: 200,
+          value,
+          ...(opts?.meta !== undefined ? { meta: opts.meta } : {}),
+        } as JsonResult<T>;
+      },
+      create<T>(value: T): JsonResult<T> {
+        return { [jsonResultBrand]: true, status: 201, value } as JsonResult<T>;
+      },
+      empty(): JsonResult<never> {
+        return { [jsonResultBrand]: true, status: 204 } as JsonResult<never>;
+      },
+      with<T>(data: T, meta: Record<string, unknown>): JsonResult<T> {
+        return { [jsonResultBrand]: true, status: 200, value: data, meta } as JsonResult<T>;
+      },
+    },
     async step<T>(name: string, fn: () => T | Promise<T>): Promise<T> {
       if (journal) {
         return journal.step(name, fn);

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]!;
 }