co-maintainer 0.4.0-beta.1

package/dist/src/pr/scope.js

@@ -0,0 +1,84 @@
+import { ensureCloneUnlocked, ensureCommit, runCommand, withCloneLock, } from "./checkout.js";
+import { detectDefaultBranchRef } from "../git/default_branch.js";
+import { log } from "../util/log.js";
+function lines(output) {
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+/** The scope algorithm against a clone that is already on disk. Split out from
+ * `computeScope` so a caller that already manages its own clone — the
+ * benchmark's OCR runner has its own, separate from co-maintainer's — can run
+ * the identical algorithm without a second clone of the same repository. */
+export async function scopeInClone(clone, base, head, run = runCommand, remote = "origin") {
+    let baseSha;
+    let headSha;
+    try {
+        baseSha = await ensureCommit(clone, base, run);
+        headSha = await ensureCommit(clone, head, run);
+    }
+    catch (error) {
+        log("scope", `unavailable · ${String(error)}`);
+        return undefined;
+    }
+    const defaultBranch = await detectDefaultBranchRef(clone, remote, run);
+    if (!defaultBranch) {
+        log("scope", "unavailable · could not determine the default branch");
+        return undefined;
+    }
+    // Mirrors GitHub's three-dot compare: the round started at the point where
+    // the PR's branch diverged, not at whatever `base` happens to be today.
+    const mergeBase = await run("git", ["merge-base", baseSha, headSha], clone);
+    const boundary = mergeBase.code === 0 ? mergeBase.stdout.trim() : baseSha;
+    const range = [`${boundary}..${headSha}`, "--not", defaultBranch];
+    const [ownCommits, mergeCommits, allFiles] = await Promise.all([
+        run("git", ["rev-list", "--no-merges", ...range], clone),
+        run("git", ["rev-list", "--merges", ...range], clone),
+        run("git", ["diff", "--name-only", `${boundary}..${headSha}`], clone),
+    ]);
+    if (ownCommits.code !== 0 || mergeCommits.code !== 0 || allFiles.code !== 0) {
+        log("scope", "unavailable · git failed to list the round's commits");
+        return undefined;
+    }
+    const ownFiles = new Set();
+    for (const sha of lines(ownCommits.stdout)) {
+        const shown = await run("git", ["show", "--name-only", "--format=", sha], clone);
+        for (const path of lines(shown.stdout))
+            ownFiles.add(path);
+    }
+    for (const sha of lines(mergeCommits.stdout)) {
+        const resolved = await run("git", ["diff-tree", "--cc", "-r", "--no-commit-id", "--name-only", sha], clone);
+        for (const path of lines(resolved.stdout))
+            ownFiles.add(path);
+    }
+    const upstreamFiles = new Set(lines(allFiles.stdout).filter((path) => !ownFiles.has(path)));
+    log("scope", `${ownFiles.size} own files · ${upstreamFiles.size} upstream files · ` +
+        `${lines(ownCommits.stdout).length} commits · ${lines(mergeCommits.stdout).length} merges · default=${defaultBranch}`);
+    return {
+        ownFiles,
+        upstreamFiles,
+        defaultBranch,
+        ownCommits: lines(ownCommits.stdout).length,
+        mergeCommits: lines(mergeCommits.stdout).length,
+    };
+}
+/** Clones (or reuses) `repo` under co-maintainer's own cache and runs the
+ * scope algorithm against it. Returns `undefined` on any failure — no clone,
+ * an unresolvable commit, no default branch to compare against — so the
+ * caller's fallback is always "review everything, unscoped", never a broken
+ * review. */
+export async function computeScope(repo, base, head, options = {}) {
+    const run = options.run ?? runCommand;
+    return withCloneLock(repo, async () => {
+        let clone;
+        try {
+            clone = await ensureCloneUnlocked(repo, run);
+        }
+        catch (error) {
+            log("scope", `unavailable · ${String(error)}`);
+            return undefined;
+        }
+        return await scopeInClone(clone, base, head, run);
+    });
+}

package/dist/src/pr/snapshot.d.ts

@@ -0,0 +1,11 @@
+/** Pins a review to a historical diff/discussion state instead of the PR's
+ * current (latest) state — used by the benchmarks to show the model exactly
+ * what a human reviewer saw, without leaking later comments as hints.
+ * `base` defaults to the PR's merge-base with its base branch (the whole PR
+ * so far); pass an earlier review round's commit as `base` to show only the
+ * incremental diff a re-reviewer would see since that round (P11). */
+export type Snapshot = {
+    base?: string;
+    commit: string;
+    before: string;
+};

package/dist/src/pr/snapshot.js

@@ -0,0 +1 @@
+export {};

package/dist/src/pr/suggestion.d.ts

@@ -0,0 +1,17 @@
+import type { ParsedFinding, Span } from "./findings.ts";
+import { type Anchor } from "./hunks.ts";
+export type Suggestion = Span & {
+    code: string;
+};
+/** The one suggestion a finding carries, or undefined when there is none or
+ * the model wrote more than one. */
+export declare function readSuggestion(body: string): Suggestion | undefined;
+export declare function withoutSuggestionLine(body: string): string;
+export declare function stripSuggestion(body: string): string;
+/** Replies explain a fix in a normal code block. A suggestion there would
+ * anchor to whatever lines the thread sits on, which may have moved. */
+export declare function plainSuggestionFences(text: string): string;
+/** The anchor for a suggestion GitHub can apply as written: same file,
+ * inside the finding's span, one hunk holding the whole range, and an actual
+ * change to those lines. */
+export declare function suggestionAnchor(finding: ParsedFinding, patch: string | undefined): Anchor | undefined;

package/dist/src/pr/suggestion.js

@@ -0,0 +1,70 @@
+import { anchorFor, rightLines } from "./hunks.js";
+const LINE = /^[ \t]*Suggestion:[ \t]*`?(?<path>[^`\s]+?):(?<from>\d+)(?:-(?<to>\d+))?`?[ \t]*\r?$/gm;
+const BLOCK = /^(?<fence>`{3,})suggestion[ \t]*\r?\n(?<code>[\s\S]*?)^\k<fence>[ \t]*\r?$/gm;
+const OPENING_FENCE = /^(`{3,})suggestion\b/gm;
+/** The one suggestion a finding carries, or undefined when there is none or
+ * the model wrote more than one. */
+export function readSuggestion(body) {
+    const lines = [...body.matchAll(LINE)];
+    const blocks = [...body.matchAll(BLOCK)];
+    if (lines.length !== 1 || blocks.length !== 1)
+        return undefined;
+    const { path, from, to } = lines[0].groups;
+    return {
+        path,
+        from: Number(from),
+        to: Number(to ?? from),
+        code: blocks[0].groups.code.replace(/\r?\n$/, ""),
+    };
+}
+export function withoutSuggestionLine(body) {
+    return body
+        .replace(LINE, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function stripSuggestion(body) {
+    return withoutSuggestionLine(body.replace(BLOCK, ""));
+}
+/** Replies explain a fix in a normal code block. A suggestion there would
+ * anchor to whatever lines the thread sits on, which may have moved. */
+export function plainSuggestionFences(text) {
+    return text.replace(OPENING_FENCE, "$1");
+}
+function sameCode(a, b) {
+    const clean = (value) => value
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n");
+    return clean(a) === clean(b);
+}
+/** The anchor for a suggestion GitHub can apply as written: same file,
+ * inside the finding's span, one hunk holding the whole range, and an actual
+ * change to those lines. */
+export function suggestionAnchor(finding, patch) {
+    const suggestion = readSuggestion(finding.excerpt);
+    if (!suggestion || !patch || suggestion.path !== finding.path) {
+        return undefined;
+    }
+    const { from, to } = suggestion;
+    const low = Math.min(finding.from, finding.to);
+    const high = Math.max(finding.from, finding.to);
+    if (from > to || from < low || to > high)
+        return undefined;
+    const anchor = anchorFor(patch, from, to);
+    const whole = anchor?.line === to &&
+        anchor.start_line === (from === to ? undefined : from);
+    if (!whole)
+        return undefined;
+    const lines = rightLines(patch);
+    const original = [];
+    for (let line = from; line <= to; line++) {
+        const text = lines.get(line);
+        if (text === undefined)
+            return undefined;
+        original.push(text);
+    }
+    if (sameCode(original.join("\n"), suggestion.code))
+        return undefined;
+    return anchor;
+}

package/dist/src/remote/client.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewCliArgs } from "../cli/review_args.ts";
+export declare function runRemoteReview(cli: ReviewCliArgs & {
+    mode: "remote";
+}): Promise<void>;

package/dist/src/remote/client.js

@@ -0,0 +1,199 @@
+import { VERSION } from "../version.js";
+import { printLocalReview } from "../cli/review_output.js";
+import { formatHumanJsonFindings, reviewExitCodeFromJsonFindings, } from "../cli/review_result.js";
+import { readConfig, writeUserConfig } from "../config.js";
+import { prepareLocalCodegraph } from "../local/codegraph_prepare.js";
+import { runRemoteToolCalls, toolHandlerMap, } from "./client_tools.js";
+import { REMOTE_KNOWN_TOOL_NAMES } from "./schema.js";
+import { runCommand } from "../pr/checkout.js";
+import { assertGitQuiet, currentBranch, detectRemoteRepo, gitRoot, ReviewCliError, } from "../local/git_ops.js";
+import { buildLocalRevision, mergeBase, resolveBaseRef, } from "../local/git_revision.js";
+import { withCliLogsToStderr } from "../util/log.js";
+import { setCliInteractive } from "../cli/args.js";
+import { MIN_SERVER_SCHEMA, REMOTE_CLI_UPGRADE_COMMAND, REMOTE_SCHEMA_VERSION, } from "./schema.js";
+function die(code, message, hint, exitCode = 2) {
+    throw new ReviewCliError(code, message, hint, exitCode);
+}
+function baseUrl(host) {
+    const trimmed = host.trim().replace(/\/+$/, "");
+    if (!/^https?:\/\//i.test(trimmed)) {
+        die("remote_not_configured", "remoteHost must be an absolute http(s) URL.", "co-maintainer set --remote-host=https://your-server");
+    }
+    return trimmed;
+}
+async function remoteFetch(host, token, path, init) {
+    const url = `${baseUrl(host)}${path}`;
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    return await fetch(url, { ...init, headers });
+}
+async function readApiError(response) {
+    try {
+        const body = await response.json();
+        return String(body.error?.message ?? response.statusText);
+    }
+    catch {
+        return response.statusText;
+    }
+}
+export async function runRemoteReview(cli) {
+    const config = readConfig();
+    const host = config.remoteHost;
+    const token = config.remoteToken;
+    if (!host || !token) {
+        die("remote_not_configured", "Remote review is not configured.", "co-maintainer set --remote-host=... --remote-token=...");
+    }
+    setCliInteractive(!cli.json);
+    await withCliLogsToStderr(async () => {
+        const root = await gitRoot(process.cwd());
+        await assertGitQuiet(root);
+        const repo = await detectRemoteRepo(root, cli.repoOverride);
+        const branch = await currentBranch(root, cli.branch);
+        const remotes = await runCommand("git", ["remote"], root);
+        const remoteName = ["upstream", "origin"].find((n) => remotes.stdout
+            .split("\n")
+            .map((l) => l.trim())
+            .includes(n)) ??
+            remotes.stdout
+                .split("\n")
+                .map((l) => l.trim())
+                .filter(Boolean)[0];
+        const base = await resolveBaseRef(root, remoteName, cli.toBranch, runCommand);
+        const baseSha = await mergeBase(root, base.ref, remoteName, runCommand);
+        const built = await buildLocalRevision(root, baseSha, base.label, runCommand);
+        if (built.revision.files.length === 0) {
+            if (cli.json) {
+                console.log(JSON.stringify({
+                    schemaVersion: 1,
+                    ok: true,
+                    mode: "remote",
+                    message: "No changes to review.",
+                }));
+            }
+            else {
+                console.log("No changes to review.");
+            }
+            process.exit(0);
+        }
+        const handshake = await remoteFetch(host, token, "/api/remote/handshake", {
+            method: "POST",
+            body: JSON.stringify({
+                schemaVersion: REMOTE_SCHEMA_VERSION,
+                clientVersion: VERSION,
+                repo,
+            }),
+        });
+        if (!handshake.ok) {
+            die("remote_handshake_failed", await readApiError(handshake));
+        }
+        const hs = (await handshake.json());
+        if (REMOTE_SCHEMA_VERSION < hs.minClientSchema) {
+            die("upgrade_required", "This co-maintainer CLI is too old for the server.", REMOTE_CLI_UPGRADE_COMMAND, 4);
+        }
+        if (hs.schemaVersion < MIN_SERVER_SCHEMA) {
+            die("server_too_old", "The dashboard server is too old for this CLI.", undefined, 4);
+        }
+        const hostKey = baseUrl(host);
+        const shown = config.remoteNoticeShownFor ?? [];
+        if (!shown.includes(hostKey) && !cli.json) {
+            console.error("Remote review sends your unpublished diff to the server you configured. " +
+                "Use a host you trust.");
+            await writeUserConfig({
+                remoteNoticeShownFor: [...shown, hostKey],
+            });
+        }
+        const codegraphPrep = await prepareLocalCodegraph({
+            gitRoot: root,
+            enabled: !cli.disableCodegraph,
+            allowInstall: cli.allowToolInstall,
+            interactive: !cli.json,
+        });
+        const localTools = toolHandlerMap(codegraphPrep.tools);
+        const capabilityTools = [...localTools.keys()]
+            .filter((name) => REMOTE_KNOWN_TOOL_NAMES.has(name))
+            .map((name) => ({ name }));
+        const requestId = crypto.randomUUID();
+        const submitBody = {
+            schemaVersion: REMOTE_SCHEMA_VERSION,
+            requestId,
+            repo: hs.repo.fullName,
+            branch,
+            toBranch: cli.toBranch ?? hs.repo.defaultBranch ?? undefined,
+            fresh: cli.fresh,
+            revision: {
+                title: built.revision.title,
+                description: built.revision.description,
+                baseLabel: built.revision.baseLabel,
+                files: built.revision.files,
+            },
+            capabilities: { tools: capabilityTools },
+        };
+        const serialized = JSON.stringify(submitBody);
+        if (serialized.length > hs.limits.maxBodyBytes) {
+            die("payload_too_large", "Diff is too large for the remote server limit.");
+        }
+        const submit = await remoteFetch(host, token, "/api/remote/reviews", {
+            method: "POST",
+            body: serialized,
+        });
+        if (submit.status !== 202) {
+            die("remote_submit_failed", await readApiError(submit));
+        }
+        const { jobId } = (await submit.json());
+        let afterLogSeq = 0;
+        let toolResults = [];
+        const intervalMs = hs.sync.intervalSeconds * 1000;
+        while (true) {
+            const sync = await remoteFetch(host, token, `/api/remote/reviews/${jobId}/sync`, {
+                method: "POST",
+                body: JSON.stringify({
+                    schemaVersion: REMOTE_SCHEMA_VERSION,
+                    afterLogSeq,
+                    toolResults,
+                }),
+            });
+            toolResults = [];
+            if (!sync.ok) {
+                die("remote_sync_failed", await readApiError(sync));
+            }
+            const payload = (await sync.json());
+            for (const line of payload.logs ?? []) {
+                afterLogSeq = Math.max(afterLogSeq, line.seq);
+                if (!cli.json)
+                    console.error(line.message);
+            }
+            if (payload.toolCalls?.length) {
+                toolResults = await runRemoteToolCalls(payload.toolCalls, localTools);
+                continue;
+            }
+            if (payload.status === "done" && payload.result) {
+                if (cli.json) {
+                    console.log(JSON.stringify({
+                        schemaVersion: 1,
+                        ok: true,
+                        mode: "remote",
+                        ...payload.result,
+                    }));
+                }
+                else {
+                    const findings = (payload.result.findings ??
+                        []);
+                    const summary = payload.result.summary;
+                    const summaryLine = summary
+                        ? `${summary.new ?? 0} new · ${summary.open ?? 0} open · ${summary.closed ?? 0} closed · ${summary.blocking ?? 0} blocking`
+                        : "";
+                    printLocalReview(`co-maintainer review · ${repo} · ${branch} (remote)\n${summaryLine}`, formatHumanJsonFindings(findings));
+                }
+                const findings = (payload.result.findings ?? []);
+                process.exit(reviewExitCodeFromJsonFindings(findings));
+            }
+            if (payload.status === "failed" || payload.status === "canceled") {
+                die(payload.abort?.reason ?? "remote_failed", payload.abort?.message ?? "Remote review did not complete.");
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    });
+}

package/dist/src/remote/client_tools.d.ts

@@ -0,0 +1,13 @@
+import type { ToolHandler } from "../ai/mermaid_loop.ts";
+export type RemoteToolCall = {
+    callId: string;
+    name: string;
+    arguments: Record<string, unknown>;
+};
+export type RemoteToolResult = {
+    callId: string;
+    output?: string;
+    error?: string;
+};
+export declare function toolHandlerMap(handlers: ToolHandler[]): Map<string, ToolHandler>;
+export declare function runRemoteToolCalls(calls: RemoteToolCall[], handlers: Map<string, ToolHandler>): Promise<RemoteToolResult[]>;

package/dist/src/remote/client_tools.js

@@ -0,0 +1,30 @@
+export function toolHandlerMap(handlers) {
+    return new Map(handlers.map((handler) => [handler.name, handler]));
+}
+export async function runRemoteToolCalls(calls, handlers) {
+    const results = [];
+    for (const call of calls) {
+        const handler = handlers.get(call.name);
+        if (!handler) {
+            results.push({
+                callId: call.callId,
+                error: `unknown tool: ${call.name}`,
+            });
+            continue;
+        }
+        try {
+            const output = await handler.run(call.arguments);
+            results.push({
+                callId: call.callId,
+                output: typeof output === "string" ? output : String(output),
+            });
+        }
+        catch (error) {
+            results.push({
+                callId: call.callId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}

package/dist/src/remote/fixtures.d.ts

@@ -0,0 +1 @@
+export declare function hashRemoteFixtures(version: number): Promise<string>;

package/dist/src/remote/fixtures.js

@@ -0,0 +1,30 @@
+/** Fixture directory hashing for plan §15.3. */
+import { readDir, readFile } from "../util/runtime.js";
+export async function hashRemoteFixtures(version) {
+    const dir = new URL(`./fixtures/v${version}/`, import.meta.url);
+    const names = [];
+    for await (const entry of readDir(dir)) {
+        if (entry.isFile && entry.name.endsWith(".json")) {
+            names.push(entry.name);
+        }
+    }
+    names.sort();
+    const chunks = [];
+    const enc = new TextEncoder();
+    for (const name of names) {
+        chunks.push(enc.encode(`${name}\n`));
+        chunks.push(await readFile(new URL(name, dir)));
+        chunks.push(enc.encode("\n"));
+    }
+    const total = chunks.reduce((n, c) => n + c.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+    }
+    const digest = await crypto.subtle.digest("SHA-256", merged);
+    return [...new Uint8Array(digest)]
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}

package/dist/src/remote/revision_from_submit.d.ts

@@ -0,0 +1,2 @@
+import type { Revision } from "../review/revision.ts";
+export declare function revisionFromSubmitJson(raw: unknown): Revision;

package/dist/src/remote/revision_from_submit.js

@@ -0,0 +1,26 @@
+import { validateRevisionPayload } from "./validate.js";
+export function revisionFromSubmitJson(raw) {
+    const err = validateRevisionPayload(raw);
+    if (err)
+        throw new Error(err);
+    const record = raw;
+    const files = record.files.map((file) => {
+        const f = file;
+        return {
+            path: f.path,
+            previousPath: f.previousPath == null ? null : f.previousPath,
+            status: f.status,
+            binary: f.binary,
+            additions: f.additions,
+            deletions: f.deletions,
+            patch: f.patch,
+        };
+    });
+    return {
+        files,
+        title: typeof record.title === "string" ? record.title : "",
+        description: typeof record.description === "string" ? record.description : "",
+        baseLabel: typeof record.baseLabel === "string" ? record.baseLabel : "",
+        producer: "remote",
+    };
+}

package/dist/src/remote/schema.d.ts

@@ -0,0 +1,14 @@
+/** Remote review wire protocol — plan §15.1–15.2. */
+export declare const REMOTE_SCHEMA_VERSION = 1;
+export declare const MIN_CLIENT_SCHEMA = 1;
+export declare const MIN_SERVER_SCHEMA = 1;
+/** README install line for 426 responses (plan §14.4). */
+export declare const REMOTE_CLI_UPGRADE_COMMAND = "npm install -g co-maintainer@latest";
+export declare const REMOTE_MAX_BODY_BYTES = 52428800;
+export declare const REMOTE_SYNC_INTERVAL_SECONDS = 3;
+/** SHA-256 of sorted `fixtures/v<N>/*.json` (name + contents); bump with schema version. */
+export declare const REMOTE_FIXTURE_HASH: Record<number, string>;
+export declare const REMOTE_SYNC_STATUSES: readonly ["queued", "running", "done", "failed", "canceled"];
+export type RemoteSyncStatus = (typeof REMOTE_SYNC_STATUSES)[number];
+/** Tool names the server may invoke via the bridge (plan §13.6, §14.5). */
+export declare const REMOTE_KNOWN_TOOL_NAMES: Set<string>;

package/dist/src/remote/schema.js

@@ -0,0 +1,30 @@
+/** Remote review wire protocol — plan §15.1–15.2. */
+export const REMOTE_SCHEMA_VERSION = 1;
+export const MIN_CLIENT_SCHEMA = 1;
+export const MIN_SERVER_SCHEMA = 1;
+/** README install line for 426 responses (plan §14.4). */
+export const REMOTE_CLI_UPGRADE_COMMAND = "npm install -g co-maintainer@latest";
+export const REMOTE_MAX_BODY_BYTES = 52_428_800;
+export const REMOTE_SYNC_INTERVAL_SECONDS = 3;
+/** SHA-256 of sorted `fixtures/v<N>/*.json` (name + contents); bump with schema version. */
+export const REMOTE_FIXTURE_HASH = {
+    1: "1cbb11016227fcc7fc58b692ed5a2b72dc9b0e23b4cf68858e2d7facc98efd79",
+};
+export const REMOTE_SYNC_STATUSES = [
+    "queued",
+    "running",
+    "done",
+    "failed",
+    "canceled",
+];
+/** Tool names the server may invoke via the bridge (plan §13.6, §14.5). */
+export const REMOTE_KNOWN_TOOL_NAMES = new Set([
+    "codegraph-query",
+    "codegraph-node",
+    "codegraph-explore",
+    "codegraph-callers",
+    "codegraph-callees",
+    "codegraph-impact",
+    "codegraph-affected",
+    "read-full-diff",
+]);

package/dist/src/remote/server/body.d.ts

@@ -0,0 +1,18 @@
+/** Bounded request body read — plan §14.5 / G6 (bytes, streaming). */
+export type BoundedBodyResult = {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    reason: "too_large" | "empty";
+};
+export declare function readBoundedUtf8(request: Request, maxBytes: number): Promise<BoundedBodyResult>;
+export declare function readBoundedJson(request: Request, maxBytes: number): Promise<{
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    status: number;
+    code: string;
+    message: string;
+}>;

package/dist/src/remote/server/body.js

@@ -0,0 +1,73 @@
+/** Bounded request body read — plan §14.5 / G6 (bytes, streaming). */
+export async function readBoundedUtf8(request, maxBytes) {
+    const lengthHeader = request.headers.get("content-length");
+    if (lengthHeader !== null) {
+        const declared = Number(lengthHeader);
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            return { ok: false, reason: "too_large" };
+        }
+    }
+    const stream = request.body;
+    if (!stream)
+        return { ok: true, text: "" };
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value?.length)
+                continue;
+            total += value.length;
+            if (total > maxBytes) {
+                await reader.cancel();
+                return { ok: false, reason: "too_large" };
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (total === 0)
+        return { ok: true, text: "" };
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return { ok: true, text: new TextDecoder().decode(merged) };
+}
+export async function readBoundedJson(request, maxBytes) {
+    const body = await readBoundedUtf8(request, maxBytes);
+    if (!body.ok) {
+        return {
+            ok: false,
+            status: 413,
+            code: "payload_too_large",
+            message: "request body too large",
+        };
+    }
+    if (!body.text.trim()) {
+        return {
+            ok: false,
+            status: 400,
+            code: "bad_request",
+            message: "expected a JSON body",
+        };
+    }
+    try {
+        return { ok: true, value: JSON.parse(body.text) };
+    }
+    catch {
+        return {
+            ok: false,
+            status: 400,
+            code: "bad_request",
+            message: "expected a JSON body",
+        };
+    }
+}

package/dist/src/remote/server/routes.d.ts

@@ -0,0 +1 @@
+export declare function handleRemoteRoute(request: Request, url: URL, remoteAddr: string): Promise<Response>;