@junejs/server 0.0.2

package/src/pipeline.ts

@@ -0,0 +1,248 @@
+// THE render core — ONE funnel shared by the dev server (app.ts, fs-driven) and
+// the built worker (worker.ts, manifest-driven). The PoC wrote this pipeline
+// TWICE (server.tsx + worker.tsx) and the copies drifted: the title-template
+// and charset parity bugs only surfaced because dogfood pages happened to hit
+// them. Here both callers delegate to the same code, so byte-equivalence is
+// structural — the golden parity test (test/parity.test.ts) proves it.
+//
+// Worker-safe: @junejs/core (pure) + react + react-dom/server only. No node:*, no
+// Bun.* — the dev-only and worker-only concerns (fs route discovery vs frozen
+// manifest) are injected as a RouteResolver, not branched on here.
+
+import React from "react";
+// renderToReadableStream (NOT renderToStaticMarkup): it is the ONE render
+// function present in every react-dom/server build — node, browser, AND edge.
+// workerd resolves react-dom/server to server.edge (server.browser needs
+// MessageChannel), which exports only the streaming API (reminder #3). Using it
+// on both dev and worker keeps the bundle workerd-ready AND byte-equivalent.
+import { renderToReadableStream } from "react-dom/server";
+
+import {
+  resolveProjection,
+  type BrandedRoute,
+  type Metadata,
+  type RenderTarget,
+  type RouteContext,
+} from "@junejs/core/route";
+import { Document, type DocumentConfig } from "@junejs/core/document";
+import { isResourceManifest } from "@junejs/core/agent";
+import {
+  apiCatalog,
+  buildLinkHeader,
+  llmsTxt,
+  mcpServerCard,
+  robotsTxt,
+  sitemapXml,
+} from "@junejs/core/discovery";
+import { mcpHandler } from "@junejs/core/mcp";
+import type { AgentConfig } from "@junejs/core/config";
+import type { Resources } from "@junejs/core/resources";
+
+import { negotiate } from "./negotiate";
+
+export type LayoutComponent = React.ComponentType<{ children: React.ReactNode }>;
+
+// What a resolver returns for a matched pathname: the route definition, its
+// params, and the layout chain (root→leaf) that wraps it.
+export type Resolved = {
+  def: BrandedRoute;
+  params: Record<string, string>;
+  chain: LayoutComponent[];
+};
+
+// The one thing dev and worker do differently: turn a clean pathname into a
+// matched route. Dev walks the filesystem; the worker reads the frozen manifest.
+export type RouteResolver = (pathname: string) => Promise<Resolved | null>;
+
+export type PipelineConfig = {
+  docConfig: DocumentConfig;
+  agent: AgentConfig;
+  // The route list for discovery surfaces (sitemap / llms.txt). Async so dev can
+  // re-scan the filesystem; the worker returns a frozen array.
+  routeList: () => Promise<string[]> | string[];
+  resolve: RouteResolver;
+  // Opened data resources (db/kv/blob) injected onto ctx before load(). A
+  // provider so opening is lazy/memoized; absent → no resources on ctx.
+  resources?: () => Promise<Resources> | Resources;
+  earlyHints?: string[];
+  htmlCacheControl?: string;
+  notFoundComponent?: React.ComponentType<{ pathname: string }>;
+  // The app's pre-route escape hatch (app/_extra.*): runs after the agent
+  // surface, before route resolution. Return null to fall through. For
+  // responses route() can't express yet (binary, custom content types) —
+  // e.g. an og:image PNG route.
+  extra?: ExtraHandler;
+};
+
+export type ExtraHandler = (
+  request: Request,
+  url: URL,
+) => Promise<Response | null> | Response | null;
+
+export type Pipeline = { fetch(request: Request): Promise<Response> };
+
+const DefaultNotFound: React.ComponentType<{ pathname: string }> = ({ pathname }) =>
+  React.createElement(
+    "main",
+    null,
+    React.createElement("h1", null, "404 — Not found"),
+    React.createElement("p", null, pathname),
+  );
+
+function text(body: string, contentType: string, init?: ResponseInit) {
+  const headers = new Headers(init?.headers);
+  headers.set("content-type", contentType);
+  return new Response(body, { ...init, headers });
+}
+
+export function createPipeline(cfg: PipelineConfig): Pipeline {
+  const { docConfig, agent } = cfg;
+  const NotFound = cfg.notFoundComponent ?? DefaultNotFound;
+
+  function htmlHeaders(): Headers {
+    const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
+    const links = [buildLinkHeader(agent), ...(cfg.earlyHints ?? [])].filter(Boolean) as string[];
+    if (links.length) headers.set("link", links.join(", "));
+    if (cfg.htmlCacheControl) headers.set("cache-control", cfg.htmlCacheControl);
+    return headers;
+  }
+
+  async function renderDocument(
+    node: React.ReactNode,
+    metadata: Metadata | undefined,
+    status: number,
+    chain: LayoutComponent[],
+  ): Promise<Response> {
+    // Wrap root→leaf: chain[0] is outermost.
+    const wrapped = chain.reduceRight<React.ReactNode>(
+      (acc, L) => React.createElement(L, null, acc),
+      node,
+    );
+    const stream = await renderToReadableStream(
+      React.createElement(Document, { config: docConfig, metadata, children: wrapped }),
+    );
+    await stream.allReady; // fully resolved markup (no streamed Suspense fallbacks)
+    const html = "<!doctype html>\n" + (await new Response(stream).text());
+    return new Response(html, { status, headers: htmlHeaders() });
+  }
+
+  function notFoundResponse(target: RenderTarget, pathname: string): Promise<Response> | Response {
+    // Data clients get a JSON 404; humans get the rendered NotFound document.
+    return target !== "view"
+      ? Response.json({ error: "Not Found", path: pathname }, { status: 404 })
+      : renderDocument(
+          React.createElement(NotFound, { pathname }),
+          { title: "Not found", robots: "noindex" },
+          404,
+          [],
+        );
+  }
+
+  function resolveMeta(def: BrandedRoute, data: unknown, ctx: RouteContext): Metadata | undefined {
+    return typeof def.metadata === "function"
+      ? (def.metadata as (d: unknown, c: RouteContext) => Metadata)(data, ctx)
+      : def.metadata;
+  }
+
+  async function renderMarkdown(def: BrandedRoute, data: unknown, ctx: RouteContext): Promise<Response> {
+    if (def.md) return text(await def.md(data, ctx), "text/markdown; charset=utf-8");
+    const payload = def.json ? await def.json(data, ctx) : data;
+    return text("```json\n" + JSON.stringify(payload, null, 2) + "\n```\n", "text/markdown; charset=utf-8");
+  }
+
+  async function renderProjection(
+    resolved: Resolved,
+    target: RenderTarget,
+    data: unknown,
+    ctx: RouteContext,
+  ): Promise<Response> {
+    const { def, chain } = resolved;
+    if (target === "md") return renderMarkdown(def, data, ctx);
+
+    switch (resolveProjection(def, target)) {
+      case "json":
+        return Response.json(await def.json!(data, ctx));
+      case "agent": {
+        const out = await def.agent!(data, ctx);
+        const body = isResourceManifest(out) ? out.toManifest() : out;
+        return text(JSON.stringify(body), "application/vnd.june-agent+json");
+      }
+      default: {
+        const node = def.view ? def.view(data, ctx) : null;
+        return renderDocument(node, resolveMeta(def, data, ctx), 200, chain);
+      }
+    }
+  }
+
+  async function discovery(url: URL): Promise<Response | null> {
+    switch (url.pathname) {
+      case "/llms.txt":
+        return text(
+          llmsTxt(url.origin, await cfg.routeList(), agent, docConfig.site),
+          "text/markdown; charset=utf-8",
+        );
+      case "/robots.txt":
+        return text(robotsTxt(url.origin), "text/plain; charset=utf-8");
+      case "/sitemap.xml":
+        return text(sitemapXml(url.origin, await cfg.routeList()), "application/xml; charset=utf-8");
+      case "/.well-known/api-catalog":
+        return text(JSON.stringify(apiCatalog(url.origin, agent)), "application/linkset+json");
+      case "/.well-known/mcp/server-card.json":
+        return agent.mcp ? Response.json(mcpServerCard(url.origin)) : null;
+      default:
+        return null;
+    }
+  }
+
+  return {
+    async fetch(request: Request): Promise<Response> {
+      const url = new URL(request.url);
+
+      // --- agent surface ---------------------------------------------------
+      if (url.pathname === "/mcp") {
+        if (!agent.mcp) return notFoundResponse("view", url.pathname);
+        // The agent's tool calls run through the same resources (and, once auth
+        // is wired, the same principal) the UI uses.
+        const res = cfg.resources ? await cfg.resources() : undefined;
+        return mcpHandler(request, { request, db: res?.db, kv: res?.kv, blob: res?.blob });
+      }
+      if (request.method === "GET" && agent.discovery) {
+        const d = await discovery(url);
+        if (d) return d;
+      }
+
+      // --- app escape hatch --------------------------------------------------
+      // After the agent surface (framework-owned), before routes: the app can
+      // claim any path the route conventions can't express yet.
+      if (cfg.extra) {
+        const out = await cfg.extra(request, url);
+        if (out) return out;
+      }
+
+      // --- routes ----------------------------------------------------------
+      const { target, pathname, speculative } = negotiate(url, request);
+      const resolved = await cfg.resolve(pathname);
+      if (!resolved) return notFoundResponse(target, pathname);
+
+      const res = cfg.resources ? await cfg.resources() : undefined;
+      const ctx: RouteContext = {
+        request,
+        url,
+        params: resolved.params,
+        target,
+        speculative,
+        db: res?.db,
+        kv: res?.kv,
+        blob: res?.blob,
+      };
+      let data: unknown;
+      try {
+        data = resolved.def.load ? await resolved.def.load(ctx) : undefined;
+      } catch {
+        // unknown slug etc. → 404 (segment error boundaries are a later milestone)
+        return notFoundResponse(target, pathname);
+      }
+      return renderProjection(resolved, target, data, ctx);
+    },
+  };
+}

package/src/resources.ts

@@ -0,0 +1,28 @@
+// Resource resolution — open the handles declared in june.config.ts `resources`
+// and hand them to the pipeline, which injects them onto RouteContext (ctx.db /
+// ctx.kv / ctx.blob). A resource not declared is never opened (and, for static
+// apps, tree-shaken out — the build freeze knows which routes touch resources).
+
+import type { ResourceConfig, Resources } from "@junejs/core/resources";
+
+// Open every declared resource once. Returns a memoized provider so the same
+// long-lived handles are reused across requests (one SQLite connection, etc.).
+export function memoizeResources(
+  config?: ResourceConfig,
+): () => Promise<Resources> {
+  if (!config || (!config.db && !config.kv && !config.blob)) {
+    const empty: Resources = {};
+    return () => Promise.resolve(empty);
+  }
+  let opened: Promise<Resources> | null = null;
+  return () => {
+    if (!opened) {
+      opened = (async () => ({
+        db: config.db ? await config.db.open() : undefined,
+        kv: config.kv ? await config.kv.open() : undefined,
+        blob: config.blob ? await config.blob.open() : undefined,
+      }))();
+    }
+    return opened;
+  };
+}

package/src/router.ts

@@ -0,0 +1,263 @@
+// The file-route matcher: a recursive-descent walk over the app directory that
+// turns a URL into (page file, params, segment chain). The SAME conventions
+// drive `june dev` and `june build` (rebuild-plan Phase 3) — one matcher, no
+// drift between what dev serves and what the build freezes.
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+
+export type RouteMatch = {
+  file: string;
+  params: Record<string, string>;
+};
+
+// One directory level of a matched route, root → … → the page's own dir. Each
+// level contributes its special files to the rendered tree: layout wraps,
+// loading becomes a Suspense fallback, error becomes the recovery UI for the
+// segment's load/render, not-found resolves 404s for paths under it.
+export type SegmentMatch = {
+  dir: string;
+  layout?: string;
+  loading?: string;
+  error?: string;
+  notFound?: string;
+};
+
+export type RouteTreeMatch = {
+  file: string;
+  params: Record<string, string>;
+  segments: SegmentMatch[];
+};
+
+const routeExtensions = new Set([".tsx", ".jsx", ".ts", ".js"]);
+
+// app/_extra.* — the pre-route escape hatch (a `_` file, so never a route).
+// Dev and the build look it up through this ONE helper so the conventions
+// cannot drift.
+export function findExtraFile(appDir: string): string | null {
+  for (const ext of routeExtensions) {
+    const f = join(appDir, `_extra${ext}`);
+    if (existsSync(f)) return f;
+  }
+  return null;
+}
+
+export type MatchOptions = {
+  // When true, only `page.*` and `index.*` files are routes. This lets a route
+  // folder colocate `model.ts`, `actions.ts`, `queries.ts`, `_components/`,
+  // `_tests/` without them becoming accidental routes.
+  pageConvention?: boolean;
+};
+
+function baseName(file: string) {
+  return (file.split(sep).pop() ?? "").replace(/\.[^.]+$/, "");
+}
+
+function isPageFile(file: string) {
+  const base = baseName(file);
+  return base === "page" || base === "index";
+}
+
+// Special (never-a-route) files that shape the segment tree.
+const SPECIAL_FILES = new Set(["layout", "loading", "error", "not-found"]);
+
+function isSpecialFile(file: string) {
+  return SPECIAL_FILES.has(baseName(file));
+}
+
+const isRouteGroup = (name: string) => /^\(.+\)$/.test(name);
+const isParamDir = (name: string) => /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
+const isCatchAllDir = (name: string) => /^\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
+const paramName = (name: string) => name.replace(/^\[(\.\.\.)?|\]$/g, "");
+
+type DirEntry = { name: string; dir: boolean };
+
+async function listDir(dir: string): Promise<DirEntry[]> {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  return entries
+    .filter((e) => !e.name.startsWith("_") && !e.name.startsWith("."))
+    .map((e) => ({ name: e.name, dir: e.isDirectory() }));
+}
+
+function fileFor(entries: DirEntry[], dir: string, base: string): string | undefined {
+  for (const ext of [".tsx", ".jsx", ".ts", ".js"]) {
+    if (entries.some((e) => !e.dir && e.name === base + ext)) return join(dir, base + ext);
+  }
+  return undefined;
+}
+
+function segmentAt(dir: string, entries: DirEntry[]): SegmentMatch {
+  return {
+    dir,
+    layout: fileFor(entries, dir, "layout"),
+    loading: fileFor(entries, dir, "loading"),
+    error: fileFor(entries, dir, "error"),
+    notFound: fileFor(entries, dir, "not-found"),
+  };
+}
+
+async function walk(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const files = await Promise.all(
+    entries.map((entry) => {
+      const path = join(dir, entry.name);
+      return entry.isDirectory() ? walk(path) : [path];
+    }),
+  );
+
+  return files.flat();
+}
+
+function routePath(appDir: string, file: string) {
+  const rel = relative(appDir, file).split(sep).join("/");
+  const withoutExtension = rel.replace(/\.[^.]+$/, "");
+  // Route groups shape the filesystem, not the URL.
+  const parts = withoutExtension.split("/").filter((p) => !isRouteGroup(p));
+
+  if (parts.at(-1) === "page" || parts.at(-1) === "index") {
+    parts.pop();
+  }
+
+  return `/${parts.join("/")}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+
+// Recursive-descent matcher over the app directory. Priority at every level:
+// exact static segment > [param] > [...catchAll]; route groups `(name)` descend
+// without consuming a URL segment; `_`-prefixed entries never participate.
+// Returns the page file, accumulated params (catch-all joins with "/"), and the
+// chain of segments (with their special files) from the app root to the page.
+export async function matchRouteTree(
+  appDir: string,
+  pathname: string,
+  options: MatchOptions = {},
+): Promise<RouteTreeMatch | null> {
+  const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);
+
+  async function descend(
+    dir: string,
+    rest: string[],
+    params: Record<string, string>,
+    chain: SegmentMatch[],
+  ): Promise<RouteTreeMatch | null> {
+    const entries = await listDir(dir);
+    const segments = [...chain, segmentAt(dir, entries)];
+
+    // Terminal: URL consumed → find the page in this dir.
+    if (rest.length === 0) {
+      const page = fileFor(entries, dir, "page") ?? fileFor(entries, dir, "index");
+      if (page) return { file: page, params, segments };
+    } else if (!options.pageConvention) {
+      // Legacy flat convention: a non-special leaf FILE names the final segment
+      // (examples/rsc: about.tsx → /about). Only valid for the last segment.
+      if (rest.length === 1) {
+        const leaf = fileFor(entries, dir, rest[0]!);
+        if (leaf && !isSpecialFile(leaf) && !isPageFile(leaf)) {
+          return { file: leaf, params, segments };
+        }
+      }
+    }
+
+    // Route groups: try descending into every (group) without consuming URL.
+    for (const e of entries) {
+      if (!e.dir || !isRouteGroup(e.name)) continue;
+      const hit = await descend(join(dir, e.name), rest, params, segments);
+      if (hit) return hit;
+    }
+
+    if (rest.length === 0) return null;
+    const [head, ...tail] = rest as [string, ...string[]];
+
+    // 1) exact static dir
+    const exact = entries.find((e) => e.dir && e.name === head);
+    if (exact) {
+      const hit = await descend(join(dir, head), tail, params, segments);
+      if (hit) return hit;
+    }
+    // 2) [param] dirs
+    for (const e of entries) {
+      if (!e.dir || !isParamDir(e.name)) continue;
+      const hit = await descend(
+        join(dir, e.name),
+        tail,
+        { ...params, [paramName(e.name)]: head },
+        segments,
+      );
+      if (hit) return hit;
+    }
+    // 3) [...catchAll] dirs consume everything remaining
+    for (const e of entries) {
+      if (!e.dir || !isCatchAllDir(e.name)) continue;
+      const hit = await descend(
+        join(dir, e.name),
+        [],
+        { ...params, [paramName(e.name)]: rest.join("/") },
+        segments,
+      );
+      if (hit) return hit;
+    }
+
+    return null;
+  }
+
+  return descend(appDir, urlSegments, {}, []);
+}
+
+// 404 path: walk the longest matchable STATIC prefix of the URL collecting
+// segments, so the not-found page renders inside the layouts it lives under;
+// the not-found file is the nearest one up that chain.
+export async function resolveNotFound(
+  appDir: string,
+  pathname: string,
+): Promise<{ segments: SegmentMatch[]; notFound?: string }> {
+  const urlSegments = pathname.split("/").filter(Boolean).map(decodeURIComponent);
+  const segments: SegmentMatch[] = [];
+  let dir = appDir;
+
+  for (let i = 0; i <= urlSegments.length; i++) {
+    const entries = await listDir(dir);
+    segments.push(segmentAt(dir, entries));
+    if (i === urlSegments.length) break;
+    const next = entries.find((e) => e.dir && e.name === urlSegments[i]);
+    if (!next) break;
+    dir = join(dir, next.name);
+  }
+
+  const notFound = [...segments].reverse().find((s) => s.notFound)?.notFound;
+  return { segments, notFound };
+}
+
+// Every route FILE under appDir (absolute paths). Special files
+// (layout/loading/error/not-found) and `_`-prefixed entries are never routes.
+// Used by discovery (route list) and by the dev-server warmup that imports each
+// route module so its defineAction() side effects register before /mcp is hit.
+export async function routeFiles(
+  appDir: string,
+  options: MatchOptions = {},
+): Promise<string[]> {
+  return (await walk(appDir)).filter((file) => {
+    if (!routeExtensions.has(file.match(/\.[^.]+$/)?.[0] ?? "")) return false;
+    if (isSpecialFile(file)) return false;
+    if (file.split(sep).some((p) => p.startsWith("_"))) return false;
+    if (options.pageConvention && !isPageFile(file)) return false;
+    return true;
+  });
+}
+
+// All route paths under appDir (for sitemap / llms.txt / api-catalog).
+export async function listRoutes(
+  appDir: string,
+  options: MatchOptions = {},
+): Promise<string[]> {
+  const files = await routeFiles(appDir, options);
+  return [...new Set(files.map((file) => routePath(appDir, file)))].sort();
+}
+
+// Flat-shaped result; delegates to the tree matcher.
+export async function matchRoute(
+  appDir: string,
+  pathname: string,
+  options: MatchOptions = {},
+): Promise<RouteMatch | null> {
+  const tree = await matchRouteTree(appDir, pathname, options);
+  return tree ? { file: tree.file, params: tree.params } : null;
+}

package/src/worker.ts

@@ -0,0 +1,101 @@
+// The built worker's runtime — what `june build` GENERATES an entry for.
+// workerd has no filesystem, so everything the dev server discovers at request
+// time (routes, config, content, layout chains) arrives here as a FROZEN
+// manifest built at build time. createWorker() feeds that manifest to the SAME
+// render core the dev server uses (pipeline.ts) — so the built surfaces are
+// byte-equivalent to dev (test/parity.test.ts proves it), not a re-implementation.
+//
+// Worker-safe by construction: this file + pipeline.ts touch only @junejs/core +
+// react. The content pipeline's fs reads are frozen into the manifest at build,
+// never run here.
+
+import type React from "react";
+
+import type { BrandedRoute } from "@junejs/core/route";
+import type { AgentConfig } from "@junejs/core/config";
+import type { DocumentConfig } from "@junejs/core/document";
+import type { Resources } from "@junejs/core/resources";
+
+import { createPipeline, type ExtraHandler, type LayoutComponent, type Resolved } from "./pipeline";
+
+export type WorkerManifest = {
+  // Static paths → route definitions ("/", "/users", ...).
+  routes: Record<string, BrandedRoute>;
+  // Dynamic patterns in file-route syntax ("/posts/[slug]", "/docs/[...path]").
+  dynamicRoutes?: Array<{ pattern: string; def: BrandedRoute }>;
+  // Layout chains (root→leaf) keyed by route path / dynamic pattern. The build
+  // freezes the same chain the dev server loads from app/layout.* files.
+  layoutChains?: Record<string, LayoutComponent[]>;
+  document: DocumentConfig;
+  agent: AgentConfig;
+  // Preload Link values (config earlyHints + auto font hints), frozen at build.
+  earlyHints?: string[];
+  htmlCacheControl?: string;
+  notFound?: React.ComponentType<{ pathname: string }>;
+  // The app/_extra.* pre-route handler, imported by the generated entry.
+  extra?: ExtraHandler;
+  // Opened data resources (db/kv/blob) injected onto ctx. On workerd the D1/KV/R2
+  // bindings come from env per request, so the generated entry passes a provider.
+  resources?: () => Promise<Resources> | Resources;
+};
+
+type Compiled = { regex: RegExp; names: string[]; def: BrandedRoute; pattern: string };
+
+// "/posts/[slug]" | "/docs/[...path]" → matcher
+function compilePattern(pattern: string): { regex: RegExp; names: string[] } {
+  const names: string[] = [];
+  const source = pattern
+    .split("/")
+    .map((seg) => {
+      const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
+      if (ca) {
+        names.push(ca[1]!);
+        return "(.+)";
+      }
+      const p = seg.match(/^\[(\w+)\]$/);
+      if (p) {
+        names.push(p[1]!);
+        return "([^/]+)";
+      }
+      return seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
+    })
+    .join("/");
+  return { regex: new RegExp(`^${source}$`), names };
+}
+
+export function createWorker(manifest: WorkerManifest): { fetch(request: Request): Promise<Response> } {
+  const dynamic: Compiled[] = (manifest.dynamicRoutes ?? []).map((d) => ({
+    ...compilePattern(d.pattern),
+    def: d.def,
+    pattern: d.pattern,
+  }));
+  const routeList = [
+    ...Object.keys(manifest.routes),
+    ...(manifest.dynamicRoutes ?? []).map((d) => d.pattern),
+  ].sort();
+
+  const chainFor = (key: string): LayoutComponent[] => manifest.layoutChains?.[key] ?? [];
+
+  return createPipeline({
+    docConfig: manifest.document,
+    agent: manifest.agent,
+    routeList: () => routeList,
+    earlyHints: manifest.earlyHints,
+    htmlCacheControl: manifest.htmlCacheControl,
+    notFoundComponent: manifest.notFound,
+    extra: manifest.extra,
+    resources: manifest.resources,
+    resolve: async (pathname): Promise<Resolved | null> => {
+      const staticDef = manifest.routes[pathname];
+      if (staticDef) return { def: staticDef, params: {}, chain: chainFor(pathname) };
+      for (const d of dynamic) {
+        const m = pathname.match(d.regex);
+        if (m) {
+          const params = Object.fromEntries(d.names.map((n, i) => [n, decodeURIComponent(m[i + 1]!)]));
+          return { def: d.def, params, chain: chainFor(d.pattern) };
+        }
+      }
+      return null;
+    },
+  });
+}