@fgv/ts-extras 5.1.0-46 → 5.1.0-48

package/lib/packlets/safer-fetch/addressPolicy.js

@@ -0,0 +1,123 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockPrivateNetworksPolicy = blockPrivateNetworksPolicy;
+exports.allowAnyAddressPolicy = allowAnyAddressPolicy;
+const ts_utils_1 = require("@fgv/ts-utils");
+const addressClassification_1 = require("./addressClassification");
+const PUBLIC_ONLY = new Set(['public']);
+const PUBLIC_OR_LOOPBACK = new Set([
+    'public',
+    'loopback'
+]);
+function describeAddress(classified) {
+    const embedded = classified.embeddedIpv4 !== undefined
+        ? ` via ${classified.embeddedIpv4.kind} ${classified.embeddedIpv4.address}`
+        : '';
+    return `${classified.canonical} is ${classified.classification}${embedded}`;
+}
+function checkOneAddress(policyName, allowed, address) {
+    return (0, addressClassification_1.classifyAddress)(address)
+        .withErrorFormat((message) => `${policyName}: ${message}`)
+        .onSuccess((classified) => allowed.has(classified.classification)
+        ? (0, ts_utils_1.succeed)(classified)
+        : (0, ts_utils_1.fail)(`${policyName}: ${describeAddress(classified)} and is not allowed`));
+}
+function checkAllAddresses(policyName, allowed, addresses) {
+    if (addresses.length === 0) {
+        return (0, ts_utils_1.fail)(`${policyName}: no addresses to check - the destination cannot be verified`);
+    }
+    return (0, ts_utils_1.mapResults)(addresses.map((address) => checkOneAddress(policyName, allowed, address))).onSuccess((classified) => (0, ts_utils_1.succeed)({ policy: policyName, addresses: classified }));
+}
+/**
+ * Creates the recommended address policy: every address must be a globally
+ * routable public unicast address.
+ *
+ * Rejected, in both their plain and their IPv6-embedded encodings: loopback,
+ * the link-local range that carries the cloud instance-metadata endpoint
+ * (`169.254.169.254`), RFC 1918 private ranges, IPv6 unique-local, carrier-grade
+ * NAT (`100.64.0.0/10`), the unspecified address, multicast, broadcast,
+ * benchmarking, documentation and every other reserved range. The encoding
+ * bypasses covered are IPv4-mapped IPv6 (`::ffff:169.254.169.254`),
+ * IPv4-compatible IPv6, NAT64 (`64:ff9b::a9fe:a9fe`), 6to4 (`2002:a9fe:a9fe::`)
+ * and the shortened / octal / hexadecimal / decimal IPv4 literal forms
+ * (`127.1`, `0177.0.0.1`, `0x7f.1`, `2130706433`).
+ *
+ * **What this does not protect against.** The policy classifies addresses a
+ * caller has already resolved; it cannot see the address the connection
+ * ultimately uses. A hostile DNS server that answers the resolution with a
+ * public address and the connect with a private one is not stopped by this
+ * policy — closing that requires connecting to a pinned address. The policy
+ * also says nothing about scheme, host, port, redirects or response content.
+ *
+ * This is the **policy-layer** factory. It is not what a safer-fetch call's
+ * `addressGuard` option takes: an entry point takes an `IAddressGuard`, which is
+ * the asynchronous, hop-chain-aware, name-resolving half. `blockPrivateNetworks`
+ * (Node only) is the guard that resolves a hostname and delegates every resolved
+ * address to this policy; reach for that unless you are classifying an address
+ * list you already hold.
+ *
+ * @param options - optional {@link IBlockPrivateNetworksOptions | relaxations}
+ * of the default posture.
+ * @returns the policy. Construction cannot fail.
+ * @public
+ */
+function blockPrivateNetworksPolicy(options) {
+    const allowLoopback = (options === null || options === void 0 ? void 0 : options.allowLoopback) === true;
+    const name = allowLoopback
+        ? 'blockPrivateNetworksPolicy(allowLoopback)'
+        : 'blockPrivateNetworksPolicy';
+    const allowed = allowLoopback ? PUBLIC_OR_LOOPBACK : PUBLIC_ONLY;
+    return {
+        name,
+        checkAddresses: (addresses) => checkAllAddresses(name, allowed, addresses)
+    };
+}
+/**
+ * Creates a policy that permits every address, including loopback, link-local
+ * and private ones.
+ *
+ * **This policy provides no protection whatsoever.** It classifies nothing,
+ * rejects nothing, and never fails — not even for an empty address list or an
+ * address that is not a well-formed literal. It exists so that choosing to go
+ * without an address guarantee is a deliberate, named, greppable act at the
+ * call site rather than something reachable by omission, and so that tests and
+ * genuinely trusted-input paths do not hand-roll something worse.
+ *
+ * It is the only correct choice in a browser, where neither name resolution nor
+ * redirect interposition is available and no address guarantee is possible.
+ *
+ * @returns the policy.
+ * @public
+ */
+function allowAnyAddressPolicy() {
+    const name = 'allowAnyAddressPolicy';
+    return {
+        name,
+        // The parameter is deliberately not declared. This policy does not read the
+        // addresses, and an unused `_addresses` would both restate that less
+        // clearly and cut against the repo's "don't rename unused variables to
+        // `_var`" rule. Parameter bivariance makes the zero-arg form a complete
+        // implementation of `IAddressPolicy`.
+        checkAddresses: () => (0, ts_utils_1.succeed)({ policy: name, addresses: [] })
+    };
+}
+//# sourceMappingURL=addressPolicy.js.map

package/lib/packlets/safer-fetch/addressPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressPolicy.js","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/addressPolicy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Erik Fortune\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nimport { type Result, fail, mapResults, succeed } from '@fgv/ts-utils';\nimport {\n  type AddressClassification,\n  type IClassifiedAddress,\n  classifyAddress\n} from './addressClassification';\n\n/**\n * The evidence behind an allowed address-policy decision.\n * @public\n */\nexport interface IAddressCheckVerdict {\n  /** The {@link IAddressPolicy.name | name} of the policy that produced the verdict. */\n  readonly policy: string;\n  /**\n   * The classification of every address the policy examined, in the order\n   * supplied. Empty for {@link allowAnyAddressPolicy}, which classifies nothing.\n   */\n  readonly addresses: ReadonlyArray<IClassifiedAddress>;\n}\n\n/**\n * A pure, synchronous decision over a set of IP addresses.\n *\n * A policy performs no name resolution and no I/O: a caller resolves a\n * hostname to its addresses and hands the whole list to\n * {@link IAddressPolicy.checkAddresses}. The list contract is\n * **reject-if-any** — a hostname that resolves to one public and one private\n * address is disallowed, because without connect-time address pinning there is\n * no guarantee which address the connection will use.\n *\n * @public\n */\nexport interface IAddressPolicy {\n  /**\n   * A stable, greppable identifier for the posture this policy implements.\n   * Surfaced in the failure message when an address is disallowed.\n   */\n  readonly name: string;\n\n  /**\n   * Decides whether a connection may be made to a destination that resolved to\n   * `addresses`.\n   *\n   * @param addresses - every address the destination resolved to, or the\n   * single literal address when the destination was an IP literal.\n   * @returns `Success` with the {@link IAddressCheckVerdict | verdict} when\n   * *every* address is permitted, `Failure` naming every address that is not.\n   * An empty list is a failure for any policy that offers a guarantee: nothing\n   * was verified, so nothing may be reached.\n   */\n  checkAddresses(addresses: ReadonlyArray<string>): Result<IAddressCheckVerdict>;\n}\n\n/**\n * Options shared by {@link blockPrivateNetworksPolicy} and the address guard built over it.\n * @public\n */\nexport interface IBlockPrivateNetworksOptions {\n  /**\n   * Permits `127.0.0.0/8` and `::1` (and their IPv4-mapped forms). Off by\n   * default: the polarity that ships a guard permitting `http://127.0.0.1:6379/`\n   * so a local-development convenience keeps working is the wrong one. A\n   * caller talking to a local sidecar opts in here, and the opt-in is\n   * independently greppable at the call site.\n   */\n  readonly allowLoopback?: boolean;\n}\n\nconst PUBLIC_ONLY: ReadonlySet<AddressClassification> = new Set<AddressClassification>(['public']);\nconst PUBLIC_OR_LOOPBACK: ReadonlySet<AddressClassification> = new Set<AddressClassification>([\n  'public',\n  'loopback'\n]);\n\nfunction describeAddress(classified: IClassifiedAddress): string {\n  const embedded: string =\n    classified.embeddedIpv4 !== undefined\n      ? ` via ${classified.embeddedIpv4.kind} ${classified.embeddedIpv4.address}`\n      : '';\n  return `${classified.canonical} is ${classified.classification}${embedded}`;\n}\n\nfunction checkOneAddress(\n  policyName: string,\n  allowed: ReadonlySet<AddressClassification>,\n  address: string\n): Result<IClassifiedAddress> {\n  return classifyAddress(address)\n    .withErrorFormat((message) => `${policyName}: ${message}`)\n    .onSuccess((classified) =>\n      allowed.has(classified.classification)\n        ? succeed(classified)\n        : fail(`${policyName}: ${describeAddress(classified)} and is not allowed`)\n    );\n}\n\nfunction checkAllAddresses(\n  policyName: string,\n  allowed: ReadonlySet<AddressClassification>,\n  addresses: ReadonlyArray<string>\n): Result<IAddressCheckVerdict> {\n  if (addresses.length === 0) {\n    return fail(`${policyName}: no addresses to check - the destination cannot be verified`);\n  }\n  return mapResults(addresses.map((address) => checkOneAddress(policyName, allowed, address))).onSuccess(\n    (classified) => succeed({ policy: policyName, addresses: classified })\n  );\n}\n\n/**\n * Creates the recommended address policy: every address must be a globally\n * routable public unicast address.\n *\n * Rejected, in both their plain and their IPv6-embedded encodings: loopback,\n * the link-local range that carries the cloud instance-metadata endpoint\n * (`169.254.169.254`), RFC 1918 private ranges, IPv6 unique-local, carrier-grade\n * NAT (`100.64.0.0/10`), the unspecified address, multicast, broadcast,\n * benchmarking, documentation and every other reserved range. The encoding\n * bypasses covered are IPv4-mapped IPv6 (`::ffff:169.254.169.254`),\n * IPv4-compatible IPv6, NAT64 (`64:ff9b::a9fe:a9fe`), 6to4 (`2002:a9fe:a9fe::`)\n * and the shortened / octal / hexadecimal / decimal IPv4 literal forms\n * (`127.1`, `0177.0.0.1`, `0x7f.1`, `2130706433`).\n *\n * **What this does not protect against.** The policy classifies addresses a\n * caller has already resolved; it cannot see the address the connection\n * ultimately uses. A hostile DNS server that answers the resolution with a\n * public address and the connect with a private one is not stopped by this\n * policy — closing that requires connecting to a pinned address. The policy\n * also says nothing about scheme, host, port, redirects or response content.\n *\n * This is the **policy-layer** factory. It is not what a safer-fetch call's\n * `addressGuard` option takes: an entry point takes an `IAddressGuard`, which is\n * the asynchronous, hop-chain-aware, name-resolving half. `blockPrivateNetworks`\n * (Node only) is the guard that resolves a hostname and delegates every resolved\n * address to this policy; reach for that unless you are classifying an address\n * list you already hold.\n *\n * @param options - optional {@link IBlockPrivateNetworksOptions | relaxations}\n * of the default posture.\n * @returns the policy. Construction cannot fail.\n * @public\n */\nexport function blockPrivateNetworksPolicy(options?: IBlockPrivateNetworksOptions): IAddressPolicy {\n  const allowLoopback: boolean = options?.allowLoopback === true;\n  const name: string = allowLoopback\n    ? 'blockPrivateNetworksPolicy(allowLoopback)'\n    : 'blockPrivateNetworksPolicy';\n  const allowed: ReadonlySet<AddressClassification> = allowLoopback ? PUBLIC_OR_LOOPBACK : PUBLIC_ONLY;\n  return {\n    name,\n    checkAddresses: (addresses: ReadonlyArray<string>): Result<IAddressCheckVerdict> =>\n      checkAllAddresses(name, allowed, addresses)\n  };\n}\n\n/**\n * Creates a policy that permits every address, including loopback, link-local\n * and private ones.\n *\n * **This policy provides no protection whatsoever.** It classifies nothing,\n * rejects nothing, and never fails — not even for an empty address list or an\n * address that is not a well-formed literal. It exists so that choosing to go\n * without an address guarantee is a deliberate, named, greppable act at the\n * call site rather than something reachable by omission, and so that tests and\n * genuinely trusted-input paths do not hand-roll something worse.\n *\n * It is the only correct choice in a browser, where neither name resolution nor\n * redirect interposition is available and no address guarantee is possible.\n *\n * @returns the policy.\n * @public\n */\nexport function allowAnyAddressPolicy(): IAddressPolicy {\n  const name: string = 'allowAnyAddressPolicy';\n  return {\n    name,\n    // The parameter is deliberately not declared. This policy does not read the\n    // addresses, and an unused `_addresses` would both restate that less\n    // clearly and cut against the repo's \"don't rename unused variables to\n    // `_var`\" rule. Parameter bivariance makes the zero-arg form a complete\n    // implementation of `IAddressPolicy`.\n    checkAddresses: (): Result<IAddressCheckVerdict> => succeed({ policy: name, addresses: [] })\n  };\n}\n"]}

package/lib/packlets/safer-fetch/contentType.d.ts

@@ -0,0 +1,51 @@
+import { Result } from '@fgv/ts-utils';
+/**
+ * A media type split into its type and subtype, lowercased, with parameters removed.
+ * @internal
+ */
+export interface IMediaType {
+    readonly type: string;
+    readonly subtype: string;
+}
+/**
+ * Parses `type/subtype`, ignoring any parameters and surrounding whitespace, and lowercasing
+ * both halves.
+ *
+ * The parse is not as trivial as it looks, which is the argument for owning it once:
+ * `text/html; charset=utf-8` must match `text/html`, matching is case-insensitive on both
+ * halves, and parameters must be *stripped* rather than string-matched around. Every
+ * hand-rolled version gets a different subset of that right, and the failure is silent.
+ * @internal
+ */
+export declare function parseMediaType(value: string): Result<IMediaType>;
+/**
+ * Parses an allowlist entry, which may use `*` as a wildcard for the subtype (`text/*`) or for
+ * both halves (a wildcard type with a wildcard subtype, which accepts anything). A wildcard
+ * type paired with a *concrete* subtype is rejected: it reads as if it means something and
+ * does not.
+ * @internal
+ */
+export declare function parseMediaTypePattern(value: string): Result<IMediaType>;
+/**
+ * Reports whether a parsed media type matches a parsed allowlist pattern.
+ * @internal
+ */
+export declare function mediaTypeMatches(actual: IMediaType, pattern: IMediaType): boolean;
+/**
+ * Extracts the `charset` parameter from a `Content-Type` header value, lowercased.
+ *
+ * Returns `undefined` when the header is absent or carries no `charset`, which the caller
+ * reads as "use the default encoding" — not as "any encoding will do".
+ * @internal
+ */
+export declare function parseCharset(contentType: string | undefined): string | undefined;
+/**
+ * Parses a `Content-Length` header value.
+ *
+ * Returns `undefined` for an absent, non-numeric, negative, or non-integer value rather than
+ * guessing: a malformed length is not evidence of a size, and the streaming cap does not need
+ * it. It is a fast-reject path only.
+ * @internal
+ */
+export declare function parseContentLength(value: string | undefined): number | undefined;
+//# sourceMappingURL=contentType.d.ts.map

package/lib/packlets/safer-fetch/contentType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentType.d.ts","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/contentType.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAQ,MAAM,EAAW,MAAM,eAAe,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAOD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAehE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAOvE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAQjF;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAUhF;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAUhF"}

package/lib/packlets/safer-fetch/contentType.js

@@ -0,0 +1,127 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMediaType = parseMediaType;
+exports.parseMediaTypePattern = parseMediaTypePattern;
+exports.mediaTypeMatches = mediaTypeMatches;
+exports.parseCharset = parseCharset;
+exports.parseContentLength = parseContentLength;
+const ts_utils_1 = require("@fgv/ts-utils");
+// RFC 7230 token. Deliberately not a permissive `[^/;]+`: an allowlist entry that is not a
+// well-formed media type should be reported to its author, not quietly compiled into a
+// pattern that never matches anything.
+const TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/**
+ * Parses `type/subtype`, ignoring any parameters and surrounding whitespace, and lowercasing
+ * both halves.
+ *
+ * The parse is not as trivial as it looks, which is the argument for owning it once:
+ * `text/html; charset=utf-8` must match `text/html`, matching is case-insensitive on both
+ * halves, and parameters must be *stripped* rather than string-matched around. Every
+ * hand-rolled version gets a different subset of that right, and the failure is silent.
+ * @internal
+ */
+function parseMediaType(value) {
+    const essence = value.split(';')[0].trim().toLowerCase();
+    const slash = essence.indexOf('/');
+    if (slash < 0) {
+        return (0, ts_utils_1.fail)(`"${value}": not a media type — expected "type/subtype".`);
+    }
+    const type = essence.slice(0, slash);
+    const subtype = essence.slice(slash + 1);
+    if (!TOKEN.test(type) && type !== '*') {
+        return (0, ts_utils_1.fail)(`"${value}": "${type}" is not a valid media type.`);
+    }
+    if (!TOKEN.test(subtype) && subtype !== '*') {
+        return (0, ts_utils_1.fail)(`"${value}": "${subtype}" is not a valid media subtype.`);
+    }
+    return (0, ts_utils_1.succeed)({ type, subtype });
+}
+/**
+ * Parses an allowlist entry, which may use `*` as a wildcard for the subtype (`text/*`) or for
+ * both halves (a wildcard type with a wildcard subtype, which accepts anything). A wildcard
+ * type paired with a *concrete* subtype is rejected: it reads as if it means something and
+ * does not.
+ * @internal
+ */
+function parseMediaTypePattern(value) {
+    return parseMediaType(value).onSuccess((parsed) => {
+        if (parsed.type === '*' && parsed.subtype !== '*') {
+            return (0, ts_utils_1.fail)(`"${value}": a wildcard type requires a wildcard subtype.`);
+        }
+        return (0, ts_utils_1.succeed)(parsed);
+    });
+}
+/**
+ * Reports whether a parsed media type matches a parsed allowlist pattern.
+ * @internal
+ */
+function mediaTypeMatches(actual, pattern) {
+    if (pattern.type === '*') {
+        return true;
+    }
+    if (pattern.type !== actual.type) {
+        return false;
+    }
+    return pattern.subtype === '*' || pattern.subtype === actual.subtype;
+}
+// A parameter value is either a token or a quoted-string; the charset names that matter here
+// (`utf-8`, `iso-8859-1`, …) are tokens either way once the quotes come off.
+const CHARSET_PARAM = /;\s*charset\s*=\s*(?:"([^"]*)"|([^;\s]*))/i;
+/**
+ * Extracts the `charset` parameter from a `Content-Type` header value, lowercased.
+ *
+ * Returns `undefined` when the header is absent or carries no `charset`, which the caller
+ * reads as "use the default encoding" — not as "any encoding will do".
+ * @internal
+ */
+function parseCharset(contentType) {
+    var _a;
+    if (contentType === undefined) {
+        return undefined;
+    }
+    const match = CHARSET_PARAM.exec(contentType);
+    if (match === null) {
+        return undefined;
+    }
+    const value = ((_a = match[1]) !== null && _a !== void 0 ? _a : match[2]).trim().toLowerCase();
+    return value.length > 0 ? value : undefined;
+}
+/**
+ * Parses a `Content-Length` header value.
+ *
+ * Returns `undefined` for an absent, non-numeric, negative, or non-integer value rather than
+ * guessing: a malformed length is not evidence of a size, and the streaming cap does not need
+ * it. It is a fast-reject path only.
+ * @internal
+ */
+function parseContentLength(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        return undefined;
+    }
+    const parsed = Number(trimmed);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+//# sourceMappingURL=contentType.js.map

package/lib/packlets/safer-fetch/contentType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentType.js","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/contentType.ts"],"names":[],"mappings":";AAAA,kCAAkC;AAClC,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,4EAA4E;AAC5E,wEAAwE;AACxE,2DAA2D;AAC3D,EAAE;AACF,iFAAiF;AACjF,kDAAkD;AAClD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,8EAA8E;AAC9E,yEAAyE;AACzE,gFAAgF;AAChF,gFAAgF;AAChF,YAAY;;AA4BZ,wCAeC;AASD,sDAOC;AAMD,4CAQC;AAaD,oCAUC;AAUD,gDAUC;AAlHD,4CAAsD;AAWtD,2FAA2F;AAC3F,uFAAuF;AACvF,uCAAuC;AACvC,MAAM,KAAK,GAAW,gCAAgC,CAAC;AAEvD;;;;;;;;;GASG;AACH,SAAgB,cAAc,CAAC,KAAa;IAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACzD,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,OAAO,IAAA,eAAI,EAAC,IAAI,KAAK,gDAAgD,CAAC,CAAC;IACzE,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IACzC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;QACtC,OAAO,IAAA,eAAI,EAAC,IAAI,KAAK,OAAO,IAAI,8BAA8B,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,OAAO,KAAK,GAAG,EAAE,CAAC;QAC5C,OAAO,IAAA,eAAI,EAAC,IAAI,KAAK,OAAO,OAAO,iCAAiC,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,IAAA,kBAAO,EAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,qBAAqB,CAAC,KAAa;IACjD,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;QAChD,IAAI,MAAM,CAAC,IAAI,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,KAAK,GAAG,EAAE,CAAC;YAClD,OAAO,IAAA,eAAI,EAAC,IAAI,KAAK,iDAAiD,CAAC,CAAC;QAC1E,CAAC;QACD,OAAO,IAAA,kBAAO,EAAC,MAAM,CAAC,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAAC,MAAkB,EAAE,OAAmB;IACtE,IAAI,OAAO,CAAC,IAAI,KAAK,GAAG,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC;QACjC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,OAAO,CAAC,OAAO,KAAK,GAAG,IAAI,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO,CAAC;AACvE,CAAC;AAED,6FAA6F;AAC7F,6EAA6E;AAC7E,MAAM,aAAa,GAAW,4CAA4C,CAAC;AAE3E;;;;;;GAMG;AACH,SAAgB,YAAY,CAAC,WAA+B;;IAC1D,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC9C,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,MAAA,KAAK,CAAC,CAAC,CAAC,mCAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC1D,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAC9C,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAAC,KAAyB;IAC1D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3D,CAAC","sourcesContent":["// Copyright (c) 2026 Erik Fortune\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nimport { fail, Result, succeed } from '@fgv/ts-utils';\n\n/**\n * A media type split into its type and subtype, lowercased, with parameters removed.\n * @internal\n */\nexport interface IMediaType {\n  readonly type: string;\n  readonly subtype: string;\n}\n\n// RFC 7230 token. Deliberately not a permissive `[^/;]+`: an allowlist entry that is not a\n// well-formed media type should be reported to its author, not quietly compiled into a\n// pattern that never matches anything.\nconst TOKEN: RegExp = /^[!#$%&'*+\\-.^_`|~0-9A-Za-z]+$/;\n\n/**\n * Parses `type/subtype`, ignoring any parameters and surrounding whitespace, and lowercasing\n * both halves.\n *\n * The parse is not as trivial as it looks, which is the argument for owning it once:\n * `text/html; charset=utf-8` must match `text/html`, matching is case-insensitive on both\n * halves, and parameters must be *stripped* rather than string-matched around. Every\n * hand-rolled version gets a different subset of that right, and the failure is silent.\n * @internal\n */\nexport function parseMediaType(value: string): Result<IMediaType> {\n  const essence = value.split(';')[0].trim().toLowerCase();\n  const slash = essence.indexOf('/');\n  if (slash < 0) {\n    return fail(`\"${value}\": not a media type — expected \"type/subtype\".`);\n  }\n  const type = essence.slice(0, slash);\n  const subtype = essence.slice(slash + 1);\n  if (!TOKEN.test(type) && type !== '*') {\n    return fail(`\"${value}\": \"${type}\" is not a valid media type.`);\n  }\n  if (!TOKEN.test(subtype) && subtype !== '*') {\n    return fail(`\"${value}\": \"${subtype}\" is not a valid media subtype.`);\n  }\n  return succeed({ type, subtype });\n}\n\n/**\n * Parses an allowlist entry, which may use `*` as a wildcard for the subtype (`text/*`) or for\n * both halves (a wildcard type with a wildcard subtype, which accepts anything). A wildcard\n * type paired with a *concrete* subtype is rejected: it reads as if it means something and\n * does not.\n * @internal\n */\nexport function parseMediaTypePattern(value: string): Result<IMediaType> {\n  return parseMediaType(value).onSuccess((parsed) => {\n    if (parsed.type === '*' && parsed.subtype !== '*') {\n      return fail(`\"${value}\": a wildcard type requires a wildcard subtype.`);\n    }\n    return succeed(parsed);\n  });\n}\n\n/**\n * Reports whether a parsed media type matches a parsed allowlist pattern.\n * @internal\n */\nexport function mediaTypeMatches(actual: IMediaType, pattern: IMediaType): boolean {\n  if (pattern.type === '*') {\n    return true;\n  }\n  if (pattern.type !== actual.type) {\n    return false;\n  }\n  return pattern.subtype === '*' || pattern.subtype === actual.subtype;\n}\n\n// A parameter value is either a token or a quoted-string; the charset names that matter here\n// (`utf-8`, `iso-8859-1`, …) are tokens either way once the quotes come off.\nconst CHARSET_PARAM: RegExp = /;\\s*charset\\s*=\\s*(?:\"([^\"]*)\"|([^;\\s]*))/i;\n\n/**\n * Extracts the `charset` parameter from a `Content-Type` header value, lowercased.\n *\n * Returns `undefined` when the header is absent or carries no `charset`, which the caller\n * reads as \"use the default encoding\" — not as \"any encoding will do\".\n * @internal\n */\nexport function parseCharset(contentType: string | undefined): string | undefined {\n  if (contentType === undefined) {\n    return undefined;\n  }\n  const match = CHARSET_PARAM.exec(contentType);\n  if (match === null) {\n    return undefined;\n  }\n  const value = (match[1] ?? match[2]).trim().toLowerCase();\n  return value.length > 0 ? value : undefined;\n}\n\n/**\n * Parses a `Content-Length` header value.\n *\n * Returns `undefined` for an absent, non-numeric, negative, or non-integer value rather than\n * guessing: a malformed length is not evidence of a size, and the streaming cap does not need\n * it. It is a fast-reject path only.\n * @internal\n */\nexport function parseContentLength(value: string | undefined): number | undefined {\n  if (value === undefined) {\n    return undefined;\n  }\n  const trimmed = value.trim();\n  if (!/^\\d+$/.test(trimmed)) {\n    return undefined;\n  }\n  const parsed = Number(trimmed);\n  return Number.isSafeInteger(parsed) ? parsed : undefined;\n}\n"]}

package/lib/packlets/safer-fetch/deadline.d.ts

@@ -0,0 +1,138 @@
+import type { FetchFailureReason, FetchTimeoutPhase } from './failureReason';
+/**
+ * Why a {@link DeadlineWatch} stopped waiting.
+ * @internal
+ */
+export type DeadlineStopCause = 'caller-aborted' | FetchTimeoutPhase;
+/**
+ * The outcome of racing a promise against the deadlines.
+ * @internal
+ */
+export type DeadlineRace<T> = {
+    readonly stopped: false;
+    readonly value: T;
+} | {
+    readonly stopped: true;
+    readonly cause: DeadlineStopCause;
+};
+/**
+ * Composes the caller's cancellation signal with an overall deadline and a headers deadline
+ * into one `AbortSignal`, and remembers which of the three stopped the call.
+ *
+ * @remarks
+ * The composition is done with a plain `AbortController` and listeners rather than
+ * `AbortSignal.any`, so there is no runtime-version floor to state and no feature-detection
+ * branch that only one of the two runtimes would ever execute.
+ *
+ * The overall deadline covers the connect, the headers, and the body read, and it is what
+ * stops a response that dribbles one byte every 25 seconds — such a response passes every
+ * per-read check and never trips a connect timeout.
+ * @internal
+ */
+export declare class DeadlineWatch {
+    private _controller;
+    private readonly _startedAt;
+    private readonly _timeoutMs;
+    private readonly _headersTimeoutMs;
+    private readonly _callerSignal;
+    private readonly _onCallerAbort;
+    private _overallTimer;
+    private _headersTimer;
+    private _cause;
+    /**
+     * Whether the current stop ends the whole call rather than just this attempt. The overall
+     * deadline and the caller's signal are terminal; the per-attempt headers deadline is not.
+     */
+    private _terminal;
+    private _inBodyPhase;
+    private readonly _waiters;
+    constructor(timeoutMs: number, headersTimeoutMs: number, callerSignal?: AbortSignal);
+    /** The composed signal to hand to the transport. */
+    get signal(): AbortSignal;
+    /** Why the call was stopped, or `undefined` while it is still running. */
+    get cause(): DeadlineStopCause | undefined;
+    /**
+     * Records that a new attempt is starting: the headers deadline is (re)armed from now.
+     *
+     * @remarks
+     * The headers deadline is **per attempt**, and a redirect walk makes more than one. Without a
+     * re-arm, {@link DeadlineWatch.headersReceived} on the first hop would retire the headers
+     * deadline for the whole call, leaving every later hop bounded only by the overall deadline —
+     * so a chain whose second host simply never answers would hang for the overall budget instead
+     * of failing as `timeout.phase === 'headers'`.
+     *
+     * Called before the address guard rather than before the connect, because guard evaluation
+     * (a DNS resolution, in the shipped guard) is part of the time a caller waits for a usable
+     * response and is deliberately inside this budget.
+     *
+     * The overall deadline is untouched: it spans the whole call, redirects included.
+     */
+    attemptStarted(): void;
+    /**
+     * Records that response headers have arrived: the headers deadline no longer applies to this
+     * attempt, and a subsequent overall-deadline expiry is a body-phase timeout rather than an
+     * overall one.
+     */
+    headersReceived(): void;
+    /**
+     * Races a promise against the deadlines. A stopped race reports the cause; the underlying
+     * promise is abandoned, not cancelled — the caller is responsible for releasing whatever
+     * resource it represents (a response body reader, in practice).
+     *
+     * @remarks
+     * The waiter is removed once the race settles. A body read calls this once per chunk, so a
+     * waiter set that only grew would be a leak proportional to the number of chunks — in the
+     * exact code path whose job is to bound what a hostile response can cost the process.
+     */
+    race<T>(promise: Promise<T>): Promise<DeadlineRace<T>>;
+    /**
+     * Records that an attempt has ended and another may follow: the headers deadline is disarmed,
+     * and a stop that ended only *that attempt* is cleared.
+     *
+     * @remarks
+     * **The headers deadline is attempt-scoped and the overall deadline is not.** A retry attempt
+     * that timed out waiting for headers must not leave the whole call stopped — without this,
+     * retry could never answer a `timeout.phase === 'headers'` failure, which is precisely the
+     * failure retry exists for. The composed signal is replaced rather than reset, because an
+     * aborted `AbortSignal` cannot be un-aborted.
+     *
+     * The overall deadline and the caller's signal are **terminal** by contrast: neither is about
+     * one attempt, and clearing either would let a retry loop outlive the budget the caller set or
+     * ignore the cancellation the caller requested. A terminal stop survives this call, so the
+     * backoff that follows is answered immediately and the call ends.
+     *
+     * Called between attempts rather than at the start of one, so the interval spent in a backoff
+     * is bounded by the overall deadline alone — arming a headers deadline over a sleep during
+     * which no request is outstanding would stop the call for a response nobody is waiting for.
+     */
+    attemptEnded(): void;
+    /**
+     * How much of the overall deadline is left, in milliseconds, never below zero.
+     *
+     * @remarks
+     * Read by the retry scheduler, which must not sleep past a deadline it is already inside:
+     * "the overall budget is the ceiling" is only enforceable if the remaining budget is
+     * observable.
+     */
+    get remainingMs(): number;
+    /**
+     * Waits for the given number of milliseconds, or until the call is stopped — whichever comes
+     * first.
+     *
+     * @remarks
+     * Backing the retry delay with the same watch the request races against is what keeps a
+     * caller's `abort()` responsive *between* attempts. A bare `setTimeout` would leave a caller
+     * who cancelled during a five-second backoff waiting out the full delay before being told the
+     * call was aborted.
+     *
+     * The timer is cleared however the wait ends, so a stopped delay leaves nothing pending —
+     * which matters in a test runner, where a stray timer keeps the process alive.
+     */
+    delay(ms: number): Promise<DeadlineRace<true>>;
+    /** Builds the failure reason corresponding to why the call was stopped. */
+    toFailureReason(cause: DeadlineStopCause): FetchFailureReason;
+    /** Clears timers and listeners. Safe to call more than once. */
+    dispose(): void;
+    private _stop;
+}
+//# sourceMappingURL=deadline.d.ts.map

package/lib/packlets/safer-fetch/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/deadline.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE7E;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IACtB;IAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC9C;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0B;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAa;IAE5C,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,MAAM,CAAgC;IAC9C;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;gBAEhD,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW;IAuB1F,oDAAoD;IACpD,IAAW,MAAM,IAAI,WAAW,CAE/B;IAED,0EAA0E;IAC1E,IAAW,KAAK,IAAI,iBAAiB,GAAG,SAAS,CAEhD;IAED;;;;;;;;;;;;;;;OAeG;IACI,cAAc,IAAI,IAAI;IAW7B;;;;OAIG;IACI,eAAe,IAAI,IAAI;IAQ9B;;;;;;;;;OASG;IACU,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAoBnE;;;;;;;;;;;;;;;;;;;OAmBG;IACI,YAAY,IAAI,IAAI;IAoB3B;;;;;;;OAOG;IACH,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;;;;;;;;;;;OAYG;IACU,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAe3D,2EAA2E;IACpE,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB;IAYpE,gEAAgE;IACzD,OAAO,IAAI,IAAI;IAetB,OAAO,CAAC,KAAK;CAkBd"}