@goodbones/browser 0.1.0-beta.1

package/src/model/campaigns.ts

@@ -0,0 +1,376 @@
+import type {
+  Attestation,
+  CampaignEvaluation,
+  CampaignReport,
+  Note,
+  Nudge,
+} from "@goodbones/campaigns";
+import {
+  campaignsOf,
+  isDefinedPhase,
+  ledgerKeyOf,
+  LEGACY_SECTOR,
+  snapshotCampaignsOf,
+} from "@goodbones/campaigns";
+import type { LoadedPolicy, ManifestLocator, ManifestPath } from "@goodbones/core";
+
+import type { AtlasPosition } from "./atlas.js";
+
+// The Campaign Browser's data: every campaign the policy declares, as the
+// ladder the docs draw — phases in order, each recognized by its objectives;
+// sectors standing at the first phase with residue for them; the end state
+// last — with everything `architecture campaigns` and `check` say about
+// each: the ledgers' counts, the holdouts by sector, what is new and what is
+// stale, attestations, notes, stalls, and the nudge for the working tree.
+
+export type ObjectiveSectorCard = {
+  readonly sector: string;
+  // Holdouts firing now, in window.
+  readonly count: number;
+  // The ledger's entries for this sector, relative to its root.
+  readonly holdouts: ReadonlyArray<string>;
+  // Firing and not in the ledger: unrecorded growth.
+  readonly new: ReadonlyArray<string>;
+  // In the ledger and no longer firing: cleared, waiting for `clear`.
+  readonly stale: ReadonlyArray<string>;
+  readonly drifted: number;
+  readonly unrecorded: boolean;
+  readonly initial: number | null;
+  readonly cleared: number | null;
+  readonly closed: number | null;
+  readonly lastCleared: string | null;
+  readonly measure: {
+    readonly value: number | null;
+    readonly recorded: number | null;
+    readonly standing: "within" | "breached" | "surpassed" | "unrecorded" | "unmeasured";
+  } | null;
+};
+
+export type ObjectiveCard = {
+  readonly id: string;
+  readonly message: string;
+  readonly why: string | null;
+  // `match`, `file`, `declaration`, `sector` — or `measure` for a scalar.
+  readonly holdout: string;
+  readonly phase: string | null;
+  readonly position: AtlasPosition | null;
+  readonly count: number;
+  readonly initial: number;
+  readonly allowed: number;
+  readonly cleared: number;
+  readonly closed: number;
+  readonly progress: number;
+  readonly lastCleared: string | null;
+  readonly concessions: number;
+  readonly complete: boolean;
+  readonly ledgered: boolean;
+  readonly measure: {
+    readonly direction: "down" | "up";
+    readonly value: number | null;
+    readonly recorded: number | null;
+    readonly target: number | null;
+    readonly tolerance: number;
+  } | null;
+  readonly sectors: ReadonlyArray<ObjectiveSectorCard>;
+};
+
+export type PhaseCard = {
+  readonly id: string;
+  readonly index: number;
+  readonly defined: boolean;
+  readonly intent: string | null;
+  readonly attested: boolean;
+  readonly objectives: ReadonlyArray<string>;
+  // Sectors derived to stand here.
+  readonly sectors: number;
+  readonly concessions: number;
+  readonly position: AtlasPosition | null;
+};
+
+export type HitCard = {
+  readonly objective: string;
+  readonly file: string;
+  readonly subject: string | null;
+  readonly line: number | null;
+  readonly entry: string;
+  readonly message: string;
+};
+
+export type SectorCard = {
+  readonly name: string;
+  readonly legacy: boolean;
+  // Index into `phases`; `phases.length` when every phase is done. For a
+  // campaign with no phases, `0` and `done` says whether residue is nil.
+  readonly phase: number;
+  readonly phaseId: string | null;
+  readonly done: boolean;
+  readonly reached: string | null;
+  readonly since: string | null;
+  readonly roots: ReadonlyArray<string>;
+  readonly marker: string | null;
+  readonly files: ReadonlyArray<string>;
+  // Holdouts per objective in window, and the raw counts for every objective.
+  readonly residue: Readonly<Record<string, number>>;
+  readonly counts: Readonly<Record<string, number>>;
+  readonly values: Readonly<Record<string, number>>;
+  readonly stalled: boolean;
+  readonly attested: ReadonlyArray<Attestation>;
+  readonly notes: ReadonlyArray<Note>;
+  readonly hits: ReadonlyArray<HitCard>;
+};
+
+export type CampaignCard = {
+  readonly id: string;
+  readonly title: string | null;
+  readonly why: string | null;
+  readonly how: string | null;
+  readonly owner: string | null;
+  readonly scope: ReadonlyArray<string>;
+  readonly perimeter: string | null;
+  readonly staleAfterDays: number | null;
+  readonly onComplete: "keep" | "remove";
+  readonly position: AtlasPosition | null;
+  readonly count: number;
+  readonly progress: number;
+  readonly stalled: boolean;
+  readonly complete: boolean;
+  readonly ledgered: boolean;
+  readonly missingLedger: boolean;
+  readonly arithmetic: boolean;
+  readonly phases: ReadonlyArray<PhaseCard>;
+  readonly objectives: ReadonlyArray<ObjectiveCard>;
+  readonly sectors: ReadonlyArray<SectorCard>;
+  readonly legacy: { readonly files: number; readonly holdouts: number };
+  readonly drift: ReadonlyArray<{ readonly file: string; readonly sectors: ReadonlyArray<string> }>;
+  readonly plan: {
+    readonly refined: ReadonlyArray<string>;
+    readonly changed: ReadonlyArray<string>;
+    readonly unreceipted: ReadonlyArray<string>;
+  };
+};
+
+export type CampaignView = {
+  readonly version: 1;
+  readonly name: string;
+  readonly generatedAt: string;
+  readonly ledgerDir: string;
+  readonly campaigns: ReadonlyArray<CampaignCard>;
+  // `campaigns status --changed` over the working tree, when git answered.
+  readonly nudge: Nudge | null;
+};
+
+export type CampaignViewInput = {
+  readonly policy: LoadedPolicy;
+  readonly name: string;
+  readonly evaluations: ReadonlyArray<CampaignEvaluation>;
+  readonly reports: ReadonlyArray<CampaignReport>;
+  // The manifest as read, for the fields lowering does not keep (`how`).
+  readonly manifest: unknown;
+  readonly locate: ManifestLocator | undefined;
+  readonly manifestPath: string;
+  readonly nudge: Nudge | null;
+  readonly now: number;
+};
+
+const dirnameOf = (file: string): string => {
+  const at = file.lastIndexOf("/");
+  return at === -1 ? "" : file.slice(0, at);
+};
+
+const positionAt = (
+  locate: ManifestLocator | undefined,
+  manifestPath: string,
+  path: ManifestPath,
+): AtlasPosition | null => {
+  const found = locate?.(path);
+  if (found === null || found === undefined) return null;
+  const directory = dirnameOf(manifestPath);
+  const file =
+    found.file === undefined
+      ? manifestPath
+      : directory === ""
+        ? found.file
+        : `${directory}/${found.file}`;
+  return { file, line: found.line, column: found.column };
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const stringAt = (value: unknown, ...keys: ReadonlyArray<string>): string | null => {
+  let cursor: unknown = value;
+  for (const key of keys) {
+    if (!isRecord(cursor)) return null;
+    cursor = cursor[key];
+  }
+  return typeof cursor === "string" ? cursor : null;
+};
+
+const DAY = 24 * 60 * 60 * 1000;
+
+export const campaignViewOf = (input: CampaignViewInput): CampaignView => {
+  const { policy } = input;
+  const state = campaignsOf(policy);
+  const snapshots = snapshotCampaignsOf(policy, input.evaluations);
+  const position = (path: ManifestPath) => positionAt(input.locate, input.manifestPath, path);
+
+  const campaigns = input.evaluations.map((evaluation, index): CampaignCard => {
+    const { rule } = evaluation;
+    const report = input.reports[index];
+    const snapshot = snapshots[index];
+    if (report === undefined || snapshot === undefined) {
+      throw new Error(`campaign ${rule.id} was evaluated without a report`);
+    }
+    const scalar = new Set(
+      rule.objectives.filter((one) => one.measure !== null).map((one) => one.id),
+    );
+
+    const objectives = rule.objectives.map((objective, j): ObjectiveCard => {
+      const own = report.objectives[j];
+      const summary = snapshot.objectives[j];
+      const ledger = state.ledgers.get(ledgerKeyOf(rule.id, objective.id));
+      const sectors = (own?.sectors ?? []).map((sector): ObjectiveSectorCard => {
+        const held = ledger?.sectors[sector.sector];
+        return {
+          sector: sector.sector,
+          count: sector.count,
+          holdouts: held?.holdouts ?? [],
+          new: sector.new,
+          stale: sector.stale,
+          drifted: sector.drifted,
+          unrecorded: sector.unrecorded,
+          initial: held?.initial ?? null,
+          cleared: held?.cleared ?? null,
+          closed: held?.closed ?? null,
+          lastCleared: held?.lastCleared ?? null,
+          measure: sector.measure ?? null,
+        };
+      });
+      return {
+        id: objective.id,
+        message: objective.message,
+        why: objective.why,
+        holdout: objective.measure !== null ? "measure" : (objective.holdout ?? "match"),
+        phase: summary?.phase ?? null,
+        position: position(["campaigns", rule.id, "objectives", objective.id]),
+        count: summary?.count ?? own?.count ?? 0,
+        initial: summary?.initial ?? 0,
+        allowed: summary?.allowed ?? 0,
+        cleared: summary?.cleared ?? 0,
+        closed: summary?.closed ?? 0,
+        progress: summary?.progress ?? 0,
+        lastCleared: summary?.lastCleared ?? null,
+        concessions: summary?.concessions ?? 0,
+        complete: summary?.complete ?? false,
+        ledgered: summary?.ledgered ?? false,
+        measure:
+          own?.measure === undefined
+            ? null
+            : {
+                direction: own.measure.direction,
+                value: own.measure.value,
+                recorded: own.measure.recorded,
+                target: own.measure.target,
+                tolerance: own.measure.tolerance,
+              },
+        sectors,
+      };
+    });
+
+    const phases = rule.phases.map((phase, i): PhaseCard => ({
+      id: phase.id,
+      index: i,
+      defined: isDefinedPhase(phase),
+      intent: phase.intent ?? null,
+      attested: phase.attested,
+      objectives: [...phase.objectives],
+      sectors: snapshot.phases[i]?.sectors ?? 0,
+      concessions: phase.concessions.length,
+      position: position(["campaigns", rule.id, "phases", i]),
+    }));
+
+    const hitsOf = (sector: string): ReadonlyArray<HitCard> =>
+      evaluation.hits
+        .filter((hit) => hit.sector === sector)
+        .map((hit) => ({
+          objective: hit.objective,
+          file: hit.violation.file,
+          subject: hit.violation.subject,
+          line: hit.range === undefined ? null : hit.range.start.line + 1,
+          entry: hit.entry,
+          message: hit.violation.message,
+        }))
+        .sort((a, b) => {
+          const byFile = a.file.localeCompare(b.file);
+          return byFile !== 0 ? byFile : a.entry.localeCompare(b.entry);
+        });
+
+    const sectors = [...evaluation.sectors.values()].map((sectorState): SectorCard => {
+      const record = state.sectorRecords.get(ledgerKeyOf(rule.id, sectorState.name));
+      const summary = snapshot.sectors.find((one) => one.name === sectorState.name);
+      const residueTotal = Object.entries(sectorState.residue)
+        .filter(([id]) => !scalar.has(id))
+        .reduce((sum, [, n]) => sum + n, 0);
+      const scalarOpen = Object.entries(sectorState.counts).some(
+        ([id, n]) => scalar.has(id) && n > 0,
+      );
+      return {
+        name: sectorState.name,
+        legacy: sectorState.name === LEGACY_SECTOR,
+        phase: sectorState.phase,
+        phaseId: rule.phases[sectorState.phase]?.id ?? null,
+        done:
+          rule.phases.length === 0
+            ? residueTotal === 0 && !scalarOpen
+            : sectorState.phase >= rule.phases.length,
+        reached: record?.reached ?? null,
+        since: record?.since ?? null,
+        roots: sectorState.sector.roots,
+        marker: sectorState.sector.marker,
+        files: [...sectorState.sector.files].sort(),
+        residue: sectorState.residue,
+        counts: sectorState.counts,
+        values: sectorState.values,
+        stalled: summary?.stalled ?? false,
+        attested: record?.attested ?? [],
+        notes: record?.notes ?? [],
+        hits: hitsOf(sectorState.name),
+      };
+    });
+
+    return {
+      id: rule.id,
+      title: rule.title,
+      why: rule.why,
+      how: stringAt(input.manifest, "campaigns", rule.id, "how"),
+      owner: rule.owner,
+      scope: rule.scope.map((one) => one.source),
+      perimeter: rule.perimeter?.kind ?? null,
+      staleAfterDays: rule.staleAfter === null ? null : Math.round(rule.staleAfter / DAY),
+      onComplete: rule.onComplete,
+      position: position(["campaigns", rule.id]),
+      count: snapshot.count,
+      progress: snapshot.progress,
+      stalled: report.stalled,
+      complete: report.complete,
+      ledgered: snapshot.ledgered,
+      missingLedger: report.missingLedger,
+      arithmetic: report.arithmetic,
+      phases,
+      objectives,
+      sectors,
+      legacy: snapshot.legacy,
+      drift: report.drift,
+      plan: report.plan,
+    };
+  });
+
+  return {
+    version: 1,
+    name: input.name,
+    generatedAt: new Date(input.now).toISOString(),
+    ledgerDir: state.ledgerDir,
+    campaigns,
+    nudge: input.nudge,
+  };
+};

package/src/server/collect.ts

@@ -0,0 +1,132 @@
+import { readFileSync } from "node:fs";
+import * as path from "node:path";
+
+import {
+  campaignReportsOf,
+  campaignsOf,
+  evaluateCampaigns,
+  type Nudge,
+  nudgeOf,
+  readDiff,
+  reportSpecsOf,
+  widenedExtensions,
+} from "@goodbones/campaigns";
+import { listSourceFiles, type SourceFacts } from "@goodbones/core";
+
+import { type Atlas, buildAtlas } from "../model/atlas.js";
+import { type CampaignView, campaignViewOf } from "../model/campaigns.js";
+import { type LoadedManifest, loadPolicyFromFile } from "./compose.js";
+
+// One pass over the repository for both browsers: the policy loaded, every
+// file read and parsed once, the atlas built from the architecture families
+// and the campaign view from the campaigns family. What the CLI's `check`
+// does, minus the printing, plus the positions the browsers link through.
+
+export type Collected = {
+  readonly atlas: Atlas;
+  readonly campaigns: CampaignView;
+};
+
+export type CollectOptions = {
+  readonly repoRoot: string;
+  readonly roots: ReadonlyArray<string>;
+  readonly configFilename?: string | undefined;
+  // Whether to run git for the working-tree nudge. Off for a static export.
+  readonly nudge?: boolean | undefined;
+};
+
+const toPosix = (file: string): string => file.split(path.sep).join("/");
+
+export const collect = async (options: CollectOptions): Promise<Collected> => {
+  const loaded = await loadPolicyFromFile(options.repoRoot, options.configFilename);
+  return collectWith(loaded, options);
+};
+
+export const collectWith = async (
+  loaded: LoadedManifest,
+  options: CollectOptions,
+): Promise<Collected> => {
+  const { policy } = loaded;
+  const name = path.basename(options.repoRoot);
+  const manifestPath = toPosix(path.relative(options.repoRoot, loaded.configPath));
+
+  // Every `report` a campaign names is read now, before any file asks.
+  await Promise.all(
+    reportSpecsOf(campaignsOf(policy).campaignRules).map((spec) =>
+      campaignsOf(policy).reports.read?.(spec),
+    ),
+  );
+
+  const walked = listSourceFiles(
+    options.repoRoot,
+    options.roots,
+    policy.languages,
+    widenedExtensions(policy),
+  );
+  const known = new Set(policy.languages.flatMap((one) => one.extensions));
+  const files = walked.filter((file) => known.has(path.extname(file)));
+
+  const texts = new Map<string, string>();
+  const textOf = (file: string): string => {
+    const cached = texts.get(file);
+    if (cached !== undefined) return cached;
+    const text = readFileSync(path.join(options.repoRoot, file), "utf8");
+    texts.set(file, text);
+    return text;
+  };
+  const parsed = new Map<string, SourceFacts>();
+  const factsOf = (file: string): SourceFacts => {
+    const cached = parsed.get(file);
+    if (cached !== undefined) return cached;
+    const facts = policy.extractor.factsOf(file, textOf(file));
+    parsed.set(file, facts);
+    return facts;
+  };
+
+  const atlas = buildAtlas({
+    policy,
+    name,
+    roots: options.roots,
+    files,
+    factsOf,
+    locate: loaded.locate,
+    manifestPath,
+    manifestFiles: loaded.files.map((file) => ({
+      path: toPosix(path.relative(options.repoRoot, file)),
+      text: readFileSync(file, "utf8"),
+    })),
+    now: policy.now,
+  });
+
+  const evaluations = evaluateCampaigns(policy, options.roots, walked, { textOf, factsOf });
+  const reports = campaignReportsOf(policy, evaluations);
+  const nudge = options.nudge === false ? null : nudgeFor(loaded, evaluations);
+  const campaigns = campaignViewOf({
+    policy,
+    name,
+    evaluations,
+    reports,
+    manifest: loaded.manifest,
+    locate: loaded.locate,
+    manifestPath,
+    nudge,
+    now: policy.now,
+  });
+
+  return { atlas, campaigns };
+};
+
+// The nudge for the working tree against HEAD, or nothing where git does
+// not answer — a repository with no commits, or none at all.
+const nudgeFor = (
+  loaded: LoadedManifest,
+  evaluations: Parameters<typeof nudgeOf>[1],
+): Nudge | null => {
+  if (campaignsOf(loaded.policy).campaignRules.length === 0) return null;
+  try {
+    const diff = readDiff(loaded.policy.repoRoot, null);
+    return nudgeOf(loaded.policy, evaluations, diff, null, null, null);
+  } catch {
+    return null;
+  }
+};

package/src/server/compose.ts

@@ -0,0 +1,79 @@
+import * as path from "node:path";
+
+import { astGrepMatcher } from "@goodbones/ast-grep";
+import {
+  campaignsExtension,
+  loadCampaignFunctions,
+  makeReportSourceLive,
+} from "@goodbones/campaigns";
+import {
+  findManifestFile,
+  type Language,
+  type LoadedPolicy,
+  loadPolicy,
+  makeFileSystemLive,
+  type ManifestLocator,
+  readManifestFile,
+} from "@goodbones/core";
+import { typescriptLanguage } from "@goodbones/typescript";
+import * as Result from "effect/Result";
+
+// This host's composition root: the same three lines the CLI and the plugin
+// each have, on purpose — the three hosts share the core and never each
+// other. Nothing below this file names TypeScript or ast-grep.
+
+export const hostLanguages = (): ReadonlyArray<Language> => [
+  typescriptLanguage({ syntax: astGrepMatcher() }),
+];
+
+export const hostNow = (): number => {
+  const pinned = process.env.ARCHITECTURE_NOW;
+  if (pinned === undefined || pinned === "") return Date.now();
+  const parsed = /^\d+$/.test(pinned) ? Number(pinned) : Date.parse(pinned);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`ARCHITECTURE_NOW is ${JSON.stringify(pinned)}, which is not a date.`);
+  }
+  return parsed;
+};
+
+export const manifestPathOf = (repoRoot: string, configFilename?: string): string =>
+  configFilename === undefined
+    ? findManifestFile(repoRoot)
+    : path.resolve(repoRoot, configFilename);
+
+export type LoadedManifest = {
+  readonly policy: LoadedPolicy;
+  // The manifest as read, before decoding.
+  readonly manifest: unknown;
+  readonly locate: ManifestLocator | undefined;
+  // Absolute; the root manifest first, then every file `include` pulled in.
+  readonly configPath: string;
+  readonly files: ReadonlyArray<string>;
+};
+
+export const loadPolicyFromFile = async (
+  repoRoot: string,
+  configFilename?: string,
+): Promise<LoadedManifest> => {
+  const configPath = manifestPathOf(repoRoot, configFilename);
+  const read = await readManifestFile(configPath);
+  const { functions, manifest } = await loadCampaignFunctions(configPath, read.manifest);
+  const loaded = loadPolicy({
+    repoRoot,
+    configPath,
+    manifest,
+    locate: read.locate,
+    languages: hostLanguages(),
+    fileSystem: makeFileSystemLive(repoRoot),
+    extensions: [campaignsExtension({ functions, reports: makeReportSourceLive(repoRoot) })],
+    now: hostNow(),
+  });
+  if (Result.isFailure(loaded)) throw loaded.failure;
+  return {
+    policy: loaded.success,
+    manifest: read.manifest,
+    locate: read.locate,
+    configPath,
+    files: read.files,
+  };
+};

package/src/server/export.ts

@@ -0,0 +1,24 @@
+import { cpSync, mkdirSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+
+import type { Collected } from "./collect.js";
+
+// A static export: the page as built, with the two models written where the
+// page fetches them. Serve the folder from the root of a host; the page
+// finds no feed there and says it is a snapshot.
+export const exportSite = (siteDir: string, out: string, collected: Collected): void => {
+  mkdirSync(out, { recursive: true });
+  cpSync(siteDir, out, { recursive: true });
+  const data = path.join(out, "__goodbones");
+  mkdirSync(data, { recursive: true });
+  writeFileSync(path.join(data, "atlas.json"), JSON.stringify(collected.atlas));
+  writeFileSync(path.join(data, "campaigns.json"), JSON.stringify(collected.campaigns));
+  writeFileSync(
+    path.join(data, "status.json"),
+    JSON.stringify({
+      name: collected.atlas.name,
+      generatedAt: collected.atlas.generatedAt,
+      live: false,
+    }),
+  );
+};

package/src/server/handler.ts

@@ -0,0 +1,77 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import type { Source } from "./source.js";
+
+// The routes the page reads, mounted under `/__goodbones/` by the bin's
+// server and by the Vite plugin alike, so the page is the same in both:
+//
+//   atlas.json       the Architecture Browser's model
+//   campaigns.json   the Campaign Browser's model
+//   status.json      the repository's name and whether the feed is live
+//   events           server-sent events: `changed` when the repository does
+//
+// A static export writes the first three as files and has no feed.
+
+export const PREFIX = "/__goodbones/";
+
+export type Handler = (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+
+const HEARTBEAT_MS = 25_000;
+
+const json = (response: ServerResponse, status: number, body: unknown): void => {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json; charset=utf-8");
+  response.setHeader("cache-control", "no-store");
+  response.end(JSON.stringify(body));
+};
+
+const messageOf = (cause: unknown): string =>
+  typeof cause === "object" && cause !== null && "message" in cause
+    ? String(cause.message)
+    : String(cause);
+
+export const makeHandler = (source: Source): Handler => {
+  return async (request, response) => {
+    const url = new URL(request.url ?? "/", "http://localhost");
+    if (!url.pathname.startsWith(PREFIX)) return false;
+    const route = url.pathname.slice(PREFIX.length);
+
+    if (route === "events") {
+      response.statusCode = 200;
+      response.setHeader("content-type", "text/event-stream");
+      response.setHeader("cache-control", "no-store");
+      response.setHeader("connection", "keep-alive");
+      response.write(`event: hello\ndata: ${JSON.stringify({ live: source.live })}\n\n`);
+      const unsubscribe = source.subscribe((change) => {
+        response.write(`event: changed\ndata: ${JSON.stringify(change)}\n\n`);
+      });
+      const heartbeat = setInterval(() => response.write(": keep-alive\n\n"), HEARTBEAT_MS);
+      request.on("close", () => {
+        clearInterval(heartbeat);
+        unsubscribe();
+      });
+      return true;
+    }
+
+    if (route === "atlas.json" || route === "campaigns.json" || route === "status.json") {
+      try {
+        const collected = await source.current();
+        if (route === "atlas.json") json(response, 200, collected.atlas);
+        else if (route === "campaigns.json") json(response, 200, collected.campaigns);
+        else {
+          json(response, 200, {
+            name: collected.atlas.name,
+            generatedAt: collected.atlas.generatedAt,
+            live: source.live,
+          });
+        }
+      } catch (cause) {
+        json(response, 500, { error: messageOf(cause) });
+      }
+      return true;
+    }
+
+    json(response, 404, { error: `no such route: ${url.pathname}` });
+    return true;
+  };
+};