monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/source-store/lib/addresses.js

@@ -0,0 +1,91 @@
+// The addresses the safety floor refuses to connect to (§17 Safety floor: Addresses).
+import { isIPv4, isIPv6 } from 'node:net';
+/** Refused IPv4 ranges. A single cloud-metadata address comes before the range that holds it, so that it is named. */
+const refused4 = [
+    [ipv4('169.254.169.254'), 32, 'cloud-metadata'],
+    [ipv4('100.100.100.200'), 32, 'cloud-metadata'],
+    [ipv4('168.63.129.16'), 32, 'cloud-metadata'],
+    [ipv4('192.0.0.192'), 32, 'cloud-metadata'],
+    [ipv4('0.0.0.0'), 8, 'unspecified'],
+    [ipv4('127.0.0.0'), 8, 'loopback'],
+    [ipv4('10.0.0.0'), 8, 'private'],
+    [ipv4('172.16.0.0'), 12, 'private'],
+    [ipv4('192.168.0.0'), 16, 'private'],
+    [ipv4('169.254.0.0'), 16, 'link-local'],
+    [ipv4('100.64.0.0'), 10, 'carrier-grade NAT'],
+    [ipv4('224.0.0.0'), 4, 'multicast'],
+    [ipv4('255.255.255.255'), 32, 'broadcast'],
+];
+/**
+ * Why the floor refuses to connect to `address`, as the kind of address it is, or null when it doesn't. Refused:
+ * loopback, private, link-local, unique-local, carrier-grade NAT, multicast, cloud-metadata and unspecified addresses,
+ * and an IPv6 address that carries a refused IPv4 one (IPv4-mapped, IPv4-compatible, NAT64 or 6to4).
+ */
+export function refusedAddress(scoped) {
+    // A link-local IPv6 address may carry a zone (`fe80::1%en0`).
+    const address = scoped.replace(/%.*$/, '');
+    if (isIPv4(address))
+        return refused4Of(ipv4(address));
+    if (!isIPv6(address))
+        return 'not an IP';
+    const words = ipv6(address);
+    const all = (from, to, value) => words.slice(from, to).every((word) => word === value);
+    const embedded = (high, low) => (((words[high] << 16) | words[low]) >>> 0);
+    if (all(0, 8, 0))
+        return 'unspecified';
+    if (all(0, 7, 0) && words[7] === 1)
+        return 'loopback';
+    // An IPv4 address in IPv6 form: IPv4-mapped (::ffff:0:0/96), IPv4-compatible (::/96), NAT64 (64:ff9b::/96) and
+    // 6to4 (2002::/16).
+    const carried = all(0, 5, 0) && words[5] === 0xffff
+        ? ['IPv4-mapped', embedded(6, 7)]
+        : all(0, 6, 0)
+            ? ['IPv4-compatible', embedded(6, 7)]
+            : words[0] === 0x64 && words[1] === 0xff9b && all(2, 6, 0)
+                ? ['NAT64', embedded(6, 7)]
+                : words[0] === 0x2002
+                    ? ['6to4', embedded(1, 2)]
+                    : null;
+    if (carried !== null) {
+        const inner = refused4Of(carried[1]);
+        return inner === null ? null : `${carried[0]} ${inner}`;
+    }
+    const first = words[0];
+    if (first === 0xfd00 && words[1] === 0x0ec2 && all(2, 7, 0) && words[7] === 0x254)
+        return 'cloud-metadata';
+    if ((first & 0xfe00) === 0xfc00)
+        return 'unique-local';
+    if ((first & 0xffc0) === 0xfe80)
+        return 'link-local';
+    if ((first & 0xffc0) === 0xfec0)
+        return 'site-local';
+    if ((first & 0xff00) === 0xff00)
+        return 'multicast';
+    return null;
+}
+function refused4Of(value) {
+    for (const [first, prefix, name] of refused4) {
+        const mask = prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0;
+        if (((value & mask) >>> 0) === first)
+            return name;
+    }
+    return null;
+}
+/** A dotted-quad IPv4 address as a 32-bit number. */
+function ipv4(address) {
+    return address.split('.').reduce((value, part) => ((value << 8) | Number(part)) >>> 0, 0);
+}
+/** An IPv6 address as its eight 16-bit words. A trailing dotted quad is two words. */
+function ipv6(address) {
+    const quad = /(\d+\.\d+\.\d+\.\d+)$/.exec(address);
+    let text = address;
+    if (quad !== null) {
+        const value = ipv4(quad[1]);
+        text = `${address.slice(0, quad.index)}${(value >>> 16).toString(16)}:${(value & 0xffff).toString(16)}`;
+    }
+    const [head = '', tail] = text.split('::');
+    const parse = (part) => (part === '' ? [] : part.split(':').map((word) => parseInt(word, 16)));
+    const [before, after] = [parse(head), parse(tail ?? '')];
+    const zeros = tail === undefined ? [] : new Array(8 - before.length - after.length).fill(0);
+    return [...before, ...zeros, ...after];
+}

package/dist/packages/source-store/lib/connection.d.ts

@@ -0,0 +1,15 @@
+import type { Duplex } from 'node:stream';
+import type { Sockets } from './deadline.ts';
+import type { SessionOptions } from './session.ts';
+type ConnectionOptions = Pick<SessionOptions, 'lookup' | 'connect' | 'ca' | 'env'>;
+/**
+ * Opens a connection to the URL's host: a TCP connection, with verified TLS over it for `https:`. The host's addresses
+ * are resolved once, here, and checked (§17 Addresses): the floor refuses a host when any of them is refused, and
+ * connects only to an address it has checked, so a second answer from DNS never reaches a connection (DNS rebinding).
+ *
+ * Through a proxy (§17 Proxies), the proxy connects to the host, and resolves it. The floor still refuses an IP-literal
+ * host in a refused range, and a host that resolves here to a refused address; a host that doesn't resolve here is
+ * left to the proxy. TLS runs to the host itself, through the tunnel, and is verified as without one.
+ */
+export declare function open(url: URL, options: ConnectionOptions, sockets: Sockets): Promise<Duplex>;
+export {};

package/dist/packages/source-store/lib/connection.js

@@ -0,0 +1,135 @@
+// Opening the connection for one request (§17 Safety floor): the address check, the proxy tunnel, and verified TLS.
+import { request as httpRequest } from 'node:http';
+import { isIP, isIPv6 } from 'node:net';
+import { connect as tlsConnect } from 'node:tls';
+import { refusedAddress } from "./addresses.js";
+import { Failure, reason, Refusal } from "./outcomes.js";
+import { proxyFor } from "./proxy.js";
+import { hostOf, portOf } from "./urls.js";
+/**
+ * Opens a connection to the URL's host: a TCP connection, with verified TLS over it for `https:`. The host's addresses
+ * are resolved once, here, and checked (§17 Addresses): the floor refuses a host when any of them is refused, and
+ * connects only to an address it has checked, so a second answer from DNS never reaches a connection (DNS rebinding).
+ *
+ * Through a proxy (§17 Proxies), the proxy connects to the host, and resolves it. The floor still refuses an IP-literal
+ * host in a refused range, and a host that resolves here to a refused address; a host that doesn't resolve here is
+ * left to the proxy. TLS runs to the host itself, through the tunnel, and is verified as without one.
+ */
+export async function open(url, options, sockets) {
+    const host = hostOf(url);
+    const port = portOf(url);
+    const proxy = proxyFor(url, options.env);
+    if (proxy === null) {
+        const addresses = checked(host, await addressesOf(host, options));
+        const socket = await connectToAny(host, addresses, port, options, sockets);
+        return url.protocol === 'https:' ? secure(socket, host, options, sockets) : socket;
+    }
+    if (isIP(host) === 0) {
+        const here = await addressesOf(host, options).catch(() => null);
+        if (here !== null)
+            checked(host, here);
+    }
+    else
+        checked(host, [{ address: host, family: isIP(host) }]);
+    const proxyHost = hostOf(proxy.url);
+    let socket = await connectToAny(proxyHost, await addressesOf(proxyHost, options), portOf(proxy.url), options, sockets);
+    if (proxy.url.protocol === 'https:')
+        socket = await secure(socket, proxyHost, options, sockets);
+    const tunnel = await tunnelThrough(socket, `${isIPv6(host) ? `[${host}]` : host}:${port}`, proxy.authorization);
+    return secure(sockets.add(tunnel), host, options, sockets);
+}
+/** The addresses of a host: an IP literal's own, or what the DNS hook resolves its name to. */
+async function addressesOf(host, options) {
+    return isIP(host) === 0 ? resolve(host, options) : [{ address: host, family: isIP(host) }];
+}
+/** The host's addresses, when the floor refuses none of them (§17 Addresses). */
+function checked(host, addresses) {
+    for (const { address } of addresses) {
+        const refused = refusedAddress(address);
+        if (refused !== null) {
+            const resolved = address === host ? host : `${host} resolves to ${address}`;
+            throw new Refusal(`the safety floor refuses the address: ${resolved} (${refused})`);
+        }
+    }
+    return addresses;
+}
+/**
+ * A tunnel to `target` (`host:port`) through the proxy connected to over `socket`: an HTTP `CONNECT`, with the
+ * credentials of the proxy's URL, if any.
+ */
+function tunnelThrough(socket, target, authorization) {
+    return new Promise((resolve, reject) => {
+        const request = httpRequest({
+            createConnection: () => socket,
+            method: 'CONNECT',
+            path: target,
+            setHost: false,
+            headers: { Host: target, ...(authorization === null ? {} : { 'Proxy-Authorization': authorization }) },
+        });
+        const refused = (status) => new Failure(`the proxy answered ${status} to CONNECT ${target}`);
+        request.once('connect', (response, tunnel, head) => {
+            if (response.statusCode !== 200) {
+                tunnel.destroy();
+                reject(refused(response.statusCode));
+                return;
+            }
+            if (head.length > 0)
+                tunnel.unshift(head);
+            resolve(tunnel);
+        });
+        request.once('response', (response) => {
+            socket.destroy();
+            reject(refused(response.statusCode));
+        });
+        request.on('error', (error) => reject(new Failure(`the proxy's tunnel to ${target} failed: ${reason(error)}`)));
+        request.end();
+    });
+}
+/**
+ * Connects to the first of `addresses` that accepts a connection, in order. Once the request has ended, because a time
+ * limit ran out, the connection being opened is given up, and no other address is tried.
+ */
+async function connectToAny(host, addresses, port, { connect }, sockets) {
+    const { signal } = sockets;
+    let last;
+    for (const { address, family } of addresses) {
+        if (signal.aborted)
+            break;
+        try {
+            return sockets.add(await connect({ address, family, port, signal }));
+        }
+        catch (error) {
+            last = error;
+        }
+    }
+    throw new Failure(`can't connect to ${host}: ${reason(last)}`);
+}
+async function resolve(host, options) {
+    try {
+        const addresses = await options.lookup(host);
+        if (addresses.length === 0)
+            throw new Error('no addresses');
+        return addresses;
+    }
+    catch (error) {
+        throw new Failure(`DNS lookup of ${host} failed: ${reason(error)}`);
+    }
+}
+/** Verified TLS over `socket` to `host`. Verification is never turned off, whatever the environment says. */
+function secure(socket, host, { ca }, sockets) {
+    return new Promise((resolve, reject) => {
+        const tls = sockets.add(tlsConnect({
+            socket,
+            ...(isIP(host) === 0 ? { servername: host } : { host }),
+            rejectUnauthorized: true,
+            ALPNProtocols: ['http/1.1'],
+            ...(ca === null ? {} : { ca }),
+        }));
+        tls.once('secureConnect', () => {
+            tls.off('error', fail);
+            resolve(tls);
+        });
+        const fail = (error) => reject(new Failure(`TLS with ${host} failed: ${reason(error)}`));
+        tls.once('error', fail);
+    });
+}

package/dist/packages/source-store/lib/content-types.d.ts

@@ -0,0 +1,16 @@
+import type { FetchRequest } from '../index.ts';
+type Destination = FetchRequest['destination'];
+/**
+ * Why a browser blocks a response of `contentType` for `destination` before it checks integrity, or null when it
+ * doesn't (Fetch § main fetch: § Should response to request be blocked due to its MIME type? and § due to nosniff?).
+ * Every script destination is blocked for an `image/*`, `audio/*`, `video/*` or `text/csv` type, or for a type that
+ * isn't JavaScript's with `X-Content-Type-Options: nosniff`.
+ */
+export declare function blockedTypeRefusal(destination: Destination, contentType: string | null, nosniff: string | null): string | null;
+/**
+ * Why a browser refuses a response of `contentType` for `destination` once its integrity is checked, or null when it
+ * doesn't (HTML § Fetching scripts): a module script, a worker's script and a script `importScripts` loads need a
+ * JavaScript MIME type. A classic script of the window doesn't.
+ */
+export declare function javascriptTypeRefusal(destination: Destination, contentType: string | null): string | null;
+export {};

package/dist/packages/source-store/lib/content-types.js

@@ -0,0 +1,75 @@
+// The MIME types the floor fetches each destination with (§17 Content types): what a browser would execute. The
+// checks come in two parts, which a fetch runs in the browser's order for each destination: `blockedTypeRefusal`
+// first, then the integrity check, then `javascriptTypeRefusal`. A source map is read as JSON whatever its type, so
+// neither part refuses one.
+/** JavaScript MIME type essences (MIME Sniffing § JavaScript MIME type). */
+const javascriptTypes = new Set([
+    'application/ecmascript',
+    'application/javascript',
+    'application/x-ecmascript',
+    'application/x-javascript',
+    'text/ecmascript',
+    'text/javascript',
+    'text/javascript1.0',
+    'text/javascript1.1',
+    'text/javascript1.2',
+    'text/javascript1.3',
+    'text/javascript1.4',
+    'text/javascript1.5',
+    'text/jscript',
+    'text/livescript',
+    'text/x-ecmascript',
+    'text/x-javascript',
+]);
+/**
+ * Why a browser blocks a response of `contentType` for `destination` before it checks integrity, or null when it
+ * doesn't (Fetch § main fetch: § Should response to request be blocked due to its MIME type? and § due to nosniff?).
+ * Every script destination is blocked for an `image/*`, `audio/*`, `video/*` or `text/csv` type, or for a type that
+ * isn't JavaScript's with `X-Content-Type-Options: nosniff`.
+ */
+export function blockedTypeRefusal(destination, contentType, nosniff) {
+    if (destination === 'map')
+        return null;
+    const essence = mimeEssence(contentType);
+    if (essence !== null && (/^(image|audio|video)\//.test(essence) || essence === 'text/csv')) {
+        return `the safety floor refuses ${named[destination]} served with ${served(contentType)}, which a browser blocks`;
+    }
+    if (!isJavascript(essence) && isNosniff(nosniff)) {
+        const what = `${named[destination]} served with ${served(contentType)}`;
+        return `the safety floor refuses ${what} and X-Content-Type-Options: nosniff`;
+    }
+    return null;
+}
+/**
+ * Why a browser refuses a response of `contentType` for `destination` once its integrity is checked, or null when it
+ * doesn't (HTML § Fetching scripts): a module script, a worker's script and a script `importScripts` loads need a
+ * JavaScript MIME type. A classic script of the window doesn't.
+ */
+export function javascriptTypeRefusal(destination, contentType) {
+    if (destination === 'map' || destination === 'script' || isJavascript(mimeEssence(contentType)))
+        return null;
+    const what = `${named[destination]} served with ${served(contentType)}`;
+    return `the safety floor refuses ${what}: it needs a JavaScript MIME type`;
+}
+const named = {
+    script: 'a classic script',
+    module: 'a module script',
+    worker: "a worker's script",
+};
+function served(contentType) {
+    return contentType === null ? 'no Content-Type' : `Content-Type ${contentType}`;
+}
+function isJavascript(essence) {
+    return essence !== null && javascriptTypes.has(essence);
+}
+/** The essence of a `Content-Type` (`type/subtype`, in ASCII lowercase), or null when it has none that parses. */
+function mimeEssence(contentType) {
+    if (contentType === null)
+        return null;
+    const essence = contentType.split(';')[0].trim().toLowerCase();
+    return /^[!#$%&'*+.^_`|~\da-z-]+\/[!#$%&'*+.^_`|~\da-z-]+$/.test(essence) ? essence : null;
+}
+/** Whether `X-Content-Type-Options` says `nosniff` (Fetch § determine nosniff): its first value, ignoring case. */
+function isNosniff(value) {
+    return value !== null && value.split(',')[0].trim().toLowerCase() === 'nosniff';
+}

package/dist/packages/source-store/lib/data-urls.d.ts

@@ -0,0 +1,10 @@
+import type { FetchRequest, ReadResult } from '../index.ts';
+/**
+ * Reads the `data:` URL `url` as `request` asks for it (§2 Other script URLs). Its body is the script, and its MIME
+ * type the response's `Content-Type`. It is `refused` when a browser would not run it: a malformed base64 body, a MIME
+ * type a browser blocks for any script (`image/*`, `audio/*`, `video/*`, `text/csv`), bytes that don't match the
+ * request's integrity value, or a module or a script `importScripts` loads whose MIME type isn't JavaScript's, checked
+ * in the browser's order (§17 Content types). A classic script of the window needs no JavaScript MIME type, and nor
+ * does a worker's own classic script, whose URL isn't HTTP(S) (HTML § Fetch a classic worker script).
+ */
+export declare function readDataUrl(url: string, request: FetchRequest): ReadResult;

package/dist/packages/source-store/lib/data-urls.js

@@ -0,0 +1,85 @@
+// `data:` URLs (§2 Other script URLs): code a page carries in the reference itself. The store reads one as the Fetch
+// standard's data: URL processor does, with no fetcher, and refuses it where a browser would refuse to run the
+// script: then nothing of it is an artifact.
+import { blockedTypeRefusal, javascriptTypeRefusal } from "./content-types.js";
+import { checkIntegrity } from "./integrity.js";
+/**
+ * Reads the `data:` URL `url` as `request` asks for it (§2 Other script URLs). Its body is the script, and its MIME
+ * type the response's `Content-Type`. It is `refused` when a browser would not run it: a malformed base64 body, a MIME
+ * type a browser blocks for any script (`image/*`, `audio/*`, `video/*`, `text/csv`), bytes that don't match the
+ * request's integrity value, or a module or a script `importScripts` loads whose MIME type isn't JavaScript's, checked
+ * in the browser's order (§17 Content types). A classic script of the window needs no JavaScript MIME type, and nor
+ * does a worker's own classic script, whose URL isn't HTTP(S) (HTML § Fetch a classic worker script).
+ */
+export function readDataUrl(url, request) {
+    const processed = processDataUrl(url);
+    if (processed === null)
+        return refused(url, 'its base64 body is malformed');
+    const { contentType, body } = processed;
+    if (blockedTypeRefusal(request.destination, contentType, null) !== null) {
+        return refused(url, `a browser blocks a script of the MIME type ${contentType}`);
+    }
+    const sri = checkIntegrity(request.integrity ?? '', body);
+    if (sri !== 'none' && sri.result === 'mismatch') {
+        return refused(url, `its digest is ${sri.actual}, and the integrity value expects ${sri.expected.join(' or ')}`);
+    }
+    const ownWorkerScript = request.destination === 'worker' && request.imported !== true;
+    if (!ownWorkerScript && javascriptTypeRefusal(request.destination, contentType) !== null) {
+        return refused(url, `it needs a JavaScript MIME type, and it has ${contentType}`);
+    }
+    const retrieval = { status: 'ok', requestedUrl: url, finalUrl: url, contentType, sri };
+    return { status: 'ok', url, path: null, bytes: body, retrieval, sourceMap: null };
+}
+function refused(url, why) {
+    return { status: 'refused', url, detail: `a browser refuses to run the data: script: ${why}` };
+}
+/**
+ * The MIME type and body of a `data:` URL (Fetch § data: URL processor), or null when its body is malformed base64. A
+ * MIME type that doesn't parse, an empty one included, is `text/plain;charset=US-ASCII`.
+ */
+function processDataUrl(url) {
+    // The URL serialized without its fragment: its first `#` starts the fragment.
+    const fragment = url.indexOf('#');
+    const input = url.slice('data:'.length, fragment === -1 ? undefined : fragment);
+    const comma = input.indexOf(',');
+    if (comma === -1)
+        return null;
+    let mimeType = input.slice(0, comma).replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '');
+    let body = percentDecode(input.slice(comma + 1));
+    const base64 = /; *base64$/i.exec(mimeType);
+    if (base64 !== null) {
+        try {
+            // Forgiving-base64 decode, of the body's isomorphic decoding.
+            body = Uint8Array.from(atob(Buffer.from(body).toString('latin1')), (character) => character.charCodeAt(0));
+        }
+        catch {
+            return null;
+        }
+        mimeType = mimeType.slice(0, base64.index);
+    }
+    if (mimeType.startsWith(';'))
+        mimeType = `text/plain${mimeType}`;
+    return { contentType: parsesAsMimeType(mimeType) ? mimeType : 'text/plain;charset=US-ASCII', body };
+}
+/**
+ * Whether `text` parses as a MIME type (MIME Sniffing § parse a MIME type): a token type and subtype, then any
+ * parameters.
+ */
+function parsesAsMimeType(text) {
+    return /^[\t\n\r ]*[!#$%&'*+.^_`|~\dA-Za-z-]+\/[!#$%&'*+.^_`|~\dA-Za-z-]+[\t\n\r ]*(?:;|$)/.test(text);
+}
+/** The bytes of a URL's percent-encoding (URL § percent-decode): an invalid escape is left as it is. */
+function percentDecode(text) {
+    const bytes = new TextEncoder().encode(text);
+    const out = [];
+    for (let i = 0; i < bytes.length; i++) {
+        const hex = String.fromCharCode(bytes[i + 1] ?? 0, bytes[i + 2] ?? 0);
+        if (bytes[i] === 0x25 && /^[\dA-Fa-f]{2}$/.test(hex)) {
+            out.push(Number.parseInt(hex, 16));
+            i += 2;
+        }
+        else
+            out.push(bytes[i]);
+    }
+    return Uint8Array.from(out);
+}

package/dist/packages/source-store/lib/deadline.d.ts

@@ -0,0 +1,18 @@
+import type { Duplex } from 'node:stream';
+/**
+ * The sockets one request opens: all of them are closed when it ends, however it ends. A connection still being opened
+ * then is given up through `signal`, so that it neither goes on connecting nor keeps the process alive.
+ */
+export declare class Sockets {
+    #private;
+    /** Aborts when the request ends: a connect hook given it stops connecting, and rejects. */
+    get signal(): AbortSignal;
+    /**
+     * Keeps `socket` to close with the rest, or closes it now when the request has already ended. An error on it between
+     * two steps of the request, when no step is listening, is left for the next step to find: it never crashes the scan.
+     */
+    add<T extends Duplex>(socket: T): T;
+    close(): void;
+}
+/** Settles as `work` does, or rejects with `failure()` once `ms` have passed without it settling. */
+export declare function within<T>(work: Promise<T>, ms: number, failure: () => Error): Promise<T>;

package/dist/packages/source-store/lib/deadline.js

@@ -0,0 +1,44 @@
+// Time limits for the resolve fetcher's steps (§17 Safety floor: Time), and the sockets a step leaves open when one
+// runs out.
+/**
+ * The sockets one request opens: all of them are closed when it ends, however it ends. A connection still being opened
+ * then is given up through `signal`, so that it neither goes on connecting nor keeps the process alive.
+ */
+export class Sockets {
+    #open = [];
+    #ended = new AbortController();
+    /** Aborts when the request ends: a connect hook given it stops connecting, and rejects. */
+    get signal() {
+        return this.#ended.signal;
+    }
+    /**
+     * Keeps `socket` to close with the rest, or closes it now when the request has already ended. An error on it between
+     * two steps of the request, when no step is listening, is left for the next step to find: it never crashes the scan.
+     */
+    add(socket) {
+        socket.on('error', () => { });
+        if (this.signal.aborted)
+            socket.destroy();
+        else
+            this.#open.push(socket);
+        return socket;
+    }
+    close() {
+        this.#ended.abort();
+        for (const socket of this.#open)
+            socket.destroy();
+    }
+}
+/** Settles as `work` does, or rejects with `failure()` once `ms` have passed without it settling. */
+export function within(work, ms, failure) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(failure()), ms);
+        work.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}

package/dist/packages/source-store/lib/exchange.d.ts

@@ -0,0 +1,29 @@
+import { type Duplex } from 'node:stream';
+import type { FetchedResponse } from '../index.ts';
+import type { SessionOptions } from './session.ts';
+/**
+ * What one request got: the response's status and recorded headers, its `Location` and `X-Content-Type-Options`, and a
+ * 2xx response's body.
+ */
+export interface Answer {
+    response: FetchedResponse;
+    status: number;
+    location: string | null;
+    nosniff: string | null;
+    bytes: Uint8Array | null;
+}
+/** How many bytes a response's body may hold, decompressed (§17 Size). */
+export interface ByteLimits {
+    /** The most one response may have. */
+    responseBytes: number;
+    /** The most all the responses of the scan may have. */
+    scanBytes: number;
+    /** The bytes the scan's earlier responses had. */
+    scanned: number;
+}
+/**
+ * Sends a `GET` for `url` over `connection`: with monkeypatchlist's `User-Agent`, and without cookies, credentials or
+ * conditional headers (§17 Requests). Only a 2xx response's body is read, decompressed from `gzip` or `br`, and it is
+ * refused as soon as it holds more bytes than `limits` allow.
+ */
+export declare function exchange(url: URL, connection: Duplex, { version }: Pick<SessionOptions, 'version'>, limits: ByteLimits): Promise<Answer>;

package/dist/packages/source-store/lib/exchange.js

@@ -0,0 +1,112 @@
+// One request and its response, over a connection the floor has opened (§17 Safety floor: Requests, Size).
+import { request as httpRequest } from 'node:http';
+import { Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
+import { Failure, reason, Refusal } from "./outcomes.js";
+/**
+ * Sends a `GET` for `url` over `connection`: with monkeypatchlist's `User-Agent`, and without cookies, credentials or
+ * conditional headers (§17 Requests). Only a 2xx response's body is read, decompressed from `gzip` or `br`, and it is
+ * refused as soon as it holds more bytes than `limits` allow.
+ */
+export function exchange(url, connection, { version }, limits) {
+    return new Promise((resolve, reject) => {
+        const request = httpRequest({
+            createConnection: () => connection,
+            method: 'GET',
+            path: `${url.pathname}${url.search}`,
+            setHost: false,
+            headers: {
+                Host: url.host,
+                'User-Agent': `monkeypatchlist/${version}`,
+                Accept: '*/*',
+                'Accept-Encoding': 'gzip, br',
+                Connection: 'close',
+            },
+        });
+        request.on('error', (error) => reject(new Failure(`the request for ${url.href} failed: ${reason(error)}`)));
+        request.once('response', (message) => {
+            const status = message.statusCode ?? 0;
+            const response = recorded(url, message);
+            const location = header(message, 'location');
+            const nosniff = header(message, 'x-content-type-options');
+            if (status < 200 || status > 299) {
+                message.destroy();
+                connection.destroy();
+                resolve({ response, status, location, nosniff, bytes: null });
+                return;
+            }
+            body(url, message, response, limits)
+                .then((bytes) => resolve({ response, status, location, nosniff, bytes }), reject)
+                .finally(() => connection.destroy());
+        });
+        request.end();
+    });
+}
+/** Reads a response's body, decoded, refusing it once it holds more bytes than `limits` allow. */
+async function body(url, message, response, { responseBytes, scanBytes, scanned }) {
+    const decoders = decodersFor(header(message, 'content-encoding'));
+    const chunks = [];
+    let size = 0;
+    const sink = new Writable({
+        write(chunk, _, callback) {
+            size += chunk.length;
+            if (size > responseBytes) {
+                callback(new Refusal(`the safety floor refuses a response of more than ${responseBytes} bytes`, response));
+            }
+            else if (scanned + size > scanBytes) {
+                callback(new Refusal(`the safety floor refuses more than ${scanBytes} bytes of responses in a scan`, response));
+            }
+            else {
+                chunks.push(chunk);
+                callback();
+            }
+        },
+    });
+    try {
+        await pipeline([message, ...decoders, sink]);
+    }
+    catch (error) {
+        if (error instanceof Refusal || error instanceof Failure)
+            throw error;
+        throw new Failure(`reading ${url.href} failed: ${reason(error)}`);
+    }
+    return new Uint8Array(Buffer.concat(chunks));
+}
+/**
+ * The decoders a `Content-Encoding` needs, in the order to apply them: the codings are listed in the order they were
+ * applied. A coding the floor can't decode fails the fetch.
+ */
+function decodersFor(encoding) {
+    const codings = (encoding ?? '')
+        .split(',')
+        .map((coding) => coding.trim().toLowerCase())
+        .filter((coding) => coding !== '' && coding !== 'identity');
+    return codings.reverse().map((coding) => {
+        switch (coding) {
+            case 'gzip':
+            case 'x-gzip':
+                return createGunzip();
+            case 'br':
+                return createBrotliDecompress();
+            case 'deflate':
+                return createInflate();
+            default:
+                throw new Failure(`the response has a content coding monkeypatchlist can't decode: ${coding}`);
+        }
+    });
+}
+/** The response's URL and the headers that are recorded (§17 What is recorded). */
+function recorded(url, message) {
+    return {
+        finalUrl: url.href,
+        contentType: header(message, 'content-type'),
+        etag: header(message, 'etag'),
+        lastModified: header(message, 'last-modified'),
+        sourceMap: header(message, 'sourcemap') ?? header(message, 'x-sourcemap'),
+    };
+}
+function header(message, name) {
+    const value = message.headers[name];
+    return typeof value === 'string' ? value : null;
+}

package/dist/packages/source-store/lib/integrity.d.ts

@@ -0,0 +1,19 @@
+import type { FetchedResponse, FetchResult, Sri } from '../index.ts';
+/**
+ * The result of fetching `bytes` with the integrity metadata `integrity` (the empty string for none): `ok` with the
+ * check, or `sri-mismatch` with it, and without the bytes, which are never analyzed (§17 Integrity).
+ */
+export declare function verified(bytes: Uint8Array, response: FetchedResponse, integrity: string): FetchResult;
+/**
+ * One integrity value that stands for several (§17 Integrity): code sets an element's `integrity` to one of
+ * several constants, and the bytes pass when they match any. A single value is returned as it is.
+ */
+export declare function alternativeIntegrity(values: readonly string[]): string;
+/**
+ * Checks `bytes` against an integrity value, which is integrity metadata or alternatives of it
+ * (`alternativeIntegrity`). The bytes match when they match any alternative, and the check is that alternative's. When
+ * none does, the check expects every alternative's digests, and `actual` is the bytes' digest in the strongest
+ * algorithm any of them names. An alternative that checks nothing makes the value check nothing (`none`), as in a
+ * browser.
+ */
+export declare function checkIntegrity(integrity: string, bytes: Uint8Array): Sri;