@gatebolt/agent-redroom 0.1.1 → 0.2.0

package/dist/redroom.js

@@ -1,6 +1,6 @@
 import { randomBytes, randomInt, randomUUID } from "node:crypto";
 import {} from "./agents/agent.js";
-import { dockerCli, MAX_OUTPUT_MB, tarOf, withDefaultTimeouts, } from "./docker/cli.js";
+import { dockerCli, failureReason, keepEnd, mustSucceed, outputTooLarge, tarOf, withDefaultTimeouts, } from "./docker/cli.js";
 import { AGENT_HOST, agentArgs, CA_DIR, CA_FILE, DEFAULT_LIMITS, GIT_INIT, sessionPlan, SIDECAR_HOST, SIDECAR_IMAGE, sidecarArgs, SYSTEM_CA_DIR, SYSTEM_CA_FILE, WORKSPACE, } from "./docker/plan.js";
 import { createInternalNetwork, LEASE_MS, LEASE_RENEW_MS, networkIp, removeLeftovers, tearDownSession, } from "./docker/session.js";
 import { withDeadline } from "./deadline.js";
@@ -10,6 +10,7 @@ import { absoluteEntries, servedPages, workspaceEntries } from "./planting.js";
 import { redactDeep, redactSecrets } from "./redact.js";
 import { openRun } from "./run.js";
 import { CONFIG_ENV, PORTS } from "./sidecar/config.js";
+import { count, firstLine } from "./text.js";
 import { DETAIL_LIMIT, messageOf, RedroomError, } from "./types.js";
 export const DEFAULT_DOMAIN = "redroom.test";
 export const CONTROL_TIMEOUT_MS = 30 * 1000;
@@ -18,8 +19,10 @@ const READY_DELAY_MS = 500;
 const START_FAILED = "start_failed";
 const RUN_START_FAILED = "run_start_failed";
 const MAX_PARALLEL = 245;
+// Node timers fire at once above this.
+export const MAX_TIMEOUT_MS = 2_147_483_647;
 // Docker 28 added the isolated gateway mode; older engines ignore or reject it.
-const MIN_ENGINE_MAJOR = 28;
+export const MIN_ENGINE_MAJOR = 28;
 const DOMAIN = /^[a-z0-9-]+(\.[a-z0-9-]+)*$/;
 export const defaultDeps = () => ({
     docker: dockerCli(),
@@ -71,11 +74,29 @@ function validate(options) {
     if (!DOMAIN.test(domain)) {
         throw new RedroomError("invalid_option", `fakeDomain must be a lowercase DNS name, got ${domain}`, "redroom");
     }
-    return {
-        parallel,
-        domain,
-        limits: { ...DEFAULT_LIMITS, ...options.limits },
-    };
+    const limits = { ...DEFAULT_LIMITS, ...options.limits };
+    const { turnTimeoutMs } = limits;
+    if (!Number.isInteger(turnTimeoutMs) ||
+        turnTimeoutMs < 1 ||
+        turnTimeoutMs > MAX_TIMEOUT_MS) {
+        throw new RedroomError("invalid_option", `limits.turnTimeoutMs must be a whole number from 1 to ${MAX_TIMEOUT_MS}, got ${turnTimeoutMs}`, "redroom");
+    }
+    return { parallel, domain, limits };
+}
+export async function checkEngine(docker, redact = keepEnd) {
+    const version = await docker(["version", "--format", "{{.Server.Version}}"]);
+    const call = { command: "docker version", exitCode: version.exitCode };
+    if (version.outputTooLarge)
+        throw outputTooLarge("docker version", call);
+    if (version.exitCode !== 0) {
+        throw new RedroomError("docker_unavailable", `the Docker engine did not answer: ${redact(failureReason(version))}`, "docker", call);
+    }
+    const engine = version.stdout.trim();
+    const major = Number.parseInt(engine, 10);
+    if (Number.isNaN(major) || major < MIN_ENGINE_MAJOR) {
+        throw new RedroomError("docker_unavailable", `Docker Engine ${MIN_ENGINE_MAJOR} or newer is required to keep agents off host services, found ${engine || "no version"}`, "docker", call);
+    }
+    return engine;
 }
 export async function startRedroom(options) {
     return createRedroom(options, defaultDeps());
@@ -95,18 +116,7 @@ export async function createRedroom(options, deps) {
     const conceal = (text) => redactSecrets(text, [...hidden]);
     const redact = (text) => conceal(text).slice(-DETAIL_LIMIT);
     async function must(code, args, dockerOptions) {
-        const result = await docker(args, dockerOptions);
-        const call = {
-            command: `docker ${args.slice(0, 2).join(" ")}`,
-            exitCode: result.exitCode,
-        };
-        if (result.outputTooLarge) {
-            throw new RedroomError("output_too_large", `docker ${args[0]} wrote more than ${MAX_OUTPUT_MB} MB of output`, "docker", call);
-        }
-        if (result.exitCode !== 0) {
-            throw new RedroomError(code, `docker ${args[0]} failed (${result.exitCode}): ${redact(result.stderr.trim())}`, "docker", call);
-        }
-        return result;
+        return mustSucceed(docker, args, code, { ...dockerOptions, redact });
     }
     function fetchControl(base, path, init) {
         const timeoutError = () => new RedroomError("sidecar_timeout", `${path} did not answer within ${CONTROL_TIMEOUT_MS} ms`, "sidecar", { url: path });
@@ -115,17 +125,15 @@ export async function createRedroom(options, deps) {
             return new Response(await response.arrayBuffer(), response);
         });
     }
-    const version = await docker(["version", "--format", "{{.Server.Version}}"]);
-    if (version.exitCode !== 0) {
-        throw new RedroomError("docker_unavailable", `the Docker engine did not answer: ${redact(version.stderr.trim())}`, "docker", { command: "docker version", exitCode: version.exitCode });
-    }
-    const engine = version.stdout.trim();
-    if (Number.parseInt(engine, 10) < MIN_ENGINE_MAJOR) {
-        throw new RedroomError("docker_unavailable", `Docker Engine ${MIN_ENGINE_MAJOR} or newer is required to keep agents off host services, found ${engine}`, "docker", { command: "docker version", exitCode: version.exitCode });
+    await checkEngine(docker, redact);
+    try {
+        const leftovers = await removeLeftovers(docker, Date.now(), redact);
+        if (leftovers.containers.length + leftovers.networks.length > 0) {
+            log(`agent-redroom: removed ${count(leftovers.containers.length, "container")} and ${count(leftovers.networks.length, "network")} left by stopped sessions`);
+        }
     }
-    const leftovers = await removeLeftovers(docker);
-    if (leftovers.containers.length + leftovers.networks.length > 0) {
-        log(`agent-redroom: removed ${leftovers.containers.length} containers and ${leftovers.networks.length} networks left by stopped sessions`);
+    catch (error) {
+        log(`agent-redroom: could not remove leftovers: ${redact(firstLine(messageOf(error)))}`);
     }
     await must("image_build_failed", [
         ...["build", "-t", agent.image.tag],
@@ -141,7 +149,7 @@ export async function createRedroom(options, deps) {
         packagePath("dist", "sidecar-bundle"),
     ]);
     if (sidecarBuild.exitCode !== 0) {
-        throw new RedroomError("image_build_failed", `could not build ${SIDECAR_IMAGE}; build the package so dist/sidecar-bundle/sidecar.mjs exists (${redact(sidecarBuild.stderr.trim())})`, "docker", { command: "docker build", exitCode: sidecarBuild.exitCode });
+        throw new RedroomError("image_build_failed", `could not build ${SIDECAR_IMAGE}; build the package so dist/sidecar-bundle/sidecar.mjs exists (${redact(failureReason(sidecarBuild))})`, "docker", { command: "docker build", exitCode: sidecarBuild.exitCode });
     }
     const reported = await must("version_failed", [
         ...["run", "--rm", "--network", "none", agent.image.tag],

package/dist/run.js

@@ -112,11 +112,12 @@ export function openRun(deps, run) {
         }
         const { complete, ...parsed } = agent.parseTurn(stdout);
         if (!complete) {
-            return fail(new RedroomError("turn_failed", `${agent.name} exited with code ${result.exitCode} without a result: ${redact(result.stderr.trim()).slice(-DETAIL_LIMIT)}`, "agent", call));
+            const stderr = redact(result.stderr.trim()).slice(-DETAIL_LIMIT);
+            return fail(new RedroomError("turn_failed", `${agent.name} exited with code ${result.exitCode} without a result${stderr && `: ${stderr}`}`, "agent", call));
         }
         const turn = {
             index: turns.length,
-            message,
+            message: redact(message),
             exitCode: result.exitCode,
             ...parsed,
         };
@@ -140,8 +141,26 @@ export function openRun(deps, run) {
     async function collect() {
         let transcript = "";
         let diff = "";
+        const attempt = async (label, piece) => {
+            try {
+                await piece();
+                return true;
+            }
+            catch (error) {
+                const info = errorInfo(error, "redroom");
+                errors.push({ ...info, detail: `${label}: ${redact(info.detail)}` });
+                return false;
+            }
+        };
+        const isolated = await attempt("agent stop", stopAgent);
+        if (!isolated) {
+            errors.push({
+                by: "redroom",
+                code: "collection_incomplete",
+                detail: "could not stop and isolate the agent; final evidence collection skipped",
+            });
+        }
         const pieces = [
-            ["agent stop", stopAgent],
             [
                 "transcript",
                 async () => {
@@ -168,14 +187,9 @@ export function openRun(deps, run) {
             ["tool calls", () => drain("tool-calls")],
             ["model calls", () => drain("model-calls")],
         ];
-        for (const [label, piece] of pieces) {
-            try {
-                await piece();
-            }
-            catch (error) {
-                const info = errorInfo(error, "redroom");
-                errors.push({ ...info, detail: `${label}: ${redact(info.detail)}` });
-            }
+        if (isolated) {
+            for (const [label, piece] of pieces)
+                await attempt(label, piece);
         }
         try {
             await deps.remove();

package/dist/scenario.d.ts

@@ -0,0 +1,12 @@
+import { type ClaudeCodeOptions } from "./agents/claude-code.js";
+import { type RedroomOptions } from "./redroom.js";
+import { type RunOptions } from "./types.js";
+export declare class ScenarioError extends Error {
+}
+export type Scenario = {
+    agent: Pick<ClaudeCodeOptions, "version" | "model" | "maxTurns" | "maxBudgetUsd">;
+    turns: string[];
+    redroom: Pick<RedroomOptions, "modelProxy" | "toolCallCheck" | "limits">;
+    run: RunOptions;
+};
+export declare function parseScenario(text: string, file: string, env: NodeJS.ProcessEnv): Scenario;

package/dist/scenario.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import {} from "./agents/claude-code.js";
+import { MAX_TIMEOUT_MS } from "./redroom.js";
+import {} from "./types.js";
+export class ScenarioError extends Error {
+}
+const headerValue = z.union([
+    z.string(),
+    z.object({ env: z.string().min(1) }).strict(),
+]);
+const headers = z.record(z.string().min(1), headerValue);
+const scenarioSchema = z
+    .object({
+    agent: z
+        .object({
+        version: z.string().min(1),
+        model: z.string().min(1),
+        maxTurns: z.number().int().positive().optional(),
+        maxBudgetUsd: z.number().positive().optional(),
+    })
+        .strict(),
+    turns: z.array(z.string().min(1)).min(1),
+    turnTimeoutMs: z.number().int().positive().max(MAX_TIMEOUT_MS).optional(),
+    workspace: z
+        .record(z.union([
+        z.string(),
+        z
+            .object({ body: z.string(), executable: z.boolean().optional() })
+            .strict(),
+    ]))
+        .optional(),
+    pages: z
+        .record(z.union([
+        z.string(),
+        z
+            .object({
+            body: z.string(),
+            contentType: z.string().optional(),
+            status: z.number().int().optional(),
+        })
+            .strict(),
+    ]))
+        .optional(),
+    secrets: z.record(z.string()).optional(),
+    modelProxy: z
+        .object({ baseUrl: z.string().min(1), headers: headers.optional() })
+        .strict()
+        .optional(),
+    toolCallCheck: z
+        .object({ url: z.string().min(1), headers: headers.optional() })
+        .strict()
+        .optional(),
+})
+    .strict();
+// A union reports "Invalid input" at its own path; report the branch that got furthest instead.
+function innermostIssue(issue) {
+    if (issue.code !== "invalid_union")
+        return issue;
+    const [first = issue, ...rest] = issue.unionErrors.flatMap(({ issues: [branch] }) => (branch ? [innermostIssue(branch)] : []));
+    return rest.reduce((best, next) => (next.path.length > best.path.length ? next : best), first);
+}
+function formatPath(path) {
+    if (path.length === 0)
+        return "(root)";
+    return path
+        .map((key, i) => {
+        if (typeof key === "number")
+            return `[${key}]`;
+        if (/^[A-Za-z_$][\w$]*$/.test(key))
+            return i === 0 ? key : `.${key}`;
+        return `[${JSON.stringify(key)}]`;
+    })
+        .join("");
+}
+export function parseScenario(text, file, env) {
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new ScenarioError(`${file}: invalid JSON`);
+    }
+    const parsed = scenarioSchema.safeParse(json);
+    if (!parsed.success) {
+        const [first] = parsed.error.issues;
+        if (!first)
+            throw new ScenarioError(`${file}: invalid scenario`);
+        const issue = innermostIssue(first);
+        throw new ScenarioError(`${file}: ${formatPath(issue.path)}: ${issue.message}`);
+    }
+    const { agent, turns, turnTimeoutMs, workspace, pages, secrets, modelProxy, toolCallCheck, } = parsed.data;
+    const resolveHeaders = (headers, field) => Object.fromEntries(Object.entries(headers).map(([name, value]) => {
+        if (typeof value === "string")
+            return [name, value];
+        const found = env[value.env];
+        if (!found) {
+            const path = formatPath([field, "headers", name]);
+            throw new ScenarioError(`${file}: ${path}: environment variable ${value.env} is not set or empty`);
+        }
+        return [name, found];
+    }));
+    return {
+        agent,
+        turns,
+        redroom: {
+            ...(turnTimeoutMs !== undefined && { limits: { turnTimeoutMs } }),
+            ...(modelProxy && {
+                modelProxy: {
+                    baseUrl: modelProxy.baseUrl,
+                    ...(modelProxy.headers && {
+                        headers: resolveHeaders(modelProxy.headers, "modelProxy"),
+                    }),
+                },
+            }),
+            ...(toolCallCheck && {
+                toolCallCheck: {
+                    url: toolCallCheck.url,
+                    ...(toolCallCheck.headers && {
+                        headers: resolveHeaders(toolCallCheck.headers, "toolCallCheck"),
+                    }),
+                },
+            }),
+        },
+        run: {
+            ...(workspace && { workspace }),
+            ...(pages && { pages }),
+            ...(secrets && { secrets }),
+        },
+    };
+}

package/dist/secrets.js

@@ -16,13 +16,13 @@ function base64Fragments(value) {
     }
     return [...fragments];
 }
-function matchIn(text, lower, value) {
+function matchIn(text, lower, urlText, value) {
     if (text.includes(value))
         return "plain";
     if (lower.includes(value.toLowerCase()))
         return "case_insensitive";
     const url = encodeURIComponent(value);
-    if (url !== value && text.includes(url))
+    if (url !== value && urlText.includes(url))
         return "url";
     if (lower.includes(Buffer.from(value).toString("hex")))
         return "hex";
@@ -35,10 +35,11 @@ export function findSecrets(text, secrets) {
     if (text === "")
         return [];
     const lower = text.toLowerCase();
+    const urlText = text.replace(/%[\da-f]{2}/gi, (escape) => escape.toUpperCase());
     return Object.entries(secrets).flatMap(([secret, value]) => {
         if (value === "")
             return [];
-        const encoding = matchIn(text, lower, value);
+        const encoding = matchIn(text, lower, urlText, value);
         return encoding ? [{ secret, encoding }] : [];
     });
 }

package/dist/sidecar/dns.js

@@ -1,5 +1,6 @@
 import { createSocket } from "node:dgram";
 import { normalizeIp } from "./state.js";
+const RECEIVE_BUFFER_BYTES = 1024 * 1024;
 export const isFakeHost = (host, domain) => host === domain || host.endsWith(`.${domain}`);
 function parseQuestion(msg) {
     const labels = [];
@@ -59,10 +60,31 @@ export function answerQuery(msg, ip, context, source) {
 const subnetOf = (ip) => ip.split(".").slice(0, 3).join(".");
 export function createDns(context, ownIps) {
     const socket = createSocket("udp4");
+    socket.once("listening", () => {
+        try {
+            if (socket.getRecvBufferSize() < RECEIVE_BUFFER_BYTES) {
+                socket.setRecvBufferSize(RECEIVE_BUFFER_BYTES);
+            }
+        }
+        catch (error) {
+            socket.emit("error", error);
+        }
+    });
+    let bySubnet = new Map();
     socket.on("message", (msg, remote) => {
         const source = normalizeIp(remote.address);
-        const ips = ownIps();
-        const ip = ips.find((own) => subnetOf(own) === subnetOf(source)) ?? ips[0];
+        const subnet = subnetOf(source);
+        let ip = bySubnet.get(subnet);
+        if (ip === undefined) {
+            const ips = ownIps();
+            bySubnet = new Map();
+            for (const own of ips) {
+                const ownSubnet = subnetOf(own);
+                if (!bySubnet.has(ownSubnet))
+                    bySubnet.set(ownSubnet, own);
+            }
+            ip = bySubnet.get(subnet) ?? ips[0];
+        }
         const reply = answerQuery(msg, ip, context, source);
         if (reply)
             socket.send(reply, remote.port, remote.address);

package/dist/sidecar/fake-web.d.ts

@@ -10,6 +10,7 @@ export type FakeWebContext = {
     state: SidecarState;
     domain: string;
     trustTestSourceHeader: boolean;
+    requestTimeoutMs: number;
 };
 export declare function createFakeHttps(context: FakeWebContext, tls: Tls): Server;
 export declare function createFakeHttp(context: FakeWebContext): Server;

package/dist/sidecar/fake-web.js

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { promisify } from "node:util";
 import {} from "../types.js";
 import { isFakeHost } from "./dns.js";
+import { BodyBuffer, sendJson } from "./http.js";
 import { headersOf, SCAN_LIMIT, sourceIp } from "./state.js";
 const run = promisify(execFile);
 const HIT_BODY_LIMIT = 64 * 1024;
@@ -32,25 +33,26 @@ export async function generateTls(domain) {
 }
 function fakeWeb(context, protocol) {
     return (req, res) => {
-        const chunks = [];
+        const host = (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
+        if (!isFakeHost(host, context.domain)) {
+            res.writeHead(404, { Connection: "close" }).end();
+            return;
+        }
+        const source = sourceIp(req, context.trustTestSourceHeader);
+        const target = req.url ?? "/";
+        const url = URL.parse(target, "http://fake-web");
+        const method = req.method ?? "GET";
+        const path = url ? url.pathname + url.search : target;
+        const lease = context.state.requests.take(source);
+        const buffered = new BodyBuffer(SCAN_LIMIT, (bytes) => lease?.reserve(bytes) ?? false);
         let size = 0;
-        req.on("data", (chunk) => {
-            if (size < SCAN_LIMIT)
-                chunks.push(chunk);
-            size += chunk.length;
-        });
-        req.on("end", () => {
-            const host = (req.headers.host ?? "").replace(/:\d+$/, "").toLowerCase();
-            if (!isFakeHost(host, context.domain)) {
-                res.writeHead(404).end();
+        let recorded = false;
+        const record = (error, extra) => {
+            if (recorded)
                 return;
-            }
-            const target = req.url ?? "/";
-            const url = URL.parse(target, "http://fake-web");
-            const source = sourceIp(req, context.trustTestSourceHeader);
-            const method = req.method ?? "GET";
-            const path = url ? url.pathname + url.search : target;
-            const body = Buffer.concat(chunks);
+            recorded = true;
+            clearTimeout(timer);
+            const body = buffered.finish(extra);
             context.state.recordHit(source, {
                 protocol,
                 host,
@@ -59,7 +61,58 @@ function fakeWeb(context, protocol) {
                 headers: headersOf(req),
                 body: body.subarray(0, HIT_BODY_LIMIT).toString("utf8"),
                 truncated: size > HIT_BODY_LIMIT,
+                ...(error ? { error } : {}),
             }, body.toString("utf8"));
+        };
+        const refuse = (status, code, detail, extra) => {
+            record({ by: "sidecar", code, detail }, extra);
+            req.pause();
+            sendJson(res, status, { error: detail }, { Connection: "close" });
+        };
+        const timer = setTimeout(() => refuse(408, "request_timeout", "request body timed out"), context.requestTimeoutMs);
+        timer.unref();
+        res.once("finish", () => lease?.release());
+        res.once("close", () => {
+            record({
+                by: "sidecar",
+                code: "request_aborted",
+                detail: "request closed before its body ended",
+            });
+            lease?.release();
+        });
+        req.once("aborted", () => {
+            record({
+                by: "sidecar",
+                code: "request_aborted",
+                detail: "request body aborted",
+            });
+            res.destroy();
+        });
+        req.once("error", () => {
+            record({
+                by: "sidecar",
+                code: "request_aborted",
+                detail: "request body failed",
+            });
+            res.destroy();
+        });
+        if (!lease) {
+            refuse(429, "request_limit", "too many in-flight requests");
+            return;
+        }
+        req.on("data", (chunk) => {
+            if (recorded)
+                return;
+            size += chunk.length;
+            if (!buffered.append(chunk)) {
+                refuse(429, "buffer_limit", "too many buffered request bytes", chunk);
+                return;
+            }
+        });
+        req.on("end", () => {
+            if (recorded)
+                return;
+            record();
             if (!url) {
                 res.writeHead(400, { "Content-Type": "text/plain" }).end("bad request");
                 return;

package/dist/sidecar/http.d.ts

@@ -1,7 +1,36 @@
 import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
 export declare const BODY_LIMIT_BYTES: number;
+export declare const REQUEST_TIMEOUT_MS = 30000;
+export type RequestLimits = {
+    requests: number;
+    requestsPerSource: number;
+    bytes: number;
+    bytesPerSource: number;
+};
+export type RequestLease = {
+    reserve(bytes: number): boolean;
+    release(): void;
+};
+export declare class RequestBudget {
+    private readonly limits;
+    private readonly sources;
+    private requests;
+    private bytes;
+    constructor(limits?: Partial<RequestLimits>);
+    take(source: string): RequestLease | undefined;
+}
 export declare class BodyTooLargeError extends Error {
 }
+export declare class BodyBuffer {
+    private readonly limit;
+    private readonly reserve;
+    private blocks;
+    private size;
+    private capacity;
+    constructor(limit: number, reserve?: (bytes: number) => boolean);
+    append(chunk: Uint8Array): boolean;
+    finish(extra?: Uint8Array): Buffer;
+}
 export declare function readBody(body: AsyncIterable<Uint8Array>, limit?: number): Promise<Buffer>;
 export declare function readJson(req: IncomingMessage): Promise<unknown>;
 export declare function sendJson(res: ServerResponse, status: number, body: unknown, headers?: Record<string, string>): void;

package/dist/sidecar/http.js

@@ -1,18 +1,120 @@
 import { timingSafeEqual } from "node:crypto";
 import { createServer, } from "node:http";
 export const BODY_LIMIT_BYTES = 1024 * 1024;
+export const REQUEST_TIMEOUT_MS = 30_000;
+export class RequestBudget {
+    limits;
+    sources = new Map();
+    requests = 0;
+    bytes = 0;
+    constructor(limits = {}) {
+        this.limits = {
+            requests: 2048,
+            requestsPerSource: 8,
+            bytes: 512 * 1024 * 1024,
+            bytesPerSource: 32 * 1024 * 1024,
+            ...limits,
+        };
+    }
+    take(source) {
+        const usage = this.sources.get(source) ?? { requests: 0, bytes: 0 };
+        if (this.requests >= this.limits.requests ||
+            usage.requests >= this.limits.requestsPerSource)
+            return undefined;
+        this.sources.set(source, usage);
+        this.requests += 1;
+        usage.requests += 1;
+        let bytes = 0;
+        let released = false;
+        return {
+            reserve: (size) => {
+                if (released ||
+                    this.bytes + size > this.limits.bytes ||
+                    usage.bytes + size > this.limits.bytesPerSource)
+                    return false;
+                this.bytes += size;
+                usage.bytes += size;
+                bytes += size;
+                return true;
+            },
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.requests -= 1;
+                usage.requests -= 1;
+                this.bytes -= bytes;
+                usage.bytes -= bytes;
+                if (usage.requests === 0)
+                    this.sources.delete(source);
+            },
+        };
+    }
+}
 export class BodyTooLargeError extends Error {
 }
+const BODY_BLOCK_BYTES = 64 * 1024;
+export class BodyBuffer {
+    limit;
+    reserve;
+    blocks = [];
+    size = 0;
+    capacity = 0;
+    constructor(limit, reserve = () => true) {
+        this.limit = limit;
+        this.reserve = reserve;
+    }
+    append(chunk) {
+        const length = Math.min(chunk.length, this.limit - this.size);
+        if (length === 0)
+            return true;
+        const end = this.size + length;
+        const capacity = Math.min(this.limit, Math.ceil(end / BODY_BLOCK_BYTES) * BODY_BLOCK_BYTES);
+        const needed = capacity - this.capacity;
+        if (needed > 0 && !this.reserve(needed))
+            return false;
+        while (this.capacity < capacity) {
+            const block = Buffer.alloc(Math.min(BODY_BLOCK_BYTES, this.limit - this.capacity));
+            this.blocks.push(block);
+            this.capacity += block.length;
+        }
+        let offset = 0;
+        while (offset < length) {
+            const block = this.blocks[Math.floor(this.size / BODY_BLOCK_BYTES)];
+            const at = this.size % BODY_BLOCK_BYTES;
+            const copied = Math.min(length - offset, block.length - at);
+            block.set(chunk.subarray(offset, offset + copied), at);
+            offset += copied;
+            this.size += copied;
+        }
+        return true;
+    }
+    finish(extra) {
+        const blocks = this.blocks;
+        const size = this.size;
+        this.blocks = [];
+        this.size = 0;
+        this.capacity = 0;
+        const last = blocks.at(-1);
+        if (last && size % BODY_BLOCK_BYTES !== 0) {
+            blocks[blocks.length - 1] = last.subarray(0, size % BODY_BLOCK_BYTES);
+        }
+        const extraLength = Math.min(extra?.length ?? 0, this.limit - size);
+        if (extra && extraLength > 0)
+            blocks.push(extra.subarray(0, extraLength));
+        return Buffer.concat(blocks, size + extraLength);
+    }
+}
 export async function readBody(body, limit = BODY_LIMIT_BYTES) {
-    const chunks = [];
+    const buffered = new BodyBuffer(limit);
     let size = 0;
     for await (const chunk of body) {
         size += chunk.length;
         if (size > limit)
             throw new BodyTooLargeError("body too large");
-        chunks.push(chunk);
+        buffered.append(chunk);
     }
-    return Buffer.concat(chunks);
+    return buffered.finish();
 }
 export async function readJson(req) {
     return JSON.parse((await readBody(req)).toString("utf8"));