@emseepea/server 0.0.1 → 0.0.3

package/README.md

@@ -5,8 +5,9 @@ Protocol (MCP) `2026-07-28` servers over Streamable HTTP.
 
 It checks data when requests enter and leave the server. It supports public
 tools, tools that require sign-in, public resources and prompts, request time
-limits, and bounded progress updates for local examples. Prompt arguments and
-resource fields may also offer suggestions.
+limits, and bounded progress updates. Direct tools,
+resources, and prompts can ask capable clients for more information. Prompt
+arguments and resource fields may also offer suggestions.
 
 The package is pre-alpha. See the
 [repository README](https://github.com/windyroad/emseepea#readme) for what the
@@ -50,6 +51,221 @@ const app = createEmseepea({ name: "coffee-guide", version: "1.0.0", tools: [get
 await serveEmseepea(app);
 ```
 
+## Measure Requests
+
+Available in this checkout; not yet published to npm.
+
+Set `telemetry: true` in `createEmseepea` to record request traces, counts, and
+response times through OpenTelemetry. Leave it out to disable these measurements.
+
+Configure your OpenTelemetry providers and context manager before creating the
+app. Em See Pea does not choose an exporter or send data to a service.
+
+### What Gets Measured
+
+Each trace covers one `/mcp` request through response completion or
+disconnection, including progress updates. Measurements report:
+
+- the HTTP method and status
+- the known MCP method, or `_OTHER` for unknown names
+- whether the response finished or disconnected
+
+An HTTP 200 response can still contain a tool error. These measurements describe
+the response, not whether the tool achieved its task.
+
+### What Stays Out
+
+The framework does not attach tool names, request data, tokens, URLs, or error
+messages. It preserves a valid active parent trace identity, but drops baggage
+and other context data. It does not read trace headers itself.
+
+### Current Limits
+
+SDK host and origin rejections happen before this measurement starts.
+Ordinary telemetry API and exporter failures do not change tool results.
+An adopter exporter that blocks the process or throws outside the telemetry
+call is not isolated.
+
+Structured logs are not included yet.
+
+## Report Dependency Readiness
+
+Available in this checkout; not yet published to npm.
+
+Pass a `readiness` callback to `createEmseepea` to check the dependencies your
+server needs. The callback receives `{ signal }` and must return `true` only
+when those dependencies are ready. It may return a promise.
+
+`GET /readyz` returns:
+
+- HTTP 200 and `ready` when the check succeeds
+- HTTP 503 and `not ready` when it fails, throws, or takes too long
+
+The reply never includes dependency details or error messages. It is not cached.
+`GET /healthz` continues to report that the process is alive, not that its
+dependencies work. Without a callback, readiness does not check dependencies.
+
+Set `readinessTimeoutMs` to limit the check. It defaults to 1,000 milliseconds
+and accepts whole numbers from 1 to 60,000. A timeout or shutdown signals
+cancellation. Only one dependency check can remain unfinished at a time; if it
+ignores cancellation, later probes return not-ready until it settles.
+
+Readiness reports health for a load balancer or monitoring system. It does not
+block MCP calls itself. Tool handlers must still handle an unavailable backend.
+
+## Flush Measurements on Shutdown
+
+Available in this checkout; not yet published to npm.
+
+Pass `flushTelemetry` to `serveEmseepea` to flush your OpenTelemetry providers
+when the returned server's `close()` method runs. The callback receives
+`{ signal }`; it can call your providers' `forceFlush()` methods. Calling the
+Fastify app's `close()` directly does not run this callback.
+
+Shutdown uses two time limits:
+
+- `shutdownTimeoutMs`: finish existing requests, then close remaining
+  connections. The default is 5,000 milliseconds.
+- `telemetryFlushTimeoutMs`: wait for the final request measurements, then flush.
+  The default is 1,000 milliseconds; the allowed range is 1 to 60,000.
+
+The total waiting budget is the sum of those limits. The second limit applies
+only when you provide `flushTelemetry`. If final measurements are not ready in
+time, flushing is skipped. Repeated `close()` calls share the same work.
+
+Flushing is best-effort. Its errors do not change tool responses, and completion
+of `close()` does not prove that an exporter delivered data. Callbacks that block
+JavaScript or ignore cancellation cannot be forcibly stopped by the framework.
+
+## Describe What Clients Can Show
+
+Applications can give servers, tools, resources, reusable resource addresses,
+and prompts a human-friendly title, description, and icons. A server can also
+provide its website address. Tools can say whether they only read data and
+whether they contact services outside the application:
+
+```ts
+const getBeanDetails = defineTool({
+  name: "get-bean-details",
+  title: "Get bean details",
+  access: "public",
+  description: "Get the recorded details for one coffee.",
+  icons: [{ src: "https://coffee.example/icons/bean.png", mimeType: "image/png" }],
+  annotations: { readOnlyHint: true, openWorldHint: false },
+  inputSchema: z.object({ name: z.string() }),
+  outputSchema: beanDetails,
+  handler,
+});
+```
+
+Resources may also include their known byte size and hints about their intended
+audience and importance. Use `_meta` for application-specific public details.
+
+Em See Pea checks this metadata when the application starts and copies it, so
+later changes to the original objects have no effect. Tool annotations are
+hints for clients. They do not prove that a tool is safe, grant permission, or
+replace sign-in and authorization checks.
+
+## Route with a Tool Argument
+
+A proxy can route a request using a checked tool argument without reading the
+JSON body. Mark a string, integer, or boolean property with `x-mcp-header`:
+
+```ts
+const inputSchema = z.object({
+  region: z.string().meta({ "x-mcp-header": "Region" }),
+});
+```
+
+Compatible clients send the same value as `Mcp-Param-Region`. The tool still
+receives and checks `region` normally. The server rejects a missing or
+different header before the tool runs.
+
+This header is a copy of tool input. It does not identify a person, prove that
+they signed in, grant permission, or protect a secret.
+
+## Bound Large Catalogues
+
+Split long tool, resource, resource-address, and prompt lists into pages by
+adding one option to the server:
+
+```ts
+const app = createEmseepea({
+  name: "coffee-guide",
+  version: "1.0.0",
+  tools,
+  listPagination: { pageSize: 50, maxPageBytes: 256 * 1024 },
+});
+```
+
+`pageSize` must be between 1 and 100. `maxPageBytes` defaults to one mebibyte and
+stops a page earlier when its public catalogue details would be too large. The
+server stops at startup if one item cannot fit.
+
+Clients receive an opaque cursor for the next page. Identical server instances
+accept the same cursor. Changing the catalogue or either limit makes old
+cursors invalid. Cursors select public catalogue pages; they do not identify a
+person or grant permission. Omit `listPagination` to keep one-page lists.
+
+## Ask the Client for More Information
+
+Application authors can create a direct tool, resource, resource address
+pattern, or prompt that pauses and asks a capable client for more information.
+The client answers by making a fresh request, and the handler runs again with
+those answers in its context.
+
+This example asks the person for a coffee preference:
+
+```ts
+import { acceptedContent, defineTool, inputRequired } from "@emseepea/server";
+import { z } from "zod";
+
+const preference = z.object({ roast: z.enum(["light", "medium", "dark"]) });
+
+const chooseRoast = defineTool({
+  name: "choose-roast",
+  access: "public",
+  description: "Ask which roast a person prefers for one coffee.",
+  inputSchema: z.object({ coffee: z.string() }),
+  outputSchema: z.object({ coffee: z.string(), roast: z.string() }),
+  handler: ({ coffee }, context) => {
+    const answer = acceptedContent(context.inputResponses, "preference", preference);
+    if (!answer) {
+      return inputRequired({
+        inputRequests: {
+          preference: inputRequired.elicit({
+            message: `Which roast do you prefer for ${coffee}?`,
+            requestedSchema: preference,
+          }),
+        },
+      });
+    }
+    return {
+      text: `${answer.roast} roast selected for ${coffee}`,
+      data: { coffee, roast: answer.roast },
+    };
+  },
+});
+```
+
+Use `acceptedContent` with the same schema that described the form. Client
+answers are untrusted even when they have the expected wire shape. Use
+`inputResponse` when the handler must distinguish acceptance, refusal, and
+cancellation.
+
+A client answer supplies information. It is not proof of identity or permission
+to change data. Authorize any effect through the application's normal security
+boundary.
+
+The client must advertise elicitation for form input or URL-mode elicitation,
+where the client opens a URL. Em See Pea applies the normal result-size limit,
+time limit, cancellation, safe-error handling, and sign-in policy to every
+round.
+
+This release supports stateless requests only. It rejects opaque
+`requestState`. Mapped tools and progress-reporting tools return through their
+existing checked paths and cannot request more client input.
+
 ## Mapped Backend Tool
 
 `defineMappedTool` validates the public input, mapped backend command, backend
@@ -166,7 +382,8 @@ progress, the official MCP library sends progress events over the same POST
 request. Otherwise the call returns one JSON response.
 
 ```ts
-import { defineStreamingTool } from "@emseepea/server";
+import { createEmseepea, defineStreamingTool } from "@emseepea/server";
+import { z } from "zod";
 
 const roast = defineStreamingTool({
   name: "roast-batch",
@@ -190,13 +407,64 @@ change those positive bounds. The reporter closes with the tool call.
 Heartbeats are disabled. Invalid, oversized, late, or extra updates are
 rejected.
 
-Streaming tools start only for local examples. They do not yet support:
+### Use Progress Behind a Proxy
+
+In the current source, public tools can also report progress behind a trusted
+HTTPS proxy. This addition is not yet in a published npm release.
+
+Using the `roast` tool above, configure the proxy's exact address and the public
+host and origin your clients use:
+
+```ts
+const app = createEmseepea({
+  name: "coffee-guide",
+  version: "1.0.0",
+  tools: [roast],
+  deployment: {
+    mode: "production-behind-proxy",
+    trustedProxyAddresses: ["10.0.0.10"],
+    allowedAuthorities: ["mcp.example.com"],
+    allowedOrigins: ["https://mcp.example.com"],
+    rateLimit: { maxRequests: 100, windowMs: 60_000, maxClients: 1_000 },
+  },
+});
+```
+
+Replace these example addresses with yours. The server still listens locally
+by default. Choose a private listening address explicitly when starting it,
+and restrict network access so only your proxy can reach it.
+
+Your proxy must replace caller-supplied forwarding headers and send:
+
+- `X-Forwarded-Proto: https` for the original HTTPS connection
+- `X-Forwarded-For` containing one client IP address, not a comma-separated chain
+- `Host` matching an entry in `allowedAuthorities`
+
+It must also forward streamed responses without buffering them.
+`X-Accel-Buffering: no` asks compatible proxies not to buffer; it does not
+configure your proxy for you.
+
+Each call sends progress on its already-open HTTP response. A later call can
+go to another server without pinning that client to the first server. This
+does not share application state or rate limits: the configured limit applies
+to each server separately.
+
+### Limits
+
+Progress remains limited by the event count, event size, result size, and
+request deadline. Disconnecting cancels work that observes the cancellation
+signal. These checks do not slow the producer to match a slow reader.
+
+Not supported yet:
 
 - long-running streams opened with GET
 - saved sessions, replay, or subscriptions
-- proxy servers or recovery after reconnecting
+- recovery after reconnecting
 - slowing the producer when a client cannot keep up
-- more than one server instance
+- progress from tools requiring sign-in outside local development
+
+See the [progress coverage and tested proxy setup](../../docs/protocol-coverage.md#progress-updates)
+for the current checks and their limits.
 
 ## Public Resources and Prompts
 
@@ -226,6 +494,7 @@ const guide = defineResource({
   name: "getting-started",
   uri: guideUri,
   mimeType: "text/markdown",
+  cacheHint: { ttlMs: 30_000 },
   handler: () => ({ contents: [{ uri: guideUri, text: "# Brew safely" }] }),
 });
 
@@ -257,9 +526,31 @@ const app = createEmseepea({
   version: "1.0.0",
   resources: [guide, methodGuide],
   prompts: [brew],
+  cacheHints: {
+    "resources/list": { ttlMs: 60_000, cacheScope: "public" },
+    "resources/read": { ttlMs: 5_000, cacheScope: "private" },
+  },
 });
 ```
 
+## Tell Clients When They May Reuse Results
+
+By default, clients are told not to reuse lists, discovery details, or resource
+content. `cacheHints` sets a time limit in milliseconds and says whether a
+shared cache may store the result.
+
+Use `public` only when every caller receives the same non-sensitive result.
+Use `private` for results that only the requesting client may keep. These
+instructions do not grant access and do not make changing or personal data safe
+to share.
+
+An individual resource or reusable resource address can override either field.
+In the example, `guide` overrides the time limit while its missing
+`cacheScope` still comes from `cacheHints["resources/read"]`.
+
+Cache instructions are supported for discovery, tool lists, resource lists,
+reusable resource-address lists, prompt lists, and resource reads.
+
 Resource templates advertise an address pattern rather than listing every
 possible address. Clients list the patterns, then read an address that matches
 one. Each `{variable}` fills one complete path segment. The scheme and host
@@ -272,8 +563,8 @@ Pea checks the returned suggestions and keeps at most the first 100.
 Suggestions are public even when some tools require sign-in. Return only text
 that is safe for anyone to discover.
 
-Listing every matching address, large result pages, sign-in for resources, and
-custom caching are not included yet.
+Listing every matching address, catalogue pages without the bounds above, and
+sign-in for resources are not included yet.
 
 ## Tool That Requires Sign-In
 

package/dist/http.d.ts

@@ -0,0 +1,15 @@
+export interface JsonHttpClientOptions {
+    readonly origin: string | URL;
+    readonly maxResponseBytes?: number;
+}
+export interface JsonHttpGetOptions {
+    readonly pathname: string;
+    readonly searchParams?: Readonly<Record<string, string | readonly string[]>>;
+    readonly signal: AbortSignal;
+    readonly deadlineMs: number;
+}
+export interface JsonHttpClient {
+    readonly get: (options: JsonHttpGetOptions) => Promise<unknown>;
+}
+export declare function createJsonHttpClient(candidate: JsonHttpClientOptions): JsonHttpClient;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAiDA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IAC7E,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,qBAAqB,GAAG,cAAc,CAiCrF"}

package/dist/http.js

@@ -0,0 +1,284 @@
+import { lookup } from "node:dns/promises";
+import { request } from "node:https";
+import { BlockList, isIP } from "node:net";
+import { TextDecoder } from "node:util";
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_RESPONSE_HEADER_BYTES = 16 * 1024;
+const MAX_REQUEST_TARGET_BYTES = 8 * 1024;
+const MAX_DEADLINE_DELAY_MS = 2_147_483_647;
+const FAILURE_MESSAGE = "Outbound JSON request failed";
+const prohibitedIpv4Addresses = new BlockList();
+for (const [network, prefix] of [
+    ["0.0.0.0", 8],
+    ["10.0.0.0", 8],
+    ["100.64.0.0", 10],
+    ["127.0.0.0", 8],
+    ["169.254.0.0", 16],
+    ["172.16.0.0", 12],
+    ["192.0.0.0", 24],
+    ["192.0.2.0", 24],
+    ["192.88.99.0", 24],
+    ["192.168.0.0", 16],
+    ["198.18.0.0", 15],
+    ["198.51.100.0", 24],
+    ["203.0.113.0", 24],
+    ["224.0.0.0", 4],
+    ["240.0.0.0", 4],
+])
+    prohibitedIpv4Addresses.addSubnet(network, prefix, "ipv4");
+const prohibitedIpv6Addresses = new BlockList();
+const globallyRoutableIpv6Addresses = new BlockList();
+globallyRoutableIpv6Addresses.addSubnet("2000::", 3, "ipv6");
+for (const [network, prefix] of [
+    ["::", 128],
+    ["::1", 128],
+    ["::ffff:0:0", 96],
+    ["64:ff9b::", 96],
+    ["64:ff9b:1::", 48],
+    ["100::", 64],
+    ["2001::", 23],
+    ["2001:db8::", 32],
+    ["2002::", 16],
+    ["3fff::", 20],
+    ["fc00::", 7],
+    ["fe80::", 10],
+    ["ff00::", 8],
+])
+    prohibitedIpv6Addresses.addSubnet(network, prefix, "ipv6");
+export function createJsonHttpClient(candidate) {
+    assertKeys(candidate, ["origin", "maxResponseBytes"], "HTTP client options");
+    const origin = normalizeOrigin(candidate.origin);
+    const maxResponseBytes = boundedPositiveInteger(candidate.maxResponseBytes ?? MAX_RESPONSE_BYTES, "maxResponseBytes", MAX_RESPONSE_BYTES);
+    return Object.freeze({
+        async get(options) {
+            try {
+                assertKeys(options, ["pathname", "searchParams", "signal", "deadlineMs"], "HTTP GET options");
+                const url = requestUrl(origin, options.pathname, options.searchParams);
+                const operation = operationSignal(options.signal, options.deadlineMs);
+                try {
+                    operation.signal.throwIfAborted();
+                    const addresses = await waitFor(lookup(url.hostname, { all: true, order: "verbatim" }), operation.signal);
+                    operation.signal.throwIfAborted();
+                    if (addresses.length === 0 || addresses.some(({ address, family }) => !isAllowedAddress(address, family))) {
+                        throw new Error(FAILURE_MESSAGE);
+                    }
+                    const selected = addresses[0];
+                    if (!selected)
+                        throw new Error(FAILURE_MESSAGE);
+                    return await waitFor(readJson(url, selected, maxResponseBytes, operation.signal), operation.signal);
+                }
+                finally {
+                    operation.dispose();
+                }
+            }
+            catch {
+                throw new Error(FAILURE_MESSAGE);
+            }
+        },
+    });
+}
+function normalizeOrigin(candidate) {
+    let url;
+    try {
+        url = new URL(candidate instanceof URL ? candidate.href : candidate);
+    }
+    catch {
+        throw new TypeError("origin must be a valid URL");
+    }
+    const hostname = url.hostname.startsWith("[") && url.hostname.endsWith("]")
+        ? url.hostname.slice(1, -1)
+        : url.hostname;
+    if (url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" ||
+        url.search || url.hash || isIP(hostname) !== 0) {
+        throw new TypeError("origin must be an HTTPS origin without credentials, path, query, fragment, or IP literal");
+    }
+    return new URL(url.origin);
+}
+function requestUrl(origin, pathname, searchParams) {
+    if (typeof pathname !== "string" || !pathname.startsWith("/") || pathname.startsWith("//") ||
+        pathname.includes("\\") || pathname.includes("?") || pathname.includes("#")) {
+        throw new TypeError("pathname must be one root-relative URL path");
+    }
+    const url = new URL(pathname, origin);
+    if (url.origin !== origin.origin || url.protocol !== "https:" || url.username || url.password || url.hash) {
+        throw new TypeError("pathname escaped the configured origin");
+    }
+    if (searchParams !== undefined) {
+        assertPlainRecord(searchParams, "searchParams");
+        for (const [name, value] of Object.entries(searchParams).sort(([left], [right]) => left.localeCompare(right))) {
+            if (typeof value === "string") {
+                url.searchParams.append(name, value);
+            }
+            else if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+                for (const entry of value)
+                    url.searchParams.append(name, entry);
+            }
+            else {
+                throw new TypeError("searchParams values must be strings or string arrays");
+            }
+        }
+    }
+    if (Buffer.byteLength(`${url.pathname}${url.search}`, "utf8") > MAX_REQUEST_TARGET_BYTES) {
+        throw new TypeError("request target exceeds the configured size limit");
+    }
+    return url;
+}
+function isAllowedAddress(address, family) {
+    if (isIP(address) !== family || (family !== 4 && family !== 6))
+        return false;
+    return family === 4
+        ? !prohibitedIpv4Addresses.check(address, "ipv4")
+        : globallyRoutableIpv6Addresses.check(address, "ipv6")
+            && !prohibitedIpv6Addresses.check(address, "ipv6");
+}
+function operationSignal(parent, deadlineMs) {
+    if (!(parent instanceof AbortSignal) || !Number.isSafeInteger(deadlineMs) ||
+        deadlineMs - Date.now() > MAX_DEADLINE_DELAY_MS) {
+        throw new TypeError("signal and a safe-integer absolute deadlineMs are required");
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (parent.aborted || deadlineMs <= Date.now())
+        controller.abort();
+    else
+        parent.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(abort, Math.max(0, deadlineMs - Date.now()));
+    timer.unref();
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timer);
+            parent.removeEventListener("abort", abort);
+        },
+    };
+}
+async function waitFor(promise, signal) {
+    if (signal.aborted)
+        throw new Error(FAILURE_MESSAGE);
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", abort);
+            callback();
+        };
+        const abort = () => finish(() => reject(new Error(FAILURE_MESSAGE)));
+        signal.addEventListener("abort", abort, { once: true });
+        void promise.then((value) => finish(() => resolve(value)), () => finish(() => reject(new Error(FAILURE_MESSAGE))));
+    });
+}
+function readJson(url, selected, maxResponseBytes, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const fail = () => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(FAILURE_MESSAGE));
+        };
+        const requestOptions = {
+            agent: false,
+            autoSelectFamily: false,
+            headers: {
+                Accept: "application/json",
+                "Accept-Encoding": "identity",
+                Host: url.host,
+            },
+            family: selected.family,
+            lookup: (_hostname, _options, callback) => callback(null, selected.address, selected.family),
+            maxHeaderSize: MAX_RESPONSE_HEADER_BYTES,
+            method: "GET",
+            servername: url.hostname,
+            signal,
+        };
+        const outgoing = request(url, requestOptions, (incoming) => {
+            if (signal.aborted || settled) {
+                incoming.destroy();
+                return;
+            }
+            const status = incoming.statusCode ?? 0;
+            const contentType = oneHeader(incoming.headersDistinct?.["content-type"]);
+            const contentEncoding = oneHeader(incoming.headersDistinct?.["content-encoding"]);
+            const contentLength = oneHeader(incoming.headersDistinct?.["content-length"]);
+            if (status < 200 || status > 299 || !isJsonContentType(contentType ?? undefined) ||
+                contentEncoding === null ||
+                (contentEncoding !== undefined && contentEncoding.toLowerCase() !== "identity") ||
+                contentLength === null ||
+                (contentLength !== undefined && !validContentLength(contentLength, maxResponseBytes))) {
+                incoming.destroy();
+                fail();
+                return;
+            }
+            const chunks = [];
+            let bytes = 0;
+            incoming.on("data", (chunk) => {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                bytes += buffer.length;
+                if (bytes > maxResponseBytes) {
+                    incoming.destroy();
+                    fail();
+                }
+                else {
+                    chunks.push(buffer);
+                }
+            });
+            incoming.once("aborted", fail);
+            incoming.once("error", fail);
+            incoming.once("close", () => {
+                if (!incoming.complete)
+                    fail();
+            });
+            incoming.once("end", () => {
+                if (settled)
+                    return;
+                try {
+                    signal.throwIfAborted();
+                    const text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+                    const value = JSON.parse(text);
+                    signal.throwIfAborted();
+                    settled = true;
+                    resolve(value);
+                }
+                catch {
+                    fail();
+                }
+            });
+        });
+        outgoing.once("error", fail);
+        outgoing.end();
+    });
+}
+function oneHeader(values) {
+    if (values === undefined || values.length === 0)
+        return undefined;
+    return values.length === 1 ? values[0] ?? null : null;
+}
+function isJsonContentType(value) {
+    return value !== undefined && /^application\/(?:json|[a-z0-9!#$&^_.+-]+\+json)(?:\s*;.*)?$/i.test(value);
+}
+function validContentLength(value, maximum) {
+    const length = Number(value);
+    return /^(?:0|[1-9]\d*)$/.test(value) && Number.isSafeInteger(length) && length <= maximum;
+}
+function assertKeys(value, allowed, label) {
+    assertPlainRecord(value, label);
+    const accepted = new Set(allowed);
+    if (Reflect.ownKeys(value).some((key) => typeof key !== "string" || !accepted.has(key))) {
+        throw new TypeError(`${label} contains an unsupported field`);
+    }
+}
+function assertPlainRecord(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value) ||
+        (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)) {
+        throw new TypeError(`${label} must be a plain object`);
+    }
+}
+function boundedPositiveInteger(value, label, maximum) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+        throw new TypeError(`${label} must be a positive integer no greater than ${maximum}`);
+    }
+    return value;
+}
+//# sourceMappingURL=http.js.map