@alisio/server 0.1.0-alpha.1

package/dist/host/workspace-host.d.ts

@@ -0,0 +1,87 @@
+import { type AppOptions, createApplication, type SQLiteStore } from "@alisio/core";
+import type { WorkspaceInfo } from "@alisio/sdk";
+export type Application = Awaited<ReturnType<typeof createApplication>>;
+/** `AppOptions` minus what the server owns per workspace (cwd, events, approvals). */
+export type ServerAppOptions = Omit<AppOptions, "cwd" | "onEvent" | "approve" | "approveExternalDirectory">;
+/** An open workspace: one `Application` bound to one canonical path. */
+export interface OpenWorkspace {
+    id: string;
+    path: string;
+    app: Application;
+    trusted: boolean;
+    untrustedResources: boolean;
+    lastUsed: number;
+}
+export interface WorkspaceHostOptions {
+    base: ServerAppOptions;
+    /** Server-level store over the same database (workspace list, metadata). */
+    catalog: SQLiteStore;
+    maxOpen?: number;
+    /** Close an app after this long without runs, subscribers or approvals (default 10 min). */
+    idleEvictMs?: number;
+    /** Listed even before it has sessions (e.g. the directory `alisio serve` ran in). */
+    defaultWorkspace?: string;
+    /** Per-workspace wiring the server owns: events and approval handlers. */
+    wire?: (id: string, path: string) => Pick<AppOptions, "onEvent" | "approve" | "approveExternalDirectory">;
+    /** Called once an app is created (e.g. to bind interactive UI) and before it is closed. */
+    onOpen?: (workspace: OpenWorkspace) => void;
+    onClose?: (workspace: OpenWorkspace) => void;
+    /** A workspace with runs, subscribers or pending approvals is never evicted. */
+    busy?: (id: string) => boolean;
+    /** Injectable for tests. */
+    create?: typeof createApplication;
+    now?: () => number;
+}
+/** Opaque, stable workspace id: a short sha256 of the canonical path (never a path in URLs). */
+export declare const workspaceId: (path: string) => string;
+/**
+ * One lazily created `Application` per workspace (ADR-06), with LRU eviction of idle apps,
+ * a cap on open apps and trust resolved from the terminal's trust store (the web never grants
+ * trust). All apps share the same session database (WAL).
+ */
+export declare class WorkspaceHost {
+    private options;
+    private open;
+    private opening;
+    private readonly maxOpen;
+    private readonly idleEvictMs;
+    private readonly now;
+    private closed;
+    constructor(options: WorkspaceHostOptions);
+    /** Canonical workspace root of a directory (realpath, then the enclosing git root). */
+    canonical(path: string): Promise<string>;
+    get openCount(): number;
+    /** Open workspaces (no side effects). */
+    entries(): OpenWorkspace[];
+    get(id: string): OpenWorkspace | undefined;
+    /** Opens (or reuses) the app of a canonical workspace path, evicting an idle one if needed. */
+    openPath(path: string): Promise<OpenWorkspace>;
+    private create;
+    /** Closes the least recently used idle app, or fails with 503 `workspace_limit`. */
+    private evictOne;
+    /** Marks a workspace as used now (keeps it out of idle eviction). */
+    touch(id: string): void;
+    /** Closes apps idle for longer than `idleEvictMs`; returns how many were closed. */
+    sweep(): Promise<number>;
+    close(id: string): Promise<void>;
+    /**
+     * Closes and reopens a workspace's app so configuration read at startup (plugins, skills) takes
+     * effect. Callers make sure it has no runs; SSE subscribers are unaffected (they read the
+     * shared store) and the next request uses the new app.
+     */
+    recycle(id: string): Promise<OpenWorkspace | undefined>;
+    /** Closes every app in parallel (each close is capped by the core's teardown timeouts). */
+    closeAll(): Promise<void>;
+    /** Every known workspace: recorded or with root sessions, the default one and the open ones. */
+    list(): Promise<WorkspaceInfo[]>;
+    /** The `WorkspaceInfo` of one canonical path. */
+    info(path: string, meta?: {
+        path: string;
+        label?: string;
+        pinned: boolean;
+        lastOpenedAt?: number;
+        sessions: number;
+    } | undefined): Promise<WorkspaceInfo>;
+    /** Canonical path of a workspace id among the known ones. */
+    pathOf(id: string): Promise<string | undefined>;
+}

package/dist/host/workspace-host.js

@@ -0,0 +1,195 @@
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { createApplication, findWorkspace, resolveTrust, } from "@alisio/core";
+import { HttpError } from "../http/errors.js";
+/** Opaque, stable workspace id: a short sha256 of the canonical path (never a path in URLs). */
+export const workspaceId = (path) => createHash("sha256").update(path).digest("hex").slice(0, 16);
+/**
+ * One lazily created `Application` per workspace (ADR-06), with LRU eviction of idle apps,
+ * a cap on open apps and trust resolved from the terminal's trust store (the web never grants
+ * trust). All apps share the same session database (WAL).
+ */
+export class WorkspaceHost {
+    options;
+    open = new Map();
+    opening = new Map();
+    maxOpen;
+    idleEvictMs;
+    now;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.maxOpen = options.maxOpen ?? 4;
+        this.idleEvictMs = options.idleEvictMs ?? 10 * 60_000;
+        this.now = options.now ?? Date.now;
+    }
+    /** Canonical workspace root of a directory (realpath, then the enclosing git root). */
+    async canonical(path) {
+        try {
+            if (!(await stat(path)).isDirectory())
+                throw new Error("not a directory");
+            return await findWorkspace(path);
+        }
+        catch {
+            throw new HttpError("not_found", "Directory not found");
+        }
+    }
+    get openCount() {
+        return this.open.size;
+    }
+    /** Open workspaces (no side effects). */
+    entries() {
+        return [...this.open.values()];
+    }
+    get(id) {
+        return this.open.get(id);
+    }
+    /** Opens (or reuses) the app of a canonical workspace path, evicting an idle one if needed. */
+    async openPath(path) {
+        if (this.closed)
+            throw new HttpError("shutting_down", "Server is shutting down");
+        const id = workspaceId(path);
+        const existing = this.open.get(id);
+        if (existing) {
+            existing.lastUsed = this.now();
+            return existing;
+        }
+        const pending = this.opening.get(id);
+        if (pending)
+            return pending;
+        if (this.open.size + this.opening.size >= this.maxOpen)
+            await this.evictOne();
+        const promise = this.create(id, path).finally(() => this.opening.delete(id));
+        this.opening.set(id, promise);
+        return promise;
+    }
+    async create(id, path) {
+        const base = this.options.base;
+        // Launch flags are explicit, one-run trust like in the terminal; otherwise the trust store
+        // decides and a workspace that would need a prompt opens untrusted.
+        const explicit = !!base.trustProject || !!base.config;
+        const trust = explicit ? undefined : await resolveTrust(path);
+        const trusted = explicit || !!trust?.trusted;
+        const app = await (this.options.create ?? createApplication)({
+            ...base,
+            trustProject: explicit ? base.trustProject : trusted,
+            cwd: path,
+            ...(this.options.wire?.(id, path) ?? {}),
+        });
+        const entry = {
+            id,
+            path,
+            app,
+            trusted,
+            untrustedResources: !trusted && !!trust?.hasProjectResources,
+            lastUsed: this.now(),
+        };
+        if (this.closed) {
+            await app.close();
+            throw new HttpError("shutting_down", "Server is shutting down");
+        }
+        this.open.set(id, entry);
+        this.options.catalog.recordWorkspace(path, { lastOpenedAt: entry.lastUsed });
+        this.options.onOpen?.(entry);
+        return entry;
+    }
+    /** Closes the least recently used idle app, or fails with 503 `workspace_limit`. */
+    async evictOne() {
+        const idle = this.entries()
+            .filter((w) => !this.options.busy?.(w.id))
+            .sort((a, b) => a.lastUsed - b.lastUsed)[0];
+        if (!idle)
+            throw new HttpError("workspace_limit", `All ${this.maxOpen} open workspaces are busy; retry when a run finishes`);
+        await this.close(idle.id);
+    }
+    /** Marks a workspace as used now (keeps it out of idle eviction). */
+    touch(id) {
+        const entry = this.open.get(id);
+        if (entry)
+            entry.lastUsed = this.now();
+    }
+    /** Closes apps idle for longer than `idleEvictMs`; returns how many were closed. */
+    async sweep() {
+        const cutoff = this.now() - this.idleEvictMs;
+        const idle = this.entries().filter((w) => w.lastUsed <= cutoff && !this.options.busy?.(w.id));
+        await Promise.all(idle.map((w) => this.close(w.id)));
+        return idle.length;
+    }
+    async close(id) {
+        const entry = this.open.get(id);
+        if (!entry)
+            return;
+        this.open.delete(id);
+        try {
+            this.options.onClose?.(entry);
+        }
+        finally {
+            await entry.app.close();
+        }
+    }
+    /**
+     * Closes and reopens a workspace's app so configuration read at startup (plugins, skills) takes
+     * effect. Callers make sure it has no runs; SSE subscribers are unaffected (they read the
+     * shared store) and the next request uses the new app.
+     */
+    async recycle(id) {
+        const entry = this.open.get(id);
+        if (!entry)
+            return undefined;
+        await this.close(id);
+        return this.openPath(entry.path);
+    }
+    /** Closes every app in parallel (each close is capped by the core's teardown timeouts). */
+    async closeAll() {
+        this.closed = true;
+        await Promise.allSettled([...this.opening.values()]);
+        await Promise.allSettled(this.entries().map((w) => this.close(w.id)));
+    }
+    /** Every known workspace: recorded or with root sessions, the default one and the open ones. */
+    async list() {
+        const known = new Map(this.options.catalog.workspaces().map((w) => [w.path, w]));
+        const paths = new Set(known.keys());
+        for (const w of this.open.values())
+            paths.add(w.path);
+        const fallback = this.options.defaultWorkspace
+            ? await this.canonical(this.options.defaultWorkspace).catch(() => undefined)
+            : undefined;
+        if (fallback)
+            paths.add(fallback);
+        return Promise.all([...paths].sort().map((path) => this.info(path, known.get(path))));
+    }
+    /** The `WorkspaceInfo` of one canonical path. */
+    async info(path, meta = this.options.catalog.workspaces().find((w) => w.path === path)) {
+        const id = workspaceId(path);
+        const entry = this.open.get(id);
+        let trusted = entry?.trusted ?? false;
+        let untrusted = entry?.untrustedResources ?? false;
+        if (!entry) {
+            const base = this.options.base;
+            if (base.trustProject || base.config)
+                trusted = true;
+            else {
+                const trust = await resolveTrust(path).catch(() => undefined);
+                trusted = !!trust?.trusted;
+                untrusted = !trusted && !!trust?.hasProjectResources;
+            }
+        }
+        return {
+            id,
+            path,
+            ...(meta?.label ? { label: meta.label } : {}),
+            pinned: meta?.pinned ?? false,
+            open: !!entry,
+            trusted,
+            untrustedResources: untrusted,
+            ...(meta?.lastOpenedAt !== undefined ? { lastOpenedAt: meta.lastOpenedAt } : {}),
+        };
+    }
+    /** Canonical path of a workspace id among the known ones. */
+    async pathOf(id) {
+        const open = this.open.get(id);
+        if (open)
+            return open.path;
+        return (await this.list()).find((w) => w.id === id)?.path;
+    }
+}

package/dist/http/body.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage } from "node:http";
+/** Default JSON body limit (§11.1: JSON bodies ≤ 1 MB). */
+export declare const MAX_JSON_BYTES: number;
+/** Reads the whole request body, failing with 413 as soon as it exceeds `limit` bytes. */
+export declare function readBody(req: IncomingMessage, limit?: number): Promise<Buffer>;
+/** Reads and parses a JSON body; an empty body is `{}`. Malformed JSON is a 400. */
+export declare function readJson(req: IncomingMessage, limit?: number): Promise<unknown>;

package/dist/http/body.js

@@ -0,0 +1,33 @@
+import { HttpError } from "./errors.js";
+/** Default JSON body limit (§11.1: JSON bodies ≤ 1 MB). */
+export const MAX_JSON_BYTES = 1024 * 1024;
+/** Reads the whole request body, failing with 413 as soon as it exceeds `limit` bytes. */
+export async function readBody(req, limit = MAX_JSON_BYTES) {
+    const declared = Number(req.headers["content-length"] ?? Number.NaN);
+    if (Number.isFinite(declared) && declared > limit)
+        throw new HttpError("payload_too_large", `Request body exceeds ${limit} bytes`);
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = chunk;
+        size += buffer.length;
+        if (size > limit) {
+            req.resume();
+            throw new HttpError("payload_too_large", `Request body exceeds ${limit} bytes`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+/** Reads and parses a JSON body; an empty body is `{}`. Malformed JSON is a 400. */
+export async function readJson(req, limit = MAX_JSON_BYTES) {
+    const raw = await readBody(req, limit);
+    if (raw.length === 0)
+        return {};
+    try {
+        return JSON.parse(raw.toString("utf8"));
+    }
+    catch {
+        throw new HttpError("validation_failed", "Request body is not valid JSON");
+    }
+}

package/dist/http/errors.d.ts

@@ -0,0 +1,15 @@
+import type { ApiError, ApiErrorCode } from "@alisio/sdk";
+/** HTTP status for every web API error code (§8.3). */
+export declare const STATUS: Record<ApiErrorCode, number>;
+/** A typed API failure; routes throw it and the server renders it as an `ApiError` body. */
+export declare class HttpError extends Error {
+    readonly code: ApiErrorCode;
+    readonly details?: unknown;
+    constructor(code: ApiErrorCode, message: string, details?: unknown);
+    get status(): number;
+}
+/** Renders any thrown value as an `ApiError`; unknown errors become a generic 500. */
+export declare function toApiError(error: unknown, correlationId: string): {
+    status: number;
+    body: ApiError;
+};

package/dist/http/errors.js

@@ -0,0 +1,58 @@
+/** HTTP status for every web API error code (§8.3). */
+export const STATUS = {
+    unauthorized: 401,
+    forbidden_origin: 403,
+    forbidden_host: 403,
+    validation_failed: 400,
+    not_found: 404,
+    unknown_command: 404,
+    session_busy: 409,
+    session_locked: 409,
+    workspace_limit: 503,
+    payload_too_large: 413,
+    unsupported_media_type: 415,
+    path_outside_workspace: 403,
+    not_a_git_repo: 409,
+    approval_resolved: 409,
+    capability_ceiling: 403,
+    not_manageable: 403,
+    mcp_not_permitted: 403,
+    runs_active: 409,
+    provider_unavailable: 502,
+    protocol_mismatch: 426,
+    shutting_down: 503,
+    stream_limit: 503,
+    internal: 500,
+};
+/** A typed API failure; routes throw it and the server renders it as an `ApiError` body. */
+export class HttpError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+    get status() {
+        return STATUS[this.code];
+    }
+}
+/** Renders any thrown value as an `ApiError`; unknown errors become a generic 500. */
+export function toApiError(error, correlationId) {
+    if (error instanceof HttpError)
+        return {
+            status: error.status,
+            body: {
+                error: {
+                    code: error.code,
+                    message: error.message,
+                    ...(error.details !== undefined ? { details: error.details } : {}),
+                },
+                correlationId,
+            },
+        };
+    return {
+        status: 500,
+        body: { error: { code: "internal", message: "Internal server error" }, correlationId },
+    };
+}

package/dist/http/router.d.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** Everything a route handler receives for one request. */
+export interface RouteContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    url: URL;
+    params: Record<string, string>;
+    /** `X-Request-Id` of the request (validated or generated); also the run correlation id. */
+    correlationId: string;
+}
+/**
+ * A route returns a JSON-serializable value (sent with `status`, 200 by default), or
+ * `undefined` after writing the response itself (e.g. an SSE stream).
+ */
+export type RouteResult = {
+    status?: number;
+    body: unknown;
+} | undefined;
+export type RouteHandler = (ctx: RouteContext) => Promise<RouteResult> | RouteResult;
+/** Minimal method + path router with `:param` segments (no regex, no wildcards). */
+export declare class Router {
+    private routes;
+    add(method: string, path: string, handler: RouteHandler): this;
+    get(path: string, handler: RouteHandler): this;
+    post(path: string, handler: RouteHandler): this;
+    patch(path: string, handler: RouteHandler): this;
+    put(path: string, handler: RouteHandler): this;
+    delete(path: string, handler: RouteHandler): this;
+    /**
+     * The handler and params for a request, `"method"` when the path exists with another method,
+     * or `undefined` when no route matches the path.
+     */
+    match(method: string, pathname: string): {
+        handler: RouteHandler;
+        params: Record<string, string>;
+    } | "method" | undefined;
+}

package/dist/http/router.js

@@ -0,0 +1,62 @@
+/** Minimal method + path router with `:param` segments (no regex, no wildcards). */
+export class Router {
+    routes = [];
+    add(method, path, handler) {
+        this.routes.push({ method, segments: path.split("/").filter(Boolean), handler });
+        return this;
+    }
+    get(path, handler) {
+        return this.add("GET", path, handler);
+    }
+    post(path, handler) {
+        return this.add("POST", path, handler);
+    }
+    patch(path, handler) {
+        return this.add("PATCH", path, handler);
+    }
+    put(path, handler) {
+        return this.add("PUT", path, handler);
+    }
+    delete(path, handler) {
+        return this.add("DELETE", path, handler);
+    }
+    /**
+     * The handler and params for a request, `"method"` when the path exists with another method,
+     * or `undefined` when no route matches the path.
+     */
+    match(method, pathname) {
+        const parts = pathname.split("/").filter(Boolean);
+        let pathMatched = false;
+        for (const route of this.routes) {
+            const params = matchSegments(route.segments, parts);
+            if (!params)
+                continue;
+            if (route.method === method)
+                return { handler: route.handler, params };
+            pathMatched = true;
+        }
+        return pathMatched ? "method" : undefined;
+    }
+}
+function matchSegments(pattern, parts) {
+    if (pattern.length !== parts.length)
+        return undefined;
+    const params = {};
+    for (let i = 0; i < pattern.length; i++) {
+        const expected = pattern[i];
+        const actual = parts[i];
+        if (expected.startsWith(":")) {
+            let decoded;
+            try {
+                decoded = decodeURIComponent(actual);
+            }
+            catch {
+                return undefined;
+            }
+            params[expected.slice(1)] = decoded;
+        }
+        else if (expected !== actual)
+            return undefined;
+    }
+    return params;
+}

package/dist/http/static.d.ts

@@ -0,0 +1,27 @@
+import type { ServerResponse } from "node:http";
+/**
+ * Default location of the web UI build: `dist/web` next to the compiled server
+ * (`packages/server/dist/web`, filled by the `@alisio/web` build in phase 3).
+ */
+export declare function defaultWebRoot(): string;
+/** Served when the web UI assets are not installed (source checkouts, standalone binary). */
+export declare const PLACEHOLDER_HTML = "<!doctype html>\n<html lang=\"en\">\n<head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<title>Alisio</title></head>\n<body style=\"font-family: system-ui, sans-serif; max-width: 40rem; margin: 3rem auto; padding: 0 1rem\">\n<h1>Alisio server is running</h1>\n<p>The web UI assets are not installed in this build, so only the HTTP API is available\n(<a href=\"/api/health\">/api/health</a>). Install the npm package <code>@alisio/alisio-code</code>\nto get the web UI.</p>\n</body>\n</html>\n";
+/** SHA-256 CSP sources for every inline `<script>` of an HTML document. */
+export declare function inlineScriptHashes(html: string): string[];
+/** The Content-Security-Policy of §11.1, allowing the given inline script hashes. */
+export declare function contentSecurityPolicy(scriptHashes?: string[]): string;
+/**
+ * Serves the web UI build with an SPA fallback to `index.html`. Paths are confined to the root
+ * (resolved and realpath-checked); a missing build serves {@link PLACEHOLDER_HTML}.
+ */
+export declare class StaticAssets {
+    readonly root: string;
+    readonly installed: boolean;
+    readonly index: string;
+    readonly csp: string;
+    constructor(root?: string);
+    /** Serves a GET/HEAD for a non-API path. */
+    serve(res: ServerResponse, pathname: string, head?: boolean): Promise<void>;
+    private resolveFile;
+    private send;
+}

package/dist/http/static.js

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { dirname, extname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".txt": "text/plain; charset=utf-8",
+    ".map": "application/json; charset=utf-8",
+    ".wasm": "application/wasm",
+};
+/**
+ * Default location of the web UI build: `dist/web` next to the compiled server
+ * (`packages/server/dist/web`, filled by the `@alisio/web` build in phase 3).
+ */
+export function defaultWebRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "web");
+}
+/** Served when the web UI assets are not installed (source checkouts, standalone binary). */
+export const PLACEHOLDER_HTML = `<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Alisio</title></head>
+<body style="font-family: system-ui, sans-serif; max-width: 40rem; margin: 3rem auto; padding: 0 1rem">
+<h1>Alisio server is running</h1>
+<p>The web UI assets are not installed in this build, so only the HTTP API is available
+(<a href="/api/health">/api/health</a>). Install the npm package <code>@alisio/alisio-code</code>
+to get the web UI.</p>
+</body>
+</html>
+`;
+/** SHA-256 CSP sources for every inline `<script>` of an HTML document. */
+export function inlineScriptHashes(html) {
+    const hashes = [];
+    for (const match of html.matchAll(/<script(?![^>]*\bsrc=)[^>]*>([\s\S]*?)<\/script>/gi)) {
+        const body = match[1] ?? "";
+        if (body.trim())
+            hashes.push(`'sha256-${createHash("sha256").update(body, "utf8").digest("base64")}'`);
+    }
+    return hashes;
+}
+/** The Content-Security-Policy of §11.1, allowing the given inline script hashes. */
+export function contentSecurityPolicy(scriptHashes = []) {
+    return [
+        "default-src 'self'",
+        `script-src ${["'self'", ...scriptHashes].join(" ")}`,
+        "style-src 'self' 'unsafe-inline'",
+        "img-src 'self' blob: data:",
+        "connect-src 'self'",
+        "frame-src 'self'",
+        "object-src 'none'",
+        "base-uri 'none'",
+        "frame-ancestors 'none'",
+    ].join("; ");
+}
+/**
+ * Serves the web UI build with an SPA fallback to `index.html`. Paths are confined to the root
+ * (resolved and realpath-checked); a missing build serves {@link PLACEHOLDER_HTML}.
+ */
+export class StaticAssets {
+    root;
+    installed;
+    index;
+    csp;
+    constructor(root = defaultWebRoot()) {
+        this.root = resolve(root);
+        const indexPath = join(this.root, "index.html");
+        this.installed = existsSync(indexPath);
+        this.index = this.installed ? readFileSync(indexPath, "utf8") : PLACEHOLDER_HTML;
+        this.csp = contentSecurityPolicy(inlineScriptHashes(this.index));
+    }
+    /** Serves a GET/HEAD for a non-API path. */
+    async serve(res, pathname, head = false) {
+        const file = this.installed ? await this.resolveFile(pathname) : undefined;
+        if (!file) {
+            if (extname(pathname) && pathname !== "/index.html") {
+                res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+                res.end(head ? undefined : "Not found");
+                return;
+            }
+            this.send(res, 200, MIME[".html"], Buffer.from(this.index), "no-store", head);
+            return;
+        }
+        const bytes = await readFile(file);
+        const immutable = pathname.startsWith("/assets/");
+        this.send(res, 200, MIME[extname(file).toLowerCase()] ?? "application/octet-stream", bytes, immutable ? "public, max-age=31536000, immutable" : "no-cache", head);
+    }
+    async resolveFile(pathname) {
+        let decoded;
+        try {
+            decoded = decodeURIComponent(pathname);
+        }
+        catch {
+            return undefined;
+        }
+        if (decoded.includes("\0"))
+            return undefined;
+        const candidate = resolve(this.root, `.${decoded}`);
+        if (candidate !== this.root && !candidate.startsWith(this.root + sep))
+            return undefined;
+        try {
+            const [real, rootReal] = await Promise.all([realpath(candidate), realpath(this.root)]);
+            if (!real.startsWith(rootReal + sep))
+                return undefined;
+            return (await stat(real)).isFile() ? real : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    send(res, status, type, bytes, cache, head) {
+        res.writeHead(status, {
+            "Content-Type": type,
+            "Content-Length": bytes.length,
+            "Cache-Control": cache,
+        });
+        res.end(head ? undefined : bytes);
+    }
+}