okengine 0.2.6 → 0.2.8

package/src/runs/drivers/clickhouse.ts

@@ -5,13 +5,7 @@
  * the ClickHouse HTTP interface.
  */
 
-import type {
-  RunsDriver,
-  RunsOpenOptions,
-  RunsRow,
-  RunsStore,
-  WideEvent,
-} from "../types.ts";
+import type { RunsDriver, RunsOpenOptions, RunsRow, RunsStore, WideEvent } from "../types.ts";
 
 /** Minimal ClickHouse HTTP-like client. */
 export interface RunsClickHouseClient {
@@ -72,8 +66,7 @@ export const clickhouseRunsDriver: RunsDriver = {
   id: "clickhouse",
   async open(options: RunsOpenOptions = {}): Promise<RunsStore> {
     const client =
-      (options.client as RunsClickHouseClient | undefined) ??
-      createRunsClickHouseFake();
+      (options.client as RunsClickHouseClient | undefined) ?? createRunsClickHouseFake();
     const table = options.name ?? "oke_runs";
 
     return {

package/src/runs/drivers/files.ts

@@ -20,13 +20,7 @@ import {
   wideEventToRow,
   writeParquet,
 } from "../parquet.ts";
-import type {
-  RunsDriver,
-  RunsOpenOptions,
-  RunsRow,
-  RunsStore,
-  WideEvent,
-} from "../types.ts";
+import type { RunsDriver, RunsOpenOptions, RunsRow, RunsStore, WideEvent } from "../types.ts";
 
 /** Default hot window — 7 days. Older writes go to object storage when present. */
 const DEFAULT_HOT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
@@ -40,14 +34,11 @@ export const filesRunsDriver: RunsDriver = {
     const hotWindowMs = options.hotWindowMs ?? DEFAULT_HOT_WINDOW_MS;
     const clock = () => Date.now();
 
-    const localRoot =
-      options.localRoot ??
-      (await mkdtemp(join(tmpdir(), "oke-runs-")));
+    const localRoot = options.localRoot ?? (await mkdtemp(join(tmpdir(), "oke-runs-")));
     const ownsLocalRoot = options.localRoot === undefined && !options.localBucket;
 
     const local: FilesBucket =
-      options.localBucket ??
-      (await fsDriver.open({ name: "runs-local", root: localRoot }));
+      options.localBucket ?? (await fsDriver.open({ name: "runs-local", root: localRoot }));
 
     const remote = options.remote?.bucket;
     const remotePrefix = options.remote?.prefix ?? "";
@@ -112,16 +103,12 @@ export const filesRunsDriver: RunsDriver = {
 
     async function materialiseAllParquet(): Promise<string[]> {
       if (queryScratch) {
-        await rm(queryScratch, { recursive: true, force: true }).catch(
-          () => undefined,
-        );
+        await rm(queryScratch, { recursive: true, force: true }).catch(() => undefined);
       }
       queryScratch = await mkdtemp(join(tmpdir(), "oke-runs-q-"));
       const paths: string[] = [];
 
-      const localKeys = (await local.list("runs/")).filter((k) =>
-        k.endsWith(".parquet"),
-      );
+      const localKeys = (await local.list("runs/")).filter((k) => k.endsWith(".parquet"));
       for (const key of localKeys) {
         const data = await local.get(key);
         if (!data) continue;
@@ -131,16 +118,11 @@ export const filesRunsDriver: RunsDriver = {
       }
       if (remote) {
         const prefix = `${remotePrefix}runs/`;
-        const remoteKeys = (await remote.list(prefix)).filter((k) =>
-          k.endsWith(".parquet"),
-        );
+        const remoteKeys = (await remote.list(prefix)).filter((k) => k.endsWith(".parquet"));
         for (const key of remoteKeys) {
           const data = await remote.get(key);
           if (!data) continue;
-          const dest = join(
-            queryScratch,
-            `remote__${key.replaceAll("/", "__")}`,
-          );
+          const dest = join(queryScratch, `remote__${key.replaceAll("/", "__")}`);
           await writeFile(dest, data);
           paths.push(dest);
         }
@@ -184,16 +166,12 @@ export const filesRunsDriver: RunsDriver = {
         await flushBuffer();
         session.close();
         if (queryScratch) {
-          await rm(queryScratch, { recursive: true, force: true }).catch(
-            () => undefined,
-          );
+          await rm(queryScratch, { recursive: true, force: true }).catch(() => undefined);
         }
         await local.close();
         await remote?.close();
         if (ownsLocalRoot) {
-          await rm(localRoot, { recursive: true, force: true }).catch(
-            () => undefined,
-          );
+          await rm(localRoot, { recursive: true, force: true }).catch(() => undefined);
         }
       },
     };

package/src/runs/drivers/memory.ts

@@ -6,20 +6,9 @@
 
 import type { DuckDBConnection } from "@duckdb/node-api";
 
-import {
-  duckLiteral,
-  duckQuery,
-  openDuckDB,
-  type DuckSession,
-} from "../duckdb.ts";
+import { duckLiteral, duckQuery, openDuckDB, type DuckSession } from "../duckdb.ts";
 import { wideEventToRow, type ParquetRow } from "../parquet.ts";
-import type {
-  RunsDriver,
-  RunsOpenOptions,
-  RunsRow,
-  RunsStore,
-  WideEvent,
-} from "../types.ts";
+import type { RunsDriver, RunsOpenOptions, RunsRow, RunsStore, WideEvent } from "../types.ts";
 
 /**
  * Memory runs driver (DuckDB `:memory:`).
@@ -65,9 +54,7 @@ export async function materialiseRunsTable(
 ): Promise<void> {
   await conn.run(`DROP TABLE IF EXISTS runs`);
   if (events.length === 0) {
-    await conn.run(
-      `CREATE TABLE runs AS SELECT * FROM (SELECT 1 AS id WHERE FALSE)`,
-    );
+    await conn.run(`CREATE TABLE runs AS SELECT * FROM (SELECT 1 AS id WHERE FALSE)`);
     return;
   }
   // JSONL path avoids VALUES type-inference issues for mixed columns.
@@ -76,13 +63,9 @@ export async function materialiseRunsTable(
   // For small test sets, VALUES is fine and keeps the driver dependency-light.
   const colList = cols.map((c) => `"${c.replaceAll('"', '""')}"`).join(", ");
   const values = rows
-    .map(
-      (r) => `(${cols.map((c) => duckLiteral(r[c] ?? null)).join(", ")})`,
-    )
+    .map((r) => `(${cols.map((c) => duckLiteral(r[c] ?? null)).join(", ")})`)
     .join(",\n");
-  await conn.run(
-    `CREATE TABLE runs AS SELECT * FROM (VALUES ${values}) AS t(${colList})`,
-  );
+  await conn.run(`CREATE TABLE runs AS SELECT * FROM (VALUES ${values}) AS t(${colList})`);
 }
 
 function unionKeys(rows: readonly ParquetRow[]): string[] {

package/src/runs/drivers/postgres.ts

@@ -4,13 +4,7 @@
  * Protocol-named. Uses an injected client in tests; production binds Bun.sql.
  */
 
-import type {
-  RunsDriver,
-  RunsOpenOptions,
-  RunsRow,
-  RunsStore,
-  WideEvent,
-} from "../types.ts";
+import type { RunsDriver, RunsOpenOptions, RunsRow, RunsStore, WideEvent } from "../types.ts";
 
 /** Minimal SQL surface used by the postgres runs driver. */
 export interface RunsPostgresClient {
@@ -71,21 +65,17 @@ export function createRunsPostgresFake(): RunsPostgresClient & {
 export const postgresRunsDriver: RunsDriver = {
   id: "postgres",
   async open(options: RunsOpenOptions = {}): Promise<RunsStore> {
-    const client =
-      (options.client as RunsPostgresClient | undefined) ??
-      createRunsPostgresFake();
+    const client = (options.client as RunsPostgresClient | undefined) ?? createRunsPostgresFake();
     const table = options.name ?? "oke_runs";
-    await client.exec(
-      `CREATE TABLE IF NOT EXISTS ${table} (id TEXT PRIMARY KEY, payload JSONB)`,
-    );
+    await client.exec(`CREATE TABLE IF NOT EXISTS ${table} (id TEXT PRIMARY KEY, payload JSONB)`);
 
     return {
       driverId: "postgres",
       async append(event: WideEvent): Promise<void> {
-        await client.exec(
-          `INSERT INTO ${table} (id, payload) VALUES ($1, $2::jsonb)`,
-          [event.id, JSON.stringify(event)],
-        );
+        await client.exec(`INSERT INTO ${table} (id, payload) VALUES ($1, $2::jsonb)`, [
+          event.id,
+          JSON.stringify(event),
+        ]);
       },
       async flush(): Promise<void> {
         /* row-level writes are immediate */
@@ -97,9 +87,7 @@ export const postgresRunsDriver: RunsDriver = {
         const result = await client.query(`SELECT payload FROM ${table}`);
         return result.map((r) => {
           const p = r.payload ?? r;
-          return typeof p === "string"
-            ? (JSON.parse(p) as WideEvent)
-            : (p as WideEvent);
+          return typeof p === "string" ? (JSON.parse(p) as WideEvent) : (p as WideEvent);
         });
       },
       async close(): Promise<void> {

package/src/runs/duckdb.ts

@@ -2,10 +2,7 @@
  * Thin DuckDB adapter — adopted via `@duckdb/node-api`, not reinvented.
  */
 
-import {
-  DuckDBInstance,
-  type DuckDBConnection,
-} from "@duckdb/node-api";
+import { DuckDBInstance, type DuckDBConnection } from "@duckdb/node-api";
 
 import type { RunsRow } from "./types.ts";
 
@@ -47,10 +44,7 @@ export async function openDuckDB(): Promise<DuckSession> {
  * @param conn - DuckDB connection
  * @param sql - SQL text
  */
-export async function duckQuery(
-  conn: DuckDBConnection,
-  sql: string,
-): Promise<RunsRow[]> {
+export async function duckQuery(conn: DuckDBConnection, sql: string): Promise<RunsRow[]> {
   const reader = await conn.runAndReadAll(sql);
   const rows = reader.getRowObjectsJson() as RunsRow[];
   return rows.map(normalizeRow);

package/src/runs/index.ts

@@ -19,16 +19,9 @@ export type {
   RunsOpenOptions,
 } from "./types.ts";
 
-export {
-  createRunTelemetry,
-  cacheDimensionOf,
-  type RunTelemetry,
-} from "./telemetry.ts";
+export { createRunTelemetry, cacheDimensionOf, type RunTelemetry } from "./telemetry.ts";
 
-export {
-  collectWideEvent,
-  type CollectWideEventInput,
-} from "./collect.ts";
+export { collectWideEvent, type CollectWideEventInput } from "./collect.ts";
 
 export {
   explainOutliers,
@@ -73,11 +66,7 @@ export {
   type RunsRuntime,
 } from "./runtime.ts";
 
-export {
-  privacyErase,
-  type PrivacyEraseOptions,
-  type PrivacyEraseResult,
-} from "./privacy.ts";
+export { privacyErase, type PrivacyEraseOptions, type PrivacyEraseResult } from "./privacy.ts";
 
 export { createRunsPostgresFake } from "./drivers/postgres.ts";
 export { createRunsClickHouseFake } from "./drivers/clickhouse.ts";

package/src/runs/outlier.ts

@@ -69,14 +69,10 @@ export function explainOutliers(
   for (const dim of dimNames) {
     const outlierCounts = valueCounts(outliers, dim);
     const baselineCounts = valueCounts(baseline, dim);
-    const values = new Set([
-      ...outlierCounts.keys(),
-      ...baselineCounts.keys(),
-    ]);
+    const values = new Set([...outlierCounts.keys(), ...baselineCounts.keys()]);
     for (const value of values) {
       const outlierShare = (outlierCounts.get(value) ?? 0) / outliers.length;
-      const baselineShare =
-        (baselineCounts.get(value) ?? 0) / baseline.length;
+      const baselineShare = (baselineCounts.get(value) ?? 0) / baseline.length;
       const lift = outlierShare - baselineShare;
       if (lift < minLift) continue;
       findings.push({
@@ -154,10 +150,7 @@ export function seedOutlierDataset(opts?: {
   return events;
 }
 
-function valueCounts(
-  events: readonly WideEvent[],
-  dim: string,
-): Map<string, number> {
+function valueCounts(events: readonly WideEvent[], dim: string): Map<string, number> {
   const m = new Map<string, number>();
   for (const e of events) {
     const raw = e.dimensions[dim];

package/src/runs/parquet.ts

@@ -91,26 +91,16 @@ export function rowToWideEvent(row: Record<string, unknown>): WideEvent {
     subjectId: row.subject_id != null ? String(row.subject_id) : null,
     gates: parseJsonArray(row.gates) as string[],
     cache: (row.cache as WideEvent["cache"]) ?? "none",
-    ...(row.replica != null
-      ? { replica: row.replica as "primary" | "replica" }
-      : {}),
-    ...(row.replica_lag_ms != null
-      ? { replicaLagMs: Number(row.replica_lag_ms) }
-      : {}),
+    ...(row.replica != null ? { replica: row.replica as "primary" | "replica" } : {}),
+    ...(row.replica_lag_ms != null ? { replicaLagMs: Number(row.replica_lag_ms) } : {}),
     ...(row.cost != null ? { cost: Number(row.cost) } : {}),
-    ...(row.prompt_version != null
-      ? { promptVersion: Number(row.prompt_version) }
-      : {}),
-    ...(row.build_version != null
-      ? { buildVersion: String(row.build_version) }
-      : {}),
+    ...(row.prompt_version != null ? { promptVersion: Number(row.prompt_version) } : {}),
+    ...(row.build_version != null ? { buildVersion: String(row.build_version) } : {}),
     error:
       errorCode != null
         ? {
             code: String(errorCode),
-            ...(row.error_message != null
-              ? { message: String(row.error_message) }
-              : {}),
+            ...(row.error_message != null ? { message: String(row.error_message) } : {}),
           }
         : null,
     effects: parseJsonArray(row.effects) as WideEvent["effects"],
@@ -129,17 +119,11 @@ export function rowToWideEvent(row: Record<string, unknown>): WideEvent {
  * @param path - Absolute output path
  * @param rows - Flattened rows
  */
-export async function writeParquet(
-  path: string,
-  rows: readonly ParquetRow[],
-): Promise<void> {
+export async function writeParquet(path: string, rows: readonly ParquetRow[]): Promise<void> {
   if (rows.length === 0) return;
   await mkdir(dirname(path), { recursive: true });
   const jsonl = `${path}.jsonl`;
-  await writeFile(
-    jsonl,
-    rows.map((r) => JSON.stringify(r)).join("\n"),
-  );
+  await writeFile(jsonl, rows.map((r) => JSON.stringify(r)).join("\n"));
   const session = await openDuckDB();
   try {
     await session.conn.run(
@@ -156,9 +140,7 @@ export async function writeParquet(
  *
  * @param paths - Absolute Parquet paths
  */
-export async function readParquet(
-  paths: readonly string[],
-): Promise<ParquetRow[]> {
+export async function readParquet(paths: readonly string[]): Promise<ParquetRow[]> {
   if (paths.length === 0) return [];
   const session = await openDuckDB();
   try {

package/src/runs/privacy.ts

@@ -3,11 +3,7 @@
  * journal / channel receipts). Deletes the Vault key, not the terabytes.
  */
 
-import {
-  eraseSubject,
-  subjectKeyName,
-  type SubjectKeyVault,
-} from "./shred.ts";
+import { eraseSubject, subjectKeyName, type SubjectKeyVault } from "./shred.ts";
 
 /** Options for {@link privacyErase}. */
 export interface PrivacyEraseOptions {
@@ -34,9 +30,7 @@ export interface PrivacyEraseResult {
  *
  * @param options - Subject + vault
  */
-export function privacyErase(
-  options: PrivacyEraseOptions,
-): PrivacyEraseResult {
+export function privacyErase(options: PrivacyEraseOptions): PrivacyEraseResult {
   const key = subjectKeyName(options.subjectId);
   const deleted = eraseSubject(options.subjectKeys, options.subjectId);
   const write = options.write ?? ((t) => process.stdout.write(t));

package/src/runs/runs.test.ts

@@ -184,9 +184,7 @@ describe("locality — local + object storage", () => {
     expect(localKeys.some((k) => k.endsWith(".parquet"))).toBe(true);
     expect(remoteKeys.some((k) => k.endsWith(".parquet"))).toBe(true);
 
-    const rows = await runs.query(
-      "SELECT id, dim_locality AS locality FROM runs ORDER BY id",
-    );
+    const rows = await runs.query("SELECT id, dim_locality AS locality FROM runs ORDER BY id");
     expect(rows.length).toBe(2);
     const ids = rows.map((r) => String(r.id)).sort();
     expect(ids).toEqual(["archived", "recent"]);
@@ -242,9 +240,7 @@ describe("crypto-shredding erasure", () => {
 
     // Snapshot partition bytes before erase
     const bucket = await fsDriver.open({ name: "snap", root: root });
-    const keysBefore = (await bucket.list("runs/")).filter((k) =>
-      k.endsWith(".parquet"),
-    );
+    const keysBefore = (await bucket.list("runs/")).filter((k) => k.endsWith(".parquet"));
     expect(keysBefore.length).toBeGreaterThan(0);
     const bytesBefore = await bucket.get(keysBefore[0]!);
     expect(bytesBefore).toBeTruthy();
@@ -262,9 +258,7 @@ describe("crypto-shredding erasure", () => {
     expect(bytesAfter).toEqual(bytesBefore);
 
     // Query still returns the row (operational dims intact)
-    const rows = await runs.query(
-      "SELECT id, subject_id FROM runs WHERE id = 'run_erase'",
-    );
+    const rows = await runs.query("SELECT id, subject_id FROM runs WHERE id = 'run_erase'");
     expect(rows.length).toBe(1);
     expect(rows[0]!.subject_id).toBe(subjectId);
 

package/src/runs/runtime.ts

@@ -7,17 +7,8 @@ import { clickhouseRunsDriver } from "./drivers/clickhouse.ts";
 import { filesRunsDriver } from "./drivers/files.ts";
 import { memoryRunsDriver } from "./drivers/memory.ts";
 import { postgresRunsDriver } from "./drivers/postgres.ts";
-import {
-  explainOutliers,
-  type ExplainOutliersOptions,
-  type OutlierFinding,
-} from "./outlier.ts";
-import {
-  archiveFields,
-  eraseSubject,
-  revealArchived,
-  type SubjectKeyVault,
-} from "./shred.ts";
+import { explainOutliers, type ExplainOutliersOptions, type OutlierFinding } from "./outlier.ts";
+import { archiveFields, eraseSubject, revealArchived, type SubjectKeyVault } from "./shred.ts";
 import type {
   RunsDriver,
   RunsDriverId,
@@ -114,9 +105,7 @@ const DRIVER_BY_ID: Record<RunsDriverId, RunsDriver> = {
  *
  * @param driver - Id or driver
  */
-export function resolveRunsDriver(
-  driver?: RunsDriverId | RunsDriver,
-): RunsDriver {
+export function resolveRunsDriver(driver?: RunsDriverId | RunsDriver): RunsDriver {
   if (!driver) return filesRunsDriver;
   if (typeof driver === "string") {
     const d = DRIVER_BY_ID[driver];
@@ -131,9 +120,7 @@ export function resolveRunsDriver(
  *
  * @param options - Driver + locality + subject keys
  */
-export function createRunsRuntime(
-  options: CreateRunsRuntimeOptions = {},
-): RunsRuntime {
+export function createRunsRuntime(options: CreateRunsRuntimeOptions = {}): RunsRuntime {
   const driver = resolveRunsDriver(options.driver);
   let store: RunsStore | undefined;
   const subjectKeys = options.subjectKeys;
@@ -156,21 +143,14 @@ export function createRunsRuntime(
       const s = await ensureStore();
       let archived = input.archived;
       const subjectId =
-        input.telemetry.subjectId ??
-        input.fx.auth.userId ??
-        input.fx.tenant.id ??
-        null;
+        input.telemetry.subjectId ?? input.fx.auth.userId ?? input.fx.tenant.id ?? null;
       if (
         archiveCleartext &&
         subjectId &&
         subjectKeys &&
         Object.keys(archiveCleartext).length > 0
       ) {
-        archived = await archiveFields(
-          subjectKeys,
-          subjectId,
-          archiveCleartext,
-        );
+        archived = await archiveFields(subjectKeys, subjectId, archiveCleartext);
       }
       const event = collectWideEvent({
         ...input,
@@ -221,9 +201,4 @@ export function createRunsRuntime(
   };
 }
 
-export {
-  filesRunsDriver,
-  memoryRunsDriver,
-  postgresRunsDriver,
-  clickhouseRunsDriver,
-};
+export { filesRunsDriver, memoryRunsDriver, postgresRunsDriver, clickhouseRunsDriver };

package/src/runs/shred.ts

@@ -83,9 +83,7 @@ export function subjectKeysFromVault(vault: VaultRuntime): SubjectKeyVault {
 /**
  * In-memory subject-key vault (tests / when no Vault element is wired).
  */
-export function createMemorySubjectKeys(
-  seed?: Readonly<Record<string, string>>,
-): SubjectKeyVault {
+export function createMemorySubjectKeys(seed?: Readonly<Record<string, string>>): SubjectKeyVault {
   const map = new Map<string, string>(Object.entries(seed ?? {}));
   return {
     read(name) {
@@ -181,26 +179,16 @@ export async function revealArchived(
  * @param subjectId - Subject id
  * @returns Whether a key was deleted
  */
-export function eraseSubject(
-  keys: SubjectKeyVault,
-  subjectId: string,
-): boolean {
+export function eraseSubject(keys: SubjectKeyVault, subjectId: string): boolean {
   return keys.delete(subjectKeyName(subjectId));
 }
 
-async function encryptAesGcm(
-  plaintext: string,
-  keyBytes: Uint8Array,
-): Promise<string> {
+async function encryptAesGcm(plaintext: string, keyBytes: Uint8Array): Promise<string> {
   const iv = crypto.getRandomValues(new Uint8Array(12));
   const keyBuf = toArrayBuffer(keyBytes);
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    keyBuf,
-    { name: "AES-GCM" },
-    false,
-    ["encrypt"],
-  );
+  const cryptoKey = await crypto.subtle.importKey("raw", keyBuf, { name: "AES-GCM" }, false, [
+    "encrypt",
+  ]);
   const cipher = await crypto.subtle.encrypt(
     { name: "AES-GCM", iv },
     cryptoKey,
@@ -212,21 +200,14 @@ async function encryptAesGcm(
   return Buffer.from(packed).toString("base64");
 }
 
-async function decryptAesGcm(
-  blob: string,
-  keyBytes: Uint8Array,
-): Promise<string> {
+async function decryptAesGcm(blob: string, keyBytes: Uint8Array): Promise<string> {
   const packed = Buffer.from(blob, "base64");
   const iv = toArrayBuffer(packed.subarray(0, 12));
   const data = toArrayBuffer(packed.subarray(12));
   const keyBuf = toArrayBuffer(keyBytes);
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    keyBuf,
-    { name: "AES-GCM" },
-    false,
-    ["decrypt"],
-  );
+  const cryptoKey = await crypto.subtle.importKey("raw", keyBuf, { name: "AES-GCM" }, false, [
+    "decrypt",
+  ]);
   const plain = await crypto.subtle.decrypt(
     { name: "AES-GCM", iv: new Uint8Array(iv) },
     cryptoKey,

package/src/runs/types.ts

@@ -26,10 +26,7 @@ export interface RunError {
  * Declared / observed dimensions available without manual instrumentation.
  * Extra keys are allowed for outlier analysis.
  */
-export type RunDimensions = Record<
-  string,
-  string | number | boolean | null | undefined
->;
+export type RunDimensions = Record<string, string | number | boolean | null | undefined>;
 
 /**
  * One wide event — the atomic observability record.

package/src/runtime/bun.ts

@@ -26,10 +26,7 @@ export interface BunRuntime extends Runtime {
    * @param filename - Path, `":memory:"`, or omit for memory
    * @param options - `bun:sqlite` open options
    */
-  sqlite(
-    filename?: string,
-    options?: ConstructorParameters<typeof Database>[1],
-  ): Database;
+  sqlite(filename?: string, options?: ConstructorParameters<typeof Database>[1]): Database;
 }
 
 /**
@@ -43,9 +40,7 @@ export function createBunRuntime(): BunRuntime {
     env: createEnv(),
     files: createFiles(),
     sqlite(filename = ":memory:", options) {
-      return options === undefined
-        ? new Database(filename)
-        : new Database(filename, options);
+      return options === undefined ? new Database(filename) : new Database(filename, options);
     },
     serve(app, options) {
       return listenBun(app, options);
@@ -67,9 +62,7 @@ export function isBunNativePath(path: string): boolean {
   return true;
 }
 
-type MethodHandlers = Partial<
-  Record<string, (req: Request) => Response | Promise<Response>>
->;
+type MethodHandlers = Partial<Record<string, (req: Request) => Response | Promise<Response>>>;
 
 /**
  * Build Bun.serve `routes` from app HTTP bindings.
@@ -99,11 +92,7 @@ export function buildBunRoutes(
 function listenBun(app: FetchApp, options?: ServeOptions): ServerHandle {
   const port = options?.port ?? APP_PORT;
   const hostname = options?.hostname ?? "127.0.0.1";
-  const fetchHandler = secureFetch(
-    (req) => app.fetch(req),
-    options,
-    hostname,
-  );
+  const fetchHandler = secureFetch((req) => app.fetch(req), options, hostname);
   const routes = buildBunRoutes(app, fetchHandler);
 
   const server = Bun.serve({

package/src/runtime/cold-start.bench.ts

@@ -12,9 +12,7 @@ import { measureColdStartMedianMs } from "../release/measure.ts";
 describe("cold start budget", () => {
   test(`Bun adapter ready in < ${COLD_START_BUDGET_MS} ms`, async () => {
     const median = await measureColdStartMedianMs();
-    console.log(
-      `cold-start median=${median.toFixed(2)} ms budget=${COLD_START_BUDGET_MS}`,
-    );
+    console.log(`cold-start median=${median.toFixed(2)} ms budget=${COLD_START_BUDGET_MS}`);
     expect(median).toBeLessThan(COLD_START_BUDGET_MS);
   });
 });

package/src/runtime/dev-request-log.test.ts

@@ -3,10 +3,7 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import {
-  isSilentDevRequest,
-  shouldLogDevRequests,
-} from "./dev-request-log.ts";
+import { isSilentDevRequest, shouldLogDevRequests } from "./dev-request-log.ts";
 
 describe("dev-request-log", () => {
   const prev = process.env.OKE_DEV_REQUEST_LOG;

package/src/runtime/dev-request-log.ts

@@ -103,10 +103,7 @@ export async function timedDevFetch(
   handle: (request: Request) => Response | Promise<Response>,
   options: {
     readonly surface?: DevLogSurface;
-    readonly resolveFlow?: (
-      request: Request,
-      response: Response,
-    ) => string | undefined;
+    readonly resolveFlow?: (request: Request, response: Response) => string | undefined;
     /** Skip logging for this path/method. */
     readonly silent?: (request: Request) => boolean;
   } = {},