@plurnk/plurnk-schemes-http 1.4.0 → 1.6.0

package/dist/Http.js

@@ -3,12 +3,12 @@
 // {§http-lifecycle}. The implementation depends only on SchemeCtx capabilities.
 var _a;
 import { createParser } from "eventsource-parser";
-import { MimetypeClassifier, NetworkAddress, PathSyntax, ProjectionInputLimitError, Results, } from "@plurnk/plurnk-schemes";
+import { MimetypeClassifier, NetworkAddress, ProjectionInputLimitError, Results, } from "@plurnk/plurnk-schemes";
 import { readFile } from "node:fs/promises";
-import Browser, { BROWSER_UA, requireNumEnv } from "./Browser.js";
 import ErrorDetail from "./ErrorDetail.js";
-import WebFetcher, { CACHE_VARIANT_HEADER, PROJECTION_ID_HEADER, cacheVariantEvidence, classifyCacheVariant, rewriteAcquisitionTarget, WebMaterializationError, } from "./WebFetcher.js";
+import WebFetcher, { DEFAULT_WEB_UA, CACHE_VARIANT_HEADER, MATERIALIZER_ID_HEADER, PROJECTION_ID_HEADER, TAVILY_CREDITS_HEADER, TAVILY_REQUEST_ID_HEADER, cacheVariantEvidence, classifyCacheVariant, WebMaterializationError, } from "./WebFetcher.js";
 import { responseMimetype } from "./ContentType.js";
+import { requireNonNegativeIntegerEnv as requireNumEnv } from "./Config.js";
 // The channel the response body streams into, and the header metadata channel.
 const BODY = "body";
 const HEADER = "header";
@@ -150,80 +150,93 @@ class Http {
         volatile: true, // remote content can change between fetches
         modelVisible: true,
         glyph: "🌐",
-        example: "<<READ(https://example.com/page)::READ",
+        example: [
+            "## READ0 (https://example.com/page)",
+            "",
+            "## 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})",
+            '{"name":"Mango","status":"available"}',
+        ].join("\n"),
         documentation,
         flags: {
             requiresWeb: true, // excluded under the loop's noWeb flag
         },
     };
-    // The render foundation (lazy chromium). Injectable for tests; one warm
-    // pool per Http instance, shared across this scheme's fetches.
-    #browser;
     #errorDetailLimit;
     #webFetcher;
-    constructor(browser = new Browser()) {
-        this.#browser = browser;
+    constructor() {
         this.#errorDetailLimit = ErrorDetail.configuredLimit();
-        this.#webFetcher = new WebFetcher(browser);
+        this.#webFetcher = new WebFetcher();
     }
     async ready() {
-        const mode = await this.#browser.ready?.();
-        if (mode !== undefined)
-            console.info(`http renderer: ${mode}`);
-    }
-    async close() {
-        await this.#webFetcher.close();
-    }
-    // FIND itself is the consumer's standard entry query. This hook owns only
-    // HTTP's prerequisite: an exact URL that is not already an entry must be
-    // acquired through the same checked byte and lazy-render path used by search
-    // prefetch. Glob targets only query already-known web entries.
-    async prepareFind(statement, ctx) {
-        const target = statement.target;
-        if (target === null || target.kind !== "url")
-            return { shape: "passthrough", status: 200 };
+        WebFetcher.validateConfiguration();
+    }
+    // Representation preparation is scope-blind. Core applies the authored READ
+    // coordinates only after this hook has either materialized a finite GET or
+    // 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.", {
+                stage: "target-validation",
+                recovery: "Provide an http(s):// URL target.",
+                retryable: false,
+            });
+        }
+        return this.#prepareGet(request.target, request.pathname, ctx);
+    }
+    async #prepareGet(target, pathname, ctx) {
         const address = _a.#address(target);
         if (!(address instanceof NetworkAddress))
             return address;
-        const { pathname, url } = address;
+        const { url } = address;
         const requestHeaders = target.headers ?? [];
-        if (PathSyntax.hasGlob(target.pathname))
-            return { shape: "passthrough", status: 200 };
+        let cached;
+        const conditional = [];
         const prior = await ctx.entries.read(pathname);
-        if (prior.entry !== null) {
-            const priorHeader = prior.entry.channels[HEADER]?.content ?? "";
-            const priorMethod = _a.#requestMethod(priorHeader);
-            if (priorMethod === undefined) {
-                return { shape: "passthrough", status: 200 };
-            }
-            let reusable;
+        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 {
-                reusable = await _a.#reusableGetRepresentation(prior.entry, requestHeaders, ctx.projection);
+                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("projection", _a.#sourceMimetype(priorHeader), cause));
-            }
-            if (reusable && _a.#fresh(priorHeader)) {
-                return { shape: "passthrough", status: 200 };
+                return _a.#materializationFailure(url, "GET", new WebMaterializationError(_a.#sourceMimetype(priorHeader.content), cause));
             }
         }
-        if (Results.isErrorStatus(prior.status) && prior.status !== 404) {
-            return _a.#passthrough(prior);
+        if (cached !== undefined && _a.#fresh(cached.channels[HEADER].content)) {
+            return { status: 200 };
         }
-        // {§prefetch} WebFetcher preserves caller cancellation as rejection;
-        // this operation owns its one model-facing 499 projection.
         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 (err) {
-            if (ctx.signal?.aborted === true && err === ctx.signal.reason) {
+        catch (error) {
+            if (ctx.signal?.aborted === true && error === ctx.signal.reason) {
                 return _a.#cancelled(url, "GET");
             }
-            throw err;
+            throw error;
         }
         if (fetched === null) {
             return _a.#bad(404, "http", "not-materialized", `The URL ${url} could not be materialized.`, {
@@ -232,48 +245,109 @@ class Http {
                 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])))) {
+                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,
+                });
+            }
+            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 };
+        }
+        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);
+            materialized = await WebFetcher.materialize(fetched, ctx.projection, ctx.signal);
         }
-        catch (err) {
+        catch (error) {
             if (ctx.signal?.aborted === true)
                 return _a.#cancelled(url, "GET");
-            if (err instanceof WebMaterializationError) {
-                return _a.#materializationFailure(url, "GET", err);
+            if (error instanceof WebMaterializationError) {
+                return _a.#materializationFailure(url, "GET", error);
             }
-            throw err;
-        }
-        if (materialized === null)
-            return _a.#noReadableProjection(url);
-        const channels = {
-            [BODY]: materialized.body,
-            ...(materialized.html === undefined ? {} : { html: materialized.html }),
-            ...(materialized.header === undefined
-                ? {}
-                : { [HEADER]: { content: materialized.header, mimetype: "text/plain" } }),
-        };
-        const written = await ctx.entries.write(pathname, { channels, tags: [] });
-        return _a.#passthrough(written);
-    }
-    // An unscoped READ fetches/revalidates. A scoped READ observes its selected
-    // already-materialized channel through universal READ: refetching would
-    // discard the requested range and return another asynchronous whole-body 102.
-    async read(statement, ctx) {
-        if (statement.target === null || statement.target.kind !== "url") {
-            return _a.#bad(400, "http", "bad-target", "READ requires an http(s):// URL target.", {
-                stage: "target-validation",
-                recovery: "Provide an http(s):// URL target.",
+            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,
             });
         }
-        if (statement.lineMarker !== null) {
-            const address = _a.#address(statement.target);
-            if (!(address instanceof NetworkAddress))
-                return address;
-            return _a.#passthrough(await ctx.entries.operations.read(statement));
+        const written = await ctx.entries.write(pathname, {
+            channels: WebFetcher.materializedChannels(materialized, { url, method: "GET" }),
+        });
+        if (Results.isErrorStatus(written.status))
+            return _a.#passthrough(written);
+        return { status: 200 };
+    }
+    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.");
         }
-        return this.#fetchStream(statement.target, ctx, "GET", undefined);
+        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 };
     }
     // EDIT -> PUT the body (full-resource replace). `<L>` has no meaning against a
     // remote resource - reject rather than silently ignore the model's intent.
@@ -301,12 +375,12 @@ class Http {
                 retryable: false,
             });
         }
-        return this.#fetchStream(statement.target, ctx, "PUT", statement.body ?? "");
+        return this.#request(statement.target, ctx, "PUT", statement.body ?? "");
     }
     async edit(statement, ctx) {
         return this.editBatch([statement], ctx);
     }
-    // KILL -> DELETE the resource. Distinct from SEND[410] (which drops the local
+    // KILL -> DELETE the resource. Distinct from SEND signal 410 (which drops the local
     // cached entry): KILL is an HTTP DELETE request to the remote.
     async kill(statement, ctx) {
         if (statement.target === null || statement.target.kind !== "url") {
@@ -316,7 +390,7 @@ class Http {
                 retryable: false,
             });
         }
-        return this.#fetchStream(statement.target, ctx, "DELETE", statement.body ?? undefined);
+        return this.#request(statement.target, ctx, "DELETE", statement.body ?? undefined);
     }
     // SEND dispatch — status-code-as-verb (SPEC {§op-surface}).
     //   200 -> request with body (POST), stream response
@@ -335,7 +409,7 @@ class Http {
         const status = statement.signal;
         if (status === 200) {
             const body = statement.body?.raw ?? "";
-            return this.#fetchStream(statement.target, ctx, "POST", body);
+            return this.#request(statement.target, ctx, "POST", body);
         }
         if (status === 410) {
             const address = _a.#address(statement.target);
@@ -345,7 +419,7 @@ class Http {
         }
         if (status === 499) {
             // Cancellation is routed by the engine to the subscription's
-            // SubscriptionHandle.cancel (registered in #fetchStream). Nothing
+            // SubscriptionHandle.cancel (registered by #request). Nothing
             // for the scheme to do at the op level.
             return { shape: "passthrough", status: 200 };
         }
@@ -356,13 +430,14 @@ class Http {
             retryable: false,
         });
     }
-    // {§http-lifecycle} One direct-operation path owns seeding,
-    // subscription cancellation, response materialization, and settlement.
-    async #fetchStream(target, ctx, method, body) {
+    // Mutation responses use the same entry/channel and subscription primitives
+    // as every live producer; GET acquisition belongs solely to
+    // prepareRepresentation.
+    async #request(target, ctx, method, body) {
         const address = _a.#address(target);
         if (!(address instanceof NetworkAddress))
             return address;
-        const url = method === "GET" ? rewriteAcquisitionTarget(address.url) : address.url;
+        const { url } = address;
         const { pathname } = address;
         const headers = target.headers ?? [];
         const publishedChannel = target.fragment ?? _a.manifest.defaultChannel;
@@ -375,49 +450,7 @@ class Http {
                 retryable: false,
             });
         }
-        // {§revalidation} — recover only a GET-marked representation and its
-        // validators before the seed write replaces the stored channels.
-        let cached;
-        const conditional = [];
-        if (method === "GET") {
-            const prior = await ctx.entries.read(pathname);
-            if (Results.isErrorStatus(prior.status) && prior.status !== 404) {
-                return _a.#passthrough(prior);
-            }
-            const pb = prior.entry?.channels[BODY];
-            const ph = prior.entry?.channels[HEADER];
-            if (prior.entry !== null && pb !== undefined && ph !== undefined) {
-                try {
-                    if (await _a.#reusableGetRepresentation(prior.entry, headers, ctx.projection)) {
-                        const html = prior.entry.channels.html;
-                        cached = {
-                            header: ph.content,
-                            body: { content: pb.content, mimetype: pb.mimetype },
-                            ...(html === undefined || html.content.length === 0 ? {} : { html: { content: html.content, mimetype: html.mimetype } }),
-                        };
-                        conditional.push(..._a.#validators(ph.content));
-                    }
-                }
-                catch (cause) {
-                    return _a.#materializationFailure(url, method, new WebMaterializationError("projection", _a.#sourceMimetype(ph.content), cause));
-                }
-            }
-        }
-        // {§revalidation} TTL fast path. Serving does not refresh the stamp;
-        // only a network acquisition or 304 vouches for a new acquisition time.
-        if (cached !== undefined && _a.#fresh(cached.header)) {
-            const written = await ctx.entries.write(pathname, _a.#seedEntry());
-            if (Results.isErrorStatus(written.status))
-                return _a.#passthrough(written);
-            const subscription = await ctx.subscriptions.open(pathname, { cancel: () => { } }, { publishedChannel });
-            await subscription.notifyChunk(HEADER, cached.header, "text/plain");
-            if (cached.html !== undefined)
-                await subscription.notifyChunk("html", cached.html.content, cached.html.mimetype);
-            await subscription.notifyChunk(BODY, cached.body.content, cached.body.mimetype);
-            await subscription.close({ status: 200 }, `ttl-fresh; ${cached.body.content.length} chars from cache`);
-            return { shape: "passthrough", status: 102 };
-        }
-        // Local AbortController for force-cancel from outside (SEND[499]).
+        // 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
@@ -426,94 +459,21 @@ class Http {
         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 the fetch/render.
-        const subscription = await ctx.subscriptions.open(pathname, handle, { publishedChannel });
+        // 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 });
-        let detached = false;
         try {
             const response = await fetch(url, {
                 method,
                 body,
-                // One browser identity on the wire (never Node's default "node"
-                // UA — a loud automated-client fingerprint). The model's own
-                // {User-Agent: …} block wins when present.
                 headers: headers.some(([k]) => k.toLowerCase() === "user-agent")
-                    ? [...headers, ...conditional]
-                    : [["User-Agent", BROWSER_UA], ...headers, ...conditional],
+                    ? headers
+                    : [["User-Agent", DEFAULT_WEB_UA], ...headers],
                 signal: local.signal,
                 redirect: "follow",
             });
-            // {§revalidation} A corresponding 304 restores the nominated GET
-            // representation into the freshly seeded channels and remains an
-            // ordinary streaming READ.
-            if (cached !== undefined && response.status === 304) {
-                if (!_a.#revalidationCorresponds(cached.header, response.headers)) {
-                    throw new Error("HTTP 304 did not identify the stored representation nominated for revalidation.");
-                }
-                await subscription.notifyChunk(HEADER, _a.#refreshAfter304(cached.header, [...response.headers], headers), "text/plain");
-                if (cached.html !== undefined)
-                    await subscription.notifyChunk("html", cached.html.content, cached.html.mimetype);
-                await subscription.notifyChunk(BODY, cached.body.content, cached.body.mimetype);
-                await subscription.close({ status: 200 }, `revalidated 304; ${cached.body.content.length} chars from cache`);
-                return { shape: "passthrough", status: 102 };
-            }
             const responseMime = responseMimetype(response.headers.get("content-type"));
-            // Always-render: a GET of an HTML page is re-acquired through the
-            // browser so the body is projected from the final rendered DOM. The probe-fetch
-            // body is discarded — the browser does its own navigation. Only GET
-            // renders; POST/PUT/DELETE can't be replayed as a browser navigation.
-            const isHtml = method === "GET" && MimetypeClassifier.isHtml(responseMime);
-            if (isHtml) {
-                await response.body?.cancel();
-                let result;
-                try {
-                    result = await this.#browser.render(url, {
-                        workerId: ctx.workerId,
-                        signal: local.signal,
-                        headers,
-                    });
-                }
-                catch (cause) {
-                    throw new WebMaterializationError("render", responseMime, cause);
-                }
-                await _a.#writeHeader(subscription, method, result.status, result.statusText, result.headers, headers);
-                await subscription.notifyChunk("html", result.html, "text/html");
-                const materialized = await WebFetcher.materialize({ body: result.html, mimetype: "text/html" }, ctx.projection);
-                if (materialized === null) {
-                    const failure = _a.#noReadableProjection(url);
-                    await subscription.close(failure, failure.problem?.detail);
-                    return failure;
-                }
-                if (materialized.projection !== undefined) {
-                    await _a.#writeProjectionIdentity(subscription, materialized.projection.identity);
-                }
-                await subscription.notifyChunk(BODY, materialized.body.content, materialized.body.mimetype);
-                await subscription.close({ status: 200 }, `rendered HTTP ${result.status}; ${materialized.body.content.length} readable chars`);
-                return { shape: "passthrough", status: 102 };
-            }
-            // SSE: an event stream is parsed into its `data` payloads (SPEC {§sse}),
-            // one notifyChunk per event with the `data:`/comment framing stripped,
-            // so the model reads event content and not the transport. A long-lived
-            // GET; events land in the body channel as they arrive across turns,
-            // until the origin closes. Only GET — a POST reply is never an SSE READ.
-            if (method === "GET" && responseMime === "text/event-stream") {
-                await _a.#writeHeader(subscription, method, response.status, response.statusText, [...response.headers], headers);
-                if (response.body === null) {
-                    await subscription.close({ status: 200 }, "SSE stream; empty body");
-                    return { shape: "passthrough", status: 102 };
-                }
-                detached = true;
-                void _a.#settleEventStream(subscription, response, {
-                    url,
-                    method,
-                    signal: local.signal,
-                    errorDetailLimit: this.#errorDetailLimit,
-                }).catch((error) => {
-                    console.error("HTTP SSE terminal cleanup failed", { url, error });
-                }).finally(() => subscription.removeEventListener("abort", onAbort));
-                return { shape: "passthrough", status: 102 };
-            }
             // {§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
@@ -599,8 +559,7 @@ class Http {
             return result;
         }
         finally {
-            if (!detached)
-                subscription.removeEventListener("abort", onAbort);
+            subscription.removeEventListener("abort", onAbort);
         }
     }
     // {§http-manifest}/{§http-lifecycle} Seed the declared channel shape before
@@ -611,13 +570,18 @@ class Http {
                 mimetype,
                 state: "active",
             }]));
-        return { channels, tags: [] };
+        return { channels };
     }
-    // {§revalidation} `static` exact materializations and successfully `closed`
-    // streams are final. Active or failed channels cannot vouch for a reusable
-    // representation, regardless of whether partial content is non-empty.
+    // {§revalidation} The body and header must have settled successfully. An
+    // auxiliary channel may have terminally failed without invalidating body.
     static #representationComplete(entry) {
-        return Object.values(entry.channels).every(({ state }) => state === "static" || state === "closed");
+        const bodyState = entry.channels[BODY]?.state;
+        const headerState = entry.channels[HEADER]?.state;
+        const successful = (state) => state === "static" || state === "closed";
+        const terminal = (state) => successful(state) || state === "errored";
+        return successful(bodyState)
+            && successful(headerState)
+            && Object.values(entry.channels).every(({ state }) => terminal(state));
     }
     // {§revalidation} Direct READ and exact FIND share the complete reusable
     // representation predicate; freshness only decides how READ uses a match.
@@ -636,13 +600,16 @@ class Http {
     // {§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");
+    }
+    static #responseHeader(method, status, statusText, responseHeaders, requestHeaders) {
         const lines = [`HTTP ${status} ${statusText}`];
         for (const [k, v] of responseHeaders)
             lines.push(`${k}: ${v}`);
         lines.push(`${REQUEST_METHOD}: ${method}`);
         lines.push(`${FETCHED_AT}: ${new Date().toISOString()}`);
         lines.push(cacheVariantEvidence(classifyCacheVariant(requestHeaders, responseHeaders)));
-        await subscription.notifyChunk(HEADER, lines.join("\n"), "text/plain");
+        return lines.join("\n");
     }
     static async #writeProjectionIdentity(subscription, identity) {
         await subscription.notifyChunk(HEADER, `\n${WebFetcher.projectionEvidence(identity)}`, "text/plain");
@@ -652,6 +619,11 @@ class Http {
     static async #settleEventStream(subscription, response, options) {
         try {
             const events = await _a.#streamEvents(subscription, response);
+            if (options.signal.aborted) {
+                const result = _a.#cancelled(options.url, options.method);
+                await subscription.close(result, result.problem?.detail);
+                return;
+            }
             await subscription.close({ status: 200 }, `SSE stream; ${events} events`);
         }
         catch (error) {
@@ -873,6 +845,9 @@ class Http {
     static #projectionIdentity(priorHeader) {
         return _a.#packageHeaderValue(priorHeader, PROJECTION_ID_HEADER);
     }
+    static #materializerIdentity(priorHeader) {
+        return _a.#packageHeaderValue(priorHeader, MATERIALIZER_ID_HEADER);
+    }
     static #cacheVariant(priorHeader) {
         const value = _a.#packageHeaderValue(priorHeader, CACHE_VARIANT_HEADER);
         return value === "default" || value === "bypass" ? value : undefined;
@@ -881,10 +856,22 @@ class Http {
         return responseMimetype(lastHeaderValue(header, "content-type") ?? null);
     }
     static async #projectionCurrent(header, projection) {
+        const sourceMimetype = _a.#sourceMimetype(header);
+        const isHtml = MimetypeClassifier.isHtml(sourceMimetype);
+        const materializerIdentity = _a.#materializerIdentity(header);
+        if (materializerIdentity !== undefined) {
+            if (!WebFetcher.materializerCurrent(materializerIdentity))
+                return false;
+            if (materializerIdentity.startsWith("tavily-extract:")
+                || materializerIdentity === "origin-markdown:v1")
+                return true;
+        }
+        if (isHtml && materializerIdentity === undefined)
+            return false;
         const storedIdentity = _a.#projectionIdentity(header);
         if (storedIdentity === undefined)
-            return true;
-        return await projection.identity(_a.#sourceMimetype(header)) === storedIdentity;
+            return !isHtml;
+        return await projection.identity(sourceMimetype) === storedIdentity;
     }
     // RFC 9111 §3.2 permits a processed cache to retain the metadata that its
     // stored body depends upon. Other 304 fields update by name; package-owned
@@ -899,7 +886,15 @@ class Http {
             ...retained.map(({ name, value }) => [name, value]),
             ...updates,
         ];
-        const projectionIdentity = _a.#projectionIdentity(header);
+        const packageEvidence = [
+            MATERIALIZER_ID_HEADER,
+            PROJECTION_ID_HEADER,
+            TAVILY_REQUEST_ID_HEADER,
+            TAVILY_CREDITS_HEADER,
+        ].flatMap((field) => {
+            const value = _a.#packageHeaderValue(header, field);
+            return value === undefined ? [] : [`${field}: ${value}`];
+        });
         return [
             lines[0] ?? "HTTP 200 OK",
             ...retained.map(({ line }) => line),
@@ -907,9 +902,7 @@ class Http {
             `${REQUEST_METHOD}: GET`,
             `${FETCHED_AT}: ${new Date().toISOString()}`,
             cacheVariantEvidence(classifyCacheVariant(requestHeaders, merged)),
-            ...(projectionIdentity === undefined
-                ? []
-                : [WebFetcher.projectionEvidence(projectionIdentity)]),
+            ...packageEvidence,
         ].join("\n");
     }
     static #revalidationCorresponds(priorHeader, responseHeaders) {
@@ -979,20 +972,10 @@ class Http {
             });
         }
         console.error("HTTP materialization failed", { method, url, error });
-        const projection = error.stage === "projection";
-        return _a.#bad(projection ? 500 : 502, "http", projection ? "projection-failed" : "render-failed", projection
-            ? `HTTP ${method} ${url} acquired content, but its readable projection failed.`
-            : `HTTP ${method} ${url} could not render HTML.`, {
+        return _a.#bad(500, "http", "projection-failed", `HTTP ${method} ${url} acquired content, but its readable projection failed.`, {
             target: url,
             method,
             mimetype: error.mimetype,
-            stage: error.stage,
-            retryable: !projection,
-        });
-    }
-    static #noReadableProjection(url) {
-        return _a.#bad(422, "http", "no-readable-projection", `The URL ${url} has no readable projection.`, {
-            target: url,
             stage: "projection",
             retryable: false,
         });