@plurnk/plurnk-schemes-http 1.14.1 → 1.15.0

package/dist/Http.js

@@ -1,21 +1,20 @@
 // HTTP(S) handler. Operation-to-method semantics live in {§op-surface};
 // acquisition, materialization, publication, and query flow live in
 // {§http-lifecycle}. The implementation depends only on SchemeCtx capabilities.
-var _a;
 import { createParser } from "eventsource-parser";
-import { MimetypeClassifier, NetworkAddress, ProjectionInputLimitError, Results, } from "@plurnk/plurnk-schemes";
+import { MimetypeClassifier, NetworkAddress, ProjectionInputLimitError, Results } from "@plurnk/plurnk-schemes";
 import { readFile } from "node:fs/promises";
 import ErrorDetail from "./ErrorDetail.js";
-import WebFetcher, { DEFAULT_WEB_UA, CACHE_VARIANT_HEADER, MATERIALIZER_ID_HEADER, PROJECTION_ID_HEADER, cacheVariantEvidence, classifyCacheVariant, WebMaterializationError, } from "./WebFetcher.js";
+import WebFetcher, { CACHE_VARIANT_HEADER, MATERIALIZER_ID_HEADER, PROJECTION_ID_HEADER, cacheVariantEvidence, classifyCacheVariant } from "./WebFetcher.js";
 import { responseMimetype } from "./ContentType.js";
 import { requireNonNegativeIntegerEnv as requireNumEnv } from "./Config.js";
+import { BODY, FETCHED_AT, HEADER, REQUEST_METHOD } from "./http-names.js";
+import HttpGet from "./HttpGet.js";
+import HttpRequester from "./HttpRequester.js";
+import LiveAcquisitions from "./LiveAcquisitions.js";
 // The channel the response body streams into, and the header metadata channel.
-const BODY = "body";
-const HEADER = "header";
 // Package-owned metadata appended after untrusted origin headers. Readers take
 // the last value so an origin using the same field name cannot override it.
-const FETCHED_AT = "x-plurnk-fetched-at";
-const REQUEST_METHOD = "x-plurnk-request-method";
 const DELTA_SECONDS_LIMIT = 2147483648n;
 const BODY_PROCESSING_FIELDS = new Set([
     "content-encoding",
@@ -135,8 +134,7 @@ const httpDate = (value, now = Date.now()) => {
 // The package-shipped model teaching is loaded verbatim and fails hard if absent.
 // The relative path is identical from src/ during development and dist/ after build.
 const documentation = await readFile(new URL("../docs/https.md", import.meta.url), "utf-8");
-const LLMS_TEXT_ATTEMPT_TTL_MS = 3_600_000;
-class Http {
+export default class Http {
     static manifest = {
         // "https" is the registered face — plain http folds into it exactly as
         // ws folds into wss ({§http-manifest}); supported, never advertised as
@@ -164,7 +162,7 @@ class Http {
             "## EDIT0 (https://api.example.com/v1/pets/42) {Content-Type: application/json}",
             '{"name":"Mango","status":"available"}',
             "",
-            "## SEND0 [200] (https://api.example.com/v1/pets) {Content-Type: application/json}",
+            "## SEND0 (https://api.example.com/v1/pets) {Content-Type: application/json}",
             '{"name":"Mango","status":"available"}',
         ].join("\n"),
         documentation,
@@ -175,10 +173,14 @@ class Http {
     // {§http-llms-txt} — one opportunistic origin-companion attempt per TTL
     // window; success and failure share the timer so a 404 does not re-probe
     // on every READ.
-    #llmsTextAttempts = new Map();
+    #get;
+    #requester;
+    #live = new LiveAcquisitions();
     constructor() {
         this.#errorDetailLimit = ErrorDetail.configuredLimit();
         this.#webFetcher = new WebFetcher();
+        this.#get = new HttpGet({ live: this.#live, errorDetailLimit: this.#errorDetailLimit, webFetcher: this.#webFetcher, address: Http.#address, requestHeaders: Http.#requestHeaders, passthrough: Http.#passthrough, requestMethod: Http.#requestMethod, reusableGetRepresentation: Http.#reusableGetRepresentation, materializerIdentity: Http.#materializerIdentity, validators: Http.#validators, materializationFailure: Http.#materializationFailure, sourceMimetype: Http.#sourceMimetype, fresh: Http.#fresh, cancelled: Http.#cancelled, bad: Http.#bad, revalidationCorresponds: Http.#revalidationCorresponds, refreshAfter304: Http.#refreshAfter304, seedEntry: Http.#seedEntry, settleEventStream: Http.#settleEventStream });
+        this.#requester = new HttpRequester({ live: this.#live, manifest: Http.manifest, errorDetailLimit: this.#errorDetailLimit, address: Http.#address, requestHeaders: Http.#requestHeaders, bad: Http.#bad, seedEntry: Http.#seedEntry, passthrough: Http.#passthrough, writeHeader: Http.#writeHeader, writeProjectionIdentity: Http.#writeProjectionIdentity, cancelled: Http.#cancelled, materializationFailure: Http.#materializationFailure });
     }
     async ready() {
         WebFetcher.validateConfiguration();
@@ -188,252 +190,19 @@ class Http {
     // returned 102 for a retained SSE response.
     async prepareRepresentation(request, ctx) {
         if (request.target.kind !== "url") {
-            return _a.#bad(400, "http", "bad-target", "READ requires an http(s):// URL target.", {
+            return Http.#bad(400, "http", "bad-target", "READ requires an http(s):// URL target.", {
                 stage: "target-validation",
                 recovery: "Provide an http(s):// URL target.",
                 retryable: false,
             });
         }
-        return this.#prepareGet(request.target, request.metadata, request.pathname, ctx);
-    }
-    async #prepareGet(target, metadata, pathname, ctx) {
-        const address = _a.#address(target);
-        if (!(address instanceof NetworkAddress))
-            return address;
-        const { url } = address;
-        const requestHeaders = _a.#requestHeaders(metadata);
-        if (!Array.isArray(requestHeaders))
-            return requestHeaders;
-        let cached;
-        const conditional = [];
-        const prior = await ctx.entries.read(pathname);
-        if (Results.isErrorStatus(prior.status) && prior.status !== 404) {
-            return _a.#passthrough(prior);
-        }
-        const priorBody = prior.entry?.channels[BODY];
-        const priorHeader = prior.entry?.channels[HEADER];
-        if (prior.entry !== null && _a.#requestMethod(priorHeader?.content ?? "") === undefined) {
-            return { status: 200 };
-        }
-        if (prior.entry !== null && priorBody !== undefined && priorHeader !== undefined) {
-            try {
-                if (await _a.#reusableGetRepresentation(prior.entry, requestHeaders, ctx.projection)) {
-                    cached = prior.entry;
-                    if (_a.#materializerIdentity(priorHeader.content) === undefined) {
-                        conditional.push(..._a.#validators(priorHeader.content));
-                    }
-                }
-            }
-            catch (cause) {
-                return _a.#materializationFailure(url, "GET", new WebMaterializationError(_a.#sourceMimetype(priorHeader.content), cause));
-            }
-        }
-        if (cached !== undefined && _a.#fresh(cached.channels[HEADER].content)) {
-            return { status: 200 };
-        }
-        let fetched;
-        try {
-            fetched = await this.#webFetcher.fetch(url, {
-                signal: ctx.signal,
-                headers: requestHeaders,
-                ...(conditional.length > 0
-                    ? { conditionalHeaders: conditional }
-                    : {}),
-                guarded: false,
-                acceptHttpErrors: true,
-                preserveUnavailable: true,
-            });
-        }
-        catch (error) {
-            if (ctx.signal?.aborted === true && error === ctx.signal.reason) {
-                return _a.#cancelled(url, "GET");
-            }
-            throw error;
-        }
-        if (fetched === null) {
-            return _a.#bad(404, "http", "not-materialized", `The URL ${url} could not be materialized.`, {
-                target: url,
-                stage: "acquisition",
-                retryable: true,
-            });
-        }
-        if (fetched.status === 304) {
-            if (cached === undefined) {
-                return _a.#bad(502, "http", "fetch-failed", `HTTP GET ${url} returned 304 without a reusable stored representation.`, {
-                    target: url,
-                    method: "GET",
-                    stage: "acquisition",
-                    retryable: true,
-                });
-            }
-            const cachedHeader = cached.channels[HEADER].content;
-            if (_a.#materializerIdentity(cachedHeader) !== undefined) {
-                return _a.#bad(502, "http", "fetch-failed", `HTTP GET ${url} returned 304 for a stored representation that requires full reacquisition.`, {
-                    target: url,
-                    method: "GET",
-                    stage: "acquisition",
-                    retryable: true,
-                });
-            }
-            const responseHeaders = fetched.responseHeaders ?? [];
-            if (_a.#revalidationCorresponds(cachedHeader, new Headers(responseHeaders.map(([name, value]) => [name, value])))) {
-                const channels = {
-                    ...cached.channels,
-                    [HEADER]: {
-                        ...cached.channels[HEADER],
-                        content: _a.#refreshAfter304(cachedHeader, responseHeaders, requestHeaders),
-                    },
-                };
-                const written = await ctx.entries.write(pathname, {
-                    channels,
-                });
-                if (Results.isErrorStatus(written.status))
-                    return _a.#passthrough(written);
-                return { status: 200 };
-            }
-            // {§revalidation} — a genuinely mismatched 304 (different opaque
-            // tags): the conditional is the problem, so fall back to one
-            // unconditional GET and acquire normally instead of surfacing
-            // an unrecoverable 502. A second 304 has no way out and is the
-            // honest failure.
-            try {
-                fetched = await this.#webFetcher.fetch(url, {
-                    signal: ctx.signal,
-                    headers: requestHeaders,
-                    guarded: false,
-                    acceptHttpErrors: true,
-                    preserveUnavailable: true,
-                });
-            }
-            catch (error) {
-                if (ctx.signal?.aborted === true && error === ctx.signal.reason) {
-                    return _a.#cancelled(url, "GET");
-                }
-                throw error;
-            }
-            if (fetched === null) {
-                return _a.#bad(404, "http", "not-materialized", `The URL ${url} could not be materialized.`, {
-                    target: url,
-                    stage: "acquisition",
-                    retryable: true,
-                });
-            }
-            if (fetched.status === 304) {
-                return _a.#bad(502, "http", "fetch-failed", `HTTP GET ${url} returned 304 without identifying the stored representation nominated for revalidation.`, {
-                    target: url,
-                    method: "GET",
-                    stage: "acquisition",
-                    retryable: true,
-                });
-            }
-            // Non-304: fall through to ordinary acquisition below.
-        }
-        if (fetched.mimetype === "text/event-stream"
-            && fetched.response?.body !== null
-            && fetched.response?.body !== undefined) {
-            return this.#openEventStream(address, fetched, ctx);
-        }
-        let materialized;
-        try {
-            materialized = await WebFetcher.materialize(fetched, ctx.projection, ctx.signal);
-        }
-        catch (error) {
-            if (ctx.signal?.aborted === true)
-                return _a.#cancelled(url, "GET");
-            if (error instanceof WebMaterializationError) {
-                return _a.#materializationFailure(url, "GET", error);
-            }
-            throw error;
-        }
-        if (materialized === null) {
-            return _a.#bad(415, "http", "binary-response-unsupported", `HTTP GET ${url} returned ${fetched.mimetype}. The remote response was received, but its binary body cannot be represented in a Plurnk text channel.`, {
-                target: url,
-                method: "GET",
-                mimetype: fetched.mimetype,
-                stage: "materialization",
-                recovery: "Inspect #header or use a byte-capable client.",
-                retryable: false,
-            });
-        }
-        const written = await ctx.entries.write(pathname, {
-            channels: WebFetcher.materializedChannels(materialized, { url, method: "GET" }),
-        });
-        if (Results.isErrorStatus(written.status))
-            return _a.#passthrough(written);
-        await this.#piggybackLlmsText(address, ctx);
-        return { status: 200 };
-    }
-    // {§http-llms-txt} — after a successful generic GET materialization,
-    // acquire <origin>/llms.txt once per TTL window and materialize it as its
-    // own https entry. Any failure is quiet: the companion never fails the
-    // READ that piggybacked it, and the companion itself never recurses.
-    async #piggybackLlmsText(address, ctx) {
-        const url = new URL(address.url);
-        if (url.pathname === "/llms.txt")
-            return;
-        const origin = url.origin;
-        const last = this.#llmsTextAttempts.get(origin);
-        if (last !== undefined && Date.now() - last < LLMS_TEXT_ATTEMPT_TTL_MS)
-            return;
-        this.#llmsTextAttempts.set(origin, Date.now());
-        const llmsUrl = `${origin}/llms.txt`;
-        try {
-            const fetched = await this.#webFetcher.fetch(llmsUrl, {
-                signal: ctx.signal,
-                guarded: false,
-                acceptHttpErrors: true,
-                preserveUnavailable: true,
-            });
-            if (fetched === null)
-                return;
-            // A missing companion (404) or any non-2xx is quiet — no entry.
-            if ((fetched.status ?? 200) >= 400)
-                return;
-            const materialized = await WebFetcher.materialize(fetched, ctx.projection, ctx.signal);
-            if (materialized === null)
-                return;
-            await ctx.entries.write("/llms.txt", {
-                channels: WebFetcher.materializedChannels(materialized, { url: llmsUrl, method: "GET" }),
-            });
-        }
-        catch {
-            // Quiet by contract: 404, guard rejection, network error, binary.
-        }
-    }
-    async #openEventStream(address, fetched, ctx) {
-        const response = fetched.response;
-        if (response?.body === null || response?.body === undefined) {
-            throw new Error("SSE preparation lost its response body.");
-        }
-        const local = new AbortController();
-        const handle = {
-            cancel: async () => {
-                local.abort();
-                await response.body?.cancel().catch(() => { });
-            },
-        };
-        const written = await ctx.entries.write(address.pathname, _a.#seedEntry());
-        if (Results.isErrorStatus(written.status))
-            return _a.#passthrough(written);
-        const subscription = await ctx.subscriptions.open(address.pathname, handle);
-        if (fetched.header !== undefined) {
-            await subscription.notifyChunk(HEADER, fetched.header, "text/plain");
-        }
-        void _a.#settleEventStream(subscription, response, {
-            url: address.url,
-            method: "GET",
-            signal: local.signal,
-            errorDetailLimit: this.#errorDetailLimit,
-        }).catch((error) => {
-            console.error("HTTP SSE terminal cleanup failed", { url: address.url, error });
-        });
-        return { shape: "passthrough", status: 102 };
+        return this.#get.prepareGet(request.target, request.metadata, request.pathname, ctx);
     }
     // EDIT -> PUT the body (full-resource replace). `<L>` has no meaning against a
     // remote resource - reject rather than silently ignore the model's intent.
     async editBatch(statements, ctx) {
         if (statements.length !== 1) {
-            return _a.#bad(409, "http", "non-atomic-edit-batch", `${statements.length} EDIT statements cannot be committed atomically to one remote resource.`, {
+            return Http.#bad(409, "http", "non-atomic-edit-batch", `${statements.length} EDIT statements cannot be committed atomically to one remote resource.`, {
                 statements: statements.length,
                 stage: "mutation",
                 recovery: "Submit one whole-resource EDIT.",
@@ -442,215 +211,77 @@ class Http {
         }
         const statement = statements[0];
         if (statement.target === null || statement.target.kind !== "url") {
-            return _a.#bad(400, "http", "bad-target", "EDIT requires an http(s):// URL target.", {
+            return Http.#bad(400, "http", "bad-target", "EDIT requires an http(s):// URL target.", {
                 stage: "target-validation",
                 recovery: "Provide an http(s):// URL target.",
                 retryable: false,
             });
         }
         if (statement.lineMarker !== null) {
-            return _a.#bad(400, "http", "line-edit-unsupported", "HTTP EDIT replaces the whole remote resource and does not accept a line range.", {
+            return Http.#bad(400, "http", "line-edit-unsupported", "HTTP EDIT replaces the whole remote resource and does not accept a line range.", {
                 stage: "mutation",
                 recovery: "Remove the line range and submit the complete replacement body.",
                 retryable: false,
             });
         }
-        return this.#request(statement.target, statement.metadata, ctx, "PUT", statement.body ?? "");
+        return this.#requester.request(statement.target, statement.metadata, ctx, "PUT", statement.body ?? "");
     }
     async edit(statement, ctx) {
         return this.editBatch([statement], ctx);
     }
-    // KILL -> DELETE the resource. Distinct from SEND signal 410 (which drops the local
-    // cached entry): KILL is an HTTP DELETE request to the remote.
+    // {§http-kill} — KILL follows the entry rule: a live acquisition of the address is
+    // cancelled, otherwise the stored response is forgotten. The remote DELETE is its own
+    // spelling, `## KILL0 (https://…) {remote}`; any other metadata blocks are its headers.
     async kill(statement, ctx) {
         if (statement.target === null || statement.target.kind !== "url") {
-            return _a.#bad(400, "http", "bad-target", "KILL requires an http(s):// URL target.", {
+            return Http.#bad(400, "http", "bad-target", "KILL requires an http(s):// URL target.", {
                 stage: "target-validation",
                 recovery: "Provide an http(s):// URL target.",
                 retryable: false,
             });
         }
-        return this.#request(statement.target, statement.metadata, ctx, "DELETE", statement.body ?? undefined);
+        const blocks = statement.metadata ?? [];
+        const remote = blocks.some((block) => block.trim() === "remote");
+        if (remote) {
+            const headers = blocks.filter((block) => block.trim() !== "remote");
+            return this.#requester.request(statement.target, headers.length === 0 ? null : headers, ctx, "DELETE", undefined);
+        }
+        const address = Http.#address(statement.target);
+        if (!(address instanceof NetworkAddress))
+            return address;
+        if (this.#live.cancel(LiveAcquisitions.key(ctx.workerId, address.url))) {
+            // The owner settles itself as cancelled through its aborted signal.
+            return { shape: "passthrough", status: 200 };
+        }
+        return Http.#passthrough(await ctx.entries.delete(address.pathname));
     }
-    // SEND dispatch — status-code-as-verb (SPEC {§op-surface}).
-    //   200 -> request with body (POST), stream response
-    //   410 -> delete the cached entry
-    //   499 -> cancel in-flight (handled by the subscription's force-cancel;
-    //         the engine routes 499 to the registered SubscriptionHandle, so a
-    //         scheme-level no-op here is correct — teardown already happened)
+    // SEND dispatch — a recipient SEND with a body is the POST; a disposition label never
+    // reaches a scheme, and any other status is refused 501 ({§send-label}).
     async send(statement, ctx) {
         if (statement.target === null || statement.target.kind !== "url") {
-            return _a.#bad(400, "http", "bad-target", "SEND requires an http(s):// URL target.", {
+            return Http.#bad(400, "http", "bad-target", "SEND requires an http(s):// URL target.", {
                 stage: "target-validation",
                 recovery: "Provide an http(s):// URL target.",
                 retryable: false,
             });
         }
-        const status = statement.signal;
-        if (status === 200) {
+        // A recipient SEND with a body posts it ({§send-label}: dispositions never reach a scheme).
+        if (statement.status === null) {
             const body = statement.body?.raw ?? "";
-            return this.#request(statement.target, statement.metadata, ctx, "POST", body);
-        }
-        if (statement.metadata !== null) {
-            return _a.#bad(400, "http", "metadata-not-applicable", `HTTP SEND status ${status} does not issue a request, so it does not accept {metadata}.`, { requestedStatus: status, retryable: false });
-        }
-        if (status === 410) {
-            const address = _a.#address(statement.target);
-            if (!(address instanceof NetworkAddress))
-                return address;
-            return _a.#passthrough(await ctx.entries.delete(address.pathname));
-        }
-        if (status === 499) {
-            // Cancellation is routed by the engine to the subscription's
-            // SubscriptionHandle.cancel (registered by #request). Nothing
-            // for the scheme to do at the op level.
-            return { shape: "passthrough", status: 200 };
+            return this.#requester.request(statement.target, statement.metadata, ctx, "POST", body);
         }
+        const status = statement.status;
         // Entry-bearing schemes return 501 for status codes they don't interpret.
-        return _a.#bad(501, "http", "send-status-unsupported", `The HTTP scheme does not interpret SEND status ${status}.`, {
+        return Http.#bad(501, "http", "send-status-unsupported", `The HTTP scheme does not interpret SEND status ${status}.`, {
             requestedStatus: status,
             stage: "dispatch",
             retryable: false,
         });
     }
-    // Mutation responses use the same entry/channel and subscription primitives
-    // as every live producer; GET acquisition belongs solely to
-    // prepareRepresentation.
-    async #request(target, metadata, ctx, method, body) {
-        const address = _a.#address(target);
-        if (!(address instanceof NetworkAddress))
-            return address;
-        const { url } = address;
-        const { pathname } = address;
-        const headers = _a.#requestHeaders(metadata);
-        if (!Array.isArray(headers))
-            return headers;
-        const publishedChannel = target.fragment ?? _a.manifest.defaultChannel;
-        if (!(publishedChannel in _a.manifest.channels)) {
-            const availableChannels = Object.keys(_a.manifest.channels);
-            return _a.#bad(400, "http", "channel-not-found", `Channel #${publishedChannel} does not exist on HTTP responses.`, {
-                requestedChannel: publishedChannel,
-                availableChannels,
-                recovery: `Use one of the available channels: ${availableChannels.map((channel) => `#${channel}`).join(", ")}.`,
-                retryable: false,
-            });
-        }
-        // Local AbortController for force-cancel from outside (SEND signal 499).
-        const local = new AbortController();
-        const handle = { cancel: () => local.abort() };
-        // {§http-lifecycle} open() binds an existing entry, so the handler seeds
-        // its manifest-owned channel shape before subscribing.
-        const written = await ctx.entries.write(pathname, _a.#seedEntry());
-        if (Results.isErrorStatus(written.status))
-            return _a.#passthrough(written);
-        // open() returns the worker+teardown-composed signal — fires on loop.cancel
-        // OR our local teardown. Wire it so either path aborts acquisition.
-        const subscription = await ctx.subscriptions.open(pathname, handle);
-        const onAbort = () => local.abort();
-        subscription.addEventListener("abort", onAbort, { once: true });
-        try {
-            const response = await fetch(url, {
-                method,
-                body,
-                headers: headers.some(([k]) => k.toLowerCase() === "user-agent")
-                    ? headers
-                    : [["User-Agent", DEFAULT_WEB_UA], ...headers],
-                signal: local.signal,
-                redirect: "follow",
-            });
-            const responseMime = responseMimetype(response.headers.get("content-type"));
-            // {§http-lifecycle}/{§mimetype-classifier} String channels retain
-            // textual response data. Binary input is transient: an installed
-            // reader may derive Unicode, otherwise the durable body is a typed
-            // empty marker rather than a fabricated byte channel.
-            await _a.#writeHeader(subscription, method, response.status, response.statusText, [...response.headers], headers);
-            const bodyMime = responseMime;
-            if (response.body === null) {
-                await subscription.close({ status: 200 }, `HTTP ${response.status}; empty body`);
-                return { shape: "passthrough", status: 102 };
-            }
-            const responseBody = response.body;
-            const byteBody = {
-                chunks: responseBody,
-                cancel: () => responseBody.cancel(),
-            };
-            const binary = await WebFetcher.classifyBinary(byteBody, bodyMime, ctx.projection);
-            if (binary) {
-                let projected;
-                try {
-                    projected = await WebFetcher.projectBytes(byteBody, bodyMime, ctx.projection);
-                }
-                catch (error) {
-                    await subscription.notifyChunk(BODY, "", bodyMime);
-                    throw error;
-                }
-                if (projected !== null) {
-                    await _a.#writeProjectionIdentity(subscription, projected.projectionIdentity);
-                    await subscription.notifyChunk(BODY, projected.content, projected.mimetype);
-                    await subscription.close({ status: 200 }, `HTTP ${response.status}; ${projected.content.length} readable chars from ${bodyMime}`);
-                    return { shape: "passthrough", status: 102 };
-                }
-                await subscription.notifyChunk(BODY, "", bodyMime);
-                const detail = `HTTP ${method} ${url} returned ${bodyMime}. The remote response was received, but its binary body cannot be represented in a Plurnk text channel.`;
-                const result = _a.#bad(415, "http", "binary-response-unsupported", detail, {
-                    target: url,
-                    method,
-                    mimetype: bodyMime,
-                    stage: "materialization",
-                    recovery: "Do not retry the request solely to retrieve this body; inspect #header or use a byte-capable client.",
-                    retryable: false,
-                });
-                await subscription.close(result, detail);
-                return result;
-            }
-            // {§http-text-decoding} Fetch text is replacement-mode UTF-8;
-            // Content-Type charset remains response evidence, not a second decoder.
-            let bytes = 0;
-            const decoder = new TextDecoder();
-            for await (const chunk of responseBody) {
-                bytes += chunk.length;
-                await subscription.notifyChunk(BODY, decoder.decode(chunk, { stream: true }), bodyMime);
-            }
-            const tail = decoder.decode();
-            if (tail.length > 0)
-                await subscription.notifyChunk(BODY, tail, bodyMime);
-            await subscription.close({ status: 200 }, `HTTP ${response.status}; ${bytes} bytes`);
-            return { shape: "passthrough", status: 102 };
-        }
-        catch (err) {
-            const aborted = local.signal.aborted;
-            if (aborted) {
-                const result = _a.#cancelled(url, method);
-                await subscription.close(result, result.problem?.detail);
-                return result;
-            }
-            if (err instanceof WebMaterializationError) {
-                const result = _a.#materializationFailure(url, method, err);
-                await subscription.close(result, result.problem?.detail);
-                return result;
-            }
-            console.error("HTTP acquisition failed", { method, url, err });
-            const cause = ErrorDetail.preview(err, this.#errorDetailLimit);
-            const reason = `HTTP ${method} ${url} failed: ${cause}`;
-            // The remaining catch owns acquisition failure; cancellation and
-            // typed materialization failures settled above.
-            const result = _a.#bad(502, "http", "fetch-failed", reason, {
-                target: url,
-                method,
-                stage: "acquisition",
-                retryable: method !== "POST",
-            });
-            await subscription.close(result, reason);
-            return result;
-        }
-        finally {
-            subscription.removeEventListener("abort", onAbort);
-        }
-    }
     // {§http-manifest}/{§http-lifecycle} Seed the declared channel shape before
     // open(); notifyChunk later welds acquired content to its actual mimetype.
     static #seedEntry() {
-        const channels = Object.fromEntries(Object.entries(_a.manifest.channels).map(([name, mimetype]) => [name, {
+        const channels = Object.fromEntries(Object.entries(Http.manifest.channels).map(([name, mimetype]) => [name, {
                 content: "",
                 mimetype,
                 state: "active",
@@ -675,17 +306,17 @@ class Http {
         const header = entry.channels[HEADER];
         if (body === undefined || header === undefined)
             return false;
-        return _a.#representationComplete(entry)
-            && _a.#requestMethod(header.content) === "GET"
+        return Http.#representationComplete(entry)
+            && Http.#requestMethod(header.content) === "GET"
             && requestHeaders.length === 0
-            && _a.#cacheVariant(header.content) === "default"
-            && !_a.#storedCachePolicy(header.content).noStore
-            && await _a.#projectionCurrent(header.content, projection);
+            && Http.#cacheVariant(header.content) === "default"
+            && !Http.#storedCachePolicy(header.content).noStore
+            && await Http.#projectionCurrent(header.content, projection);
     }
     // {§revalidation} Origin headers come first; authoritative package method
     // and acquisition metadata are appended last.
     static async #writeHeader(subscription, method, status, statusText, responseHeaders, requestHeaders) {
-        await subscription.notifyChunk(HEADER, _a.#responseHeader(method, status, statusText, responseHeaders, requestHeaders), "text/plain");
+        await subscription.notifyChunk(HEADER, Http.#responseHeader(method, status, statusText, responseHeaders, requestHeaders), "text/plain");
     }
     static #responseHeader(method, status, statusText, responseHeaders, requestHeaders) {
         const lines = [`HTTP ${status} ${statusText}`];
@@ -703,9 +334,9 @@ class Http {
     // has already returned 102, so terminal failure is durable stream state.
     static async #settleEventStream(subscription, response, options) {
         try {
-            const events = await _a.#streamEvents(subscription, response);
+            const events = await Http.#streamEvents(subscription, response);
             if (options.signal.aborted) {
-                const result = _a.#cancelled(options.url, options.method);
+                const result = Http.#cancelled(options.url, options.method);
                 await subscription.close(result, result.problem?.detail);
                 return;
             }
@@ -713,14 +344,14 @@ class Http {
         }
         catch (error) {
             if (options.signal.aborted) {
-                const result = _a.#cancelled(options.url, options.method);
+                const result = Http.#cancelled(options.url, options.method);
                 await subscription.close(result, result.problem?.detail);
                 return;
             }
             console.error("HTTP SSE stream failed", { method: options.method, url: options.url, error });
             const cause = ErrorDetail.preview(error, options.errorDetailLimit);
             const reason = `HTTP ${options.method} ${options.url} failed: ${cause}`;
-            const result = _a.#bad(502, "http", "fetch-failed", reason, {
+            const result = Http.#bad(502, "http", "fetch-failed", reason, {
                 target: options.url,
                 method: options.method,
                 stage: "transfer",
@@ -775,21 +406,21 @@ class Http {
             address = NetworkAddress.from(target);
         }
         catch {
-            return _a.#bad(400, "http", "bad-target", "HTTP operations require an http(s):// URL with an authority.", {
+            return Http.#bad(400, "http", "bad-target", "HTTP operations require an http(s):// URL with an authority.", {
                 stage: "target-validation",
                 recovery: "Provide an http(s):// URL with a host.",
                 retryable: false,
             });
         }
         if (address.scheme !== "http" && address.scheme !== "https") {
-            return _a.#bad(400, "http", "bad-target", "HTTP operations require an http(s):// URL target.", {
+            return Http.#bad(400, "http", "bad-target", "HTTP operations require an http(s):// URL target.", {
                 stage: "target-validation",
                 recovery: "Provide an http(s):// URL target.",
                 retryable: false,
             });
         }
         if (address.hasCredentials) {
-            return _a.#bad(400, "http", "userinfo-not-allowed", "HTTP URL userinfo is not allowed.", {
+            return Http.#bad(400, "http", "userinfo-not-allowed", "HTTP URL userinfo is not allowed.", {
                 target: address.url,
                 stage: "target-validation",
                 recovery: "Remove credentials from the URL and use request metadata where authorization is required.",
@@ -805,11 +436,11 @@ class Http {
         for (const [index, block] of metadata.entries()) {
             const colon = block.indexOf(":");
             if (colon < 0) {
-                return _a.#bad(400, "http", "metadata-header-shape", `HTTP metadata block ${index + 1} requires a header name and ':' separator.`, { block: index + 1, retryable: false });
+                return Http.#bad(400, "http", "metadata-header-shape", `HTTP metadata block ${index + 1} requires a header name and ':' separator.`, { block: index + 1, retryable: false });
             }
             const name = block.slice(0, colon).trim();
             if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(name)) {
-                return _a.#bad(400, "http", "metadata-header-name", `HTTP metadata block ${index + 1} has an invalid header name.`, { block: index + 1, retryable: false });
+                return Http.#bad(400, "http", "metadata-header-name", `HTTP metadata block ${index + 1} has an invalid header name.`, { block: index + 1, retryable: false });
             }
             headers.push([name, block.slice(colon + 1).trim()]);
         }
@@ -818,18 +449,18 @@ class Http {
     // {§revalidation} Validation-free reuse requires both the operator's local
     // ceiling and the origin's response policy to remain live.
     static #fresh(header, now = Date.now()) {
-        const fetchedAt = _a.#fetchedAt(header);
+        const fetchedAt = Http.#fetchedAt(header);
         const ttl = requireNumEnv("PLURNK_SCHEMES_HTTP_TTL_MS");
         if (fetchedAt === undefined || ttl <= 0)
             return false;
         const residentTime = Math.max(0, now - fetchedAt);
         if (residentTime >= ttl)
             return false;
-        const policy = _a.#storedCachePolicy(header);
+        const policy = Http.#storedCachePolicy(header);
         if (policy.noStore || policy.noCache)
             return false;
         return policy.freshnessLifetimeMs === undefined
-            || _a.#currentAge(header, fetchedAt, now) < policy.freshnessLifetimeMs;
+            || Http.#currentAge(header, fetchedAt, now) < policy.freshnessLifetimeMs;
     }
     // Package metadata is appended after origin headers, so the last value wins.
     static #fetchedAt(priorHeader) {
@@ -851,27 +482,27 @@ class Http {
     static #packageStart(lines) {
         let stampIndex = -1;
         for (const [index, line] of lines.entries()) {
-            if (_a.#headerField(line)?.name === FETCHED_AT)
+            if (Http.#headerField(line)?.name === FETCHED_AT)
                 stampIndex = index;
         }
         if (stampIndex < 0)
             return lines.length;
-        return _a.#headerField(lines[stampIndex - 1] ?? "")?.name === REQUEST_METHOD
+        return Http.#headerField(lines[stampIndex - 1] ?? "")?.name === REQUEST_METHOD
             ? stampIndex - 1
             : stampIndex;
     }
     static #originFields(header) {
         const lines = header.split(/\r?\n/);
-        return lines.slice(1, _a.#packageStart(lines))
-            .map((line) => _a.#headerField(line))
+        return lines.slice(1, Http.#packageStart(lines))
+            .map((line) => Http.#headerField(line))
             .filter((field) => field !== null);
     }
     static #originValues(fields, name) {
         return fields.filter((field) => field.name === name).map(({ value }) => value);
     }
     static #storedCachePolicy(header) {
-        const fields = _a.#originFields(header);
-        const directives = _a.#originValues(fields, "cache-control")
+        const fields = Http.#originFields(header);
+        const directives = Http.#originValues(fields, "cache-control")
             .flatMap((value) => splitHttpList(value))
             .map((member) => cacheDirective(member))
             .filter((directive) => directive !== null);
@@ -883,17 +514,17 @@ class Http {
                 : 0;
         }
         else {
-            const expiresValues = _a.#originValues(fields, "expires");
+            const expiresValues = Http.#originValues(fields, "expires");
             if (expiresValues.length > 0) {
                 const expires = expiresValues.length === 1
                     ? httpDate(expiresValues[0])
                     : null;
-                const fetchedAt = _a.#fetchedAt(header);
+                const fetchedAt = Http.#fetchedAt(header);
                 if (expires === null || fetchedAt === undefined) {
                     freshnessLifetimeMs = 0;
                 }
                 else {
-                    const dateValues = _a.#originValues(fields, "date");
+                    const dateValues = Http.#originValues(fields, "date");
                     const parsedDate = dateValues.length === 1
                         ? httpDate(dateValues[0])
                         : null;
@@ -909,11 +540,11 @@ class Http {
         };
     }
     static #currentAge(header, fetchedAt, now) {
-        const fields = _a.#originFields(header);
-        const dateValues = _a.#originValues(fields, "date");
+        const fields = Http.#originFields(header);
+        const dateValues = Http.#originValues(fields, "date");
         const date = dateValues.length === 1 ? httpDate(dateValues[0]) : null;
         const apparentAge = date === null ? 0 : Math.max(0, fetchedAt - date);
-        const ageMember = _a.#originValues(fields, "age").flatMap(splitHttpList)[0];
+        const ageMember = Http.#originValues(fields, "age").flatMap(splitHttpList)[0];
         const ageValue = deltaMilliseconds(ageMember) ?? 0;
         return Math.max(apparentAge, ageValue) + Math.max(0, now - fetchedAt);
     }
@@ -945,22 +576,22 @@ class Http {
         return value === "" ? undefined : value;
     }
     static #projectionIdentity(priorHeader) {
-        return _a.#packageHeaderValue(priorHeader, PROJECTION_ID_HEADER);
+        return Http.#packageHeaderValue(priorHeader, PROJECTION_ID_HEADER);
     }
     static #materializerIdentity(priorHeader) {
-        return _a.#packageHeaderValue(priorHeader, MATERIALIZER_ID_HEADER);
+        return Http.#packageHeaderValue(priorHeader, MATERIALIZER_ID_HEADER);
     }
     static #cacheVariant(priorHeader) {
-        const value = _a.#packageHeaderValue(priorHeader, CACHE_VARIANT_HEADER);
+        const value = Http.#packageHeaderValue(priorHeader, CACHE_VARIANT_HEADER);
         return value === "default" || value === "bypass" ? value : undefined;
     }
     static #sourceMimetype(header) {
         return responseMimetype(lastHeaderValue(header, "content-type") ?? null);
     }
     static async #projectionCurrent(header, projection) {
-        const sourceMimetype = _a.#sourceMimetype(header);
+        const sourceMimetype = Http.#sourceMimetype(header);
         const isHtml = MimetypeClassifier.isHtml(sourceMimetype);
-        const materializerIdentity = _a.#materializerIdentity(header);
+        const materializerIdentity = Http.#materializerIdentity(header);
         if (materializerIdentity !== undefined) {
             // {§http-materializer-plugins} — a stored body produced by the current
             // configured materializer (or the built-in producers) is current.
@@ -968,7 +599,7 @@ class Http {
         }
         if (isHtml && materializerIdentity === undefined)
             return false;
-        const storedIdentity = _a.#projectionIdentity(header);
+        const storedIdentity = Http.#projectionIdentity(header);
         if (storedIdentity === undefined)
             return !isHtml;
         return await projection.identity(sourceMimetype) === storedIdentity;
@@ -978,7 +609,7 @@ class Http {
     // evidence is then rebuilt after the origin block. {§revalidation}
     static #refreshAfter304(header, responseHeaders, requestHeaders) {
         const lines = header.split(/\r?\n/);
-        const origin = _a.#originFields(header);
+        const origin = Http.#originFields(header);
         const updates = responseHeaders.filter(([name]) => !BODY_PROCESSING_FIELDS.has(name.toLowerCase()));
         const updatedNames = new Set(updates.map(([name]) => name.toLowerCase()));
         const retained = origin.filter(({ name }) => !updatedNames.has(name));
@@ -992,7 +623,7 @@ class Http {
         // x-plurnk-* fields (cache-variant, materializer/projection ids, method,
         // fetched-at stamp) are rebuilt or omitted, never duplicated stale.
         const rebuilt = [MATERIALIZER_ID_HEADER, PROJECTION_ID_HEADER].flatMap((field) => {
-            const value = _a.#packageHeaderValue(header, field);
+            const value = Http.#packageHeaderValue(header, field);
             return value === undefined ? [] : [`${field}: ${value}`];
         });
         const frameworkOwned = new Set([
@@ -1025,10 +656,10 @@ class Http {
         ].join("\n");
     }
     static #revalidationCorresponds(priorHeader, responseHeaders) {
-        const fields = _a.#originFields(priorHeader);
+        const fields = Http.#originFields(priorHeader);
         const responseTagValue = responseHeaders.get("etag");
         if (responseTagValue !== null) {
-            const storedTagValues = _a.#originValues(fields, "etag");
+            const storedTagValues = Http.#originValues(fields, "etag");
             const responseTag = entityTag(responseTagValue);
             const storedTag = storedTagValues.length === 1
                 ? entityTag(storedTagValues[0])
@@ -1042,7 +673,7 @@ class Http {
             return responseTag.opaque === storedTag.opaque;
         }
         const responseModifiedValue = responseHeaders.get("last-modified");
-        const storedModifiedValues = _a.#originValues(fields, "last-modified");
+        const storedModifiedValues = Http.#originValues(fields, "last-modified");
         const responseModified = responseModifiedValue === null
             ? null
             : httpDate(responseModifiedValue);
@@ -1058,13 +689,13 @@ class Http {
     // Last-Modified → If-Modified-Since. Empty when neither is present — the
     // origin then just 200s with a full body, which is correct.
     static #validators(priorHeader) {
-        const fields = _a.#originFields(priorHeader);
+        const fields = Http.#originFields(priorHeader);
         const out = [];
-        const etags = _a.#originValues(fields, "etag");
+        const etags = Http.#originValues(fields, "etag");
         if (etags.length === 1 && entityTag(etags[0]) !== null) {
             out.push(["If-None-Match", etags[0]]);
         }
-        const lastModified = _a.#originValues(fields, "last-modified");
+        const lastModified = Http.#originValues(fields, "last-modified");
         if (lastModified.length === 1 && httpDate(lastModified[0]) !== null) {
             out.push(["If-Modified-Since", lastModified[0]]);
         }
@@ -1074,7 +705,7 @@ class Http {
         return Results.assertChannelProducerResult({ ...result, shape: "passthrough" });
     }
     static #cancelled(url, method) {
-        return _a.#bad(499, "http", "cancelled", `HTTP ${method} ${url} was cancelled.`, {
+        return Http.#bad(499, "http", "cancelled", `HTTP ${method} ${url} was cancelled.`, {
             target: url,
             method,
             stage: "acquisition",
@@ -1083,7 +714,7 @@ class Http {
     }
     static #materializationFailure(url, method, error) {
         if (error.stage === "projection" && error.cause instanceof ProjectionInputLimitError) {
-            return _a.#bad(413, "http", "projection-input-limit", `HTTP ${method} ${url} exceeded the ${error.cause.maximumBytes}-byte readable-projection input limit.`, {
+            return Http.#bad(413, "http", "projection-input-limit", `HTTP ${method} ${url} exceeded the ${error.cause.maximumBytes}-byte readable-projection input limit.`, {
                 target: url,
                 method,
                 mimetype: error.cause.mimetype,
@@ -1094,7 +725,7 @@ class Http {
             });
         }
         console.error("HTTP materialization failed", { method, url, error });
-        return _a.#bad(500, "http", "projection-failed", `HTTP ${method} ${url} acquired content, but its readable projection failed.`, {
+        return Http.#bad(500, "http", "projection-failed", `HTTP ${method} ${url} acquired content, but its readable projection failed.`, {
             target: url,
             method,
             mimetype: error.mimetype,
@@ -1106,6 +737,4 @@ class Http {
         return Results.failure(`scheme:${scheme}`, kind, status, message, { shape: "passthrough" }, extensions);
     }
 }
-_a = Http;
-export default Http;
 //# sourceMappingURL=Http.js.map