@dbx-tools/shared-core 0.3.43 → 0.4.0

package/lib/src/hash.js

@@ -0,0 +1,274 @@
+/**
+ * Short, deterministic non-cryptographic hashing and id minting.
+ *
+ * {@link fnvHash} / {@link fnvHashWithOptions} produce a stable FNV-1a
+ * digest over arbitrary structured input; {@link toBase32} encodes a
+ * 32-bit integer compactly; {@link id} mints v4 UUIDs (or short hex
+ * slices). All browser-safe - built on `globalThis.crypto`, no
+ * `node:crypto` import. **Never** use these for tokens, signatures, or
+ * anything an attacker shouldn't be able to forge.
+ *
+ * @module
+ */
+/**
+ * Mint a v4 UUID, or a short hex slice of one when `length` is set.
+ *
+ * - `id()` returns a full RFC 4122 v4 UUID. Pick this when global
+ *   uniqueness matters: long-running batches, ids that cross a storage /
+ *   process boundary, anything that may collide across machines.
+ * - `id(length)` returns the first `length` hex chars of a fresh UUID
+ *   with dashes stripped (e.g. `id(8) -> "a3f1c92b"`). Pick this when the
+ *   id has to be short / typeable and the scope is bounded - cache keys
+ *   local to a request, slug suffixes. `length <= 0` throws.
+ *
+ * Prefers `crypto.randomUUID()`, which covers Node (>= 19) and a browser on
+ * a secure origin. Browsers gate `randomUUID` behind a secure context, so a
+ * page served over plain http (a LAN dev host) has `crypto` but not that
+ * method; this package is browser-safe and its callers mint ids on the
+ * render path, so it degrades instead of throwing: `getRandomValues` when
+ * present, else `Math.random`. Every branch returns a well-formed v4 UUID -
+ * only the entropy source differs.
+ *
+ * @example
+ * id();   // "123e4567-e89b-12d3-a456-426614174000"
+ * id(8);  // "a3f1c92b"
+ */
+export function id(length) {
+    if (length !== undefined && length <= 0) {
+        throw new Error("Length must be greater than 0");
+    }
+    const id = uuidV4();
+    if (length !== undefined) {
+        return id.replace(/-/g, "").slice(0, length);
+    }
+    return id;
+}
+/** A v4 UUID from the strongest randomness source this runtime offers. */
+function uuidV4() {
+    const webCrypto = globalThis.crypto;
+    if (typeof webCrypto?.randomUUID === "function")
+        return webCrypto.randomUUID();
+    const bytes = new Uint8Array(16);
+    if (typeof webCrypto?.getRandomValues === "function") {
+        webCrypto.getRandomValues(bytes);
+    }
+    else {
+        for (let i = 0; i < bytes.length; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    }
+    // Stamp the version (4) and variant (10xx) fields RFC 4122 requires.
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/**
+ * Short, deterministic FNV-1a hash over one or more values. Wraps
+ * {@link fnvHashWithOptions} with all defaults: 6-char Crockford-style
+ * base-32 output (digits + lowercase, minus `i`/`l`/`o`/`u`).
+ * Browser-safe (no `node:crypto`).
+ *
+ * Accepts any mix of primitives, arrays, plain objects, `Map`s, and
+ * `Set`s; nested structures are walked deterministically so the hash is
+ * order-stable for objects / maps / sets and order-sensitive for arrays.
+ * Cycles are detected and folded into a `circular:` marker.
+ *
+ * Use for cache keys, slug suffixes, log correlation ids, and other
+ * "give me something short and stable" needs - **never** for tokens or
+ * signatures. FNV-1a is a non-cryptographic hash.
+ *
+ * @example
+ * fnvHash("databricks-claude-sonnet-4-6"); // "k3p9q7"
+ * fnvHash([1, 2, 3]) !== fnvHash([3, 2, 1]);
+ */
+export function fnvHash(...values) {
+    return fnvHashWithOptions({}, ...values);
+}
+/**
+ * Configurable counterpart to {@link fnvHash}.
+ *
+ * Options:
+ *   - `length` (default `6`): number of base-32 chars to return. Capped
+ *     at 7 - the underlying digest is 32 bits, which base-32-encodes to
+ *     at most 7 chars. Output is left-padded with the alphabet's zero
+ *     character so short digests still hit the requested width.
+ *   - `alphabet` (default Crockford-style
+ *     `"0123456789abcdefghjkmnpqrstvwxyz"`): 32 distinct characters used
+ *     to encode the digest. Throws when not exactly 32 unique chars.
+ *   - `digest` (default `0x811c9dc5`, the FNV-1a offset basis): the seed
+ *     the running digest starts from. Useful for namespacing so
+ *     otherwise-identical inputs hashed under different namespaces never
+ *     collide, and for chaining hashes across pipeline stages.
+ *
+ * The hash is **not** stable across changes to the alphabet or `length` -
+ * those tune the output, not the digest input.
+ *
+ * @example
+ * fnvHashWithOptions({ length: 4 }, "user@example.com");        // 4 chars
+ * fnvHashWithOptions({ digest: nsHash }, key) !== fnvHash(key); // namespaced
+ */
+export function fnvHashWithOptions(options = {}, ...values) {
+    const { length = 6 } = options;
+    let digest = options.digest ?? 0x811c9dc5;
+    for (const value of hashAttributes(values)) {
+        for (let i = 0; i < value.length; i++) {
+            digest ^= value.charCodeAt(i);
+            digest = Math.imul(digest, 0x01000193);
+        }
+    }
+    const alphabet = base32Alphabet(options.alphabet);
+    return toBase32(digest, alphabet, true).padStart(7, alphabet[0]).slice(0, Math.min(length, 7));
+}
+/**
+ * Walk an arbitrary value as a stream of canonicalized string tokens
+ * suitable for feeding into a streaming hash like FNV-1a. Used by
+ * {@link fnvHashWithOptions} so structured inputs hash deterministically
+ * without a stringification round-trip through `JSON.stringify` (which
+ * silently drops `undefined`, has no canonical key order, and can't
+ * represent cycles).
+ *
+ * Canonicalization rules:
+ *
+ *   - `null` / `undefined` collapse to `null:`.
+ *   - Primitives (`string` / `number` / `boolean`) are tagged with their
+ *     `typeof` so `"1"` and `1` produce different digests.
+ *   - Arrays preserve order: `[1,2]` and `[2,1]` hash differently.
+ *   - Plain objects emit keys in lexical order of each key's own
+ *     hash-token stream, so `{a:1,b:2}` and `{b:2,a:1}` collapse.
+ *   - `Map` keys go through the same key-sort path as objects.
+ *   - `Set`s are sorted by each element's hash-token stream and emit only
+ *     the elements, so insertion order doesn't leak into the digest.
+ *   - Cycles emit `circular:` and stop descending.
+ *   - Anything else falls through to a `${typeof}:${JSON.stringify}`
+ *     token.
+ */
+function* hashAttributes(input, seen) {
+    if (input === null || input === undefined) {
+        yield "null:";
+        return;
+    }
+    const inputType = typeof input;
+    if (inputType === "string" || inputType === "number" || inputType === "boolean") {
+        yield `${inputType}:`;
+        yield input.toString();
+        return;
+    }
+    seen ??= new WeakSet();
+    if (inputType === "object") {
+        if (seen.has(input)) {
+            yield "circular:";
+            return;
+        }
+        seen.add(input);
+        try {
+            if (Array.isArray(input)) {
+                yield "[";
+                for (const item of input) {
+                    yield* hashAttributes(item, seen);
+                    yield ",";
+                }
+                yield "]";
+                return;
+            }
+            else {
+                const hashAttributeKeys = (keys) => {
+                    return keys
+                        .map((key) => {
+                        const keyHashAttributes = [...hashAttributes(key, seen)];
+                        return {
+                            key,
+                            keyHashAttributes,
+                            sortKey: keyHashAttributes.join("\0"),
+                        };
+                    })
+                        .sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+                };
+                if (input instanceof Set) {
+                    yield "[";
+                    for (const hashAttributeKey of hashAttributeKeys(Array.from(input))) {
+                        yield* hashAttributeKey.keyHashAttributes;
+                        yield ",";
+                    }
+                    yield "]";
+                    return;
+                }
+                else {
+                    yield "{";
+                    const keys = input instanceof Map ? Array.from(input.keys()) : Object.keys(input);
+                    for (const hashAttributeKey of hashAttributeKeys(keys)) {
+                        const value = input instanceof Map
+                            ? input.get(hashAttributeKey.key)
+                            : input[hashAttributeKey.key];
+                        yield* hashAttributeKey.keyHashAttributes;
+                        yield ":";
+                        yield* hashAttributes(value, seen);
+                        yield ",";
+                    }
+                    yield "}";
+                    return;
+                }
+            }
+        }
+        finally {
+            seen.delete(input);
+        }
+    }
+    yield `${inputType}:${JSON.stringify(input)}`;
+}
+/**
+ * Default Crockford-style base-32 alphabet: digits `0-9` then lowercase
+ * letters with `i`, `l`, `o`, `u` removed. Output is safe to drop into
+ * URLs, filenames, and `[A-Za-z0-9_-]`-bound marker captures.
+ */
+const BASE32_ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
+/**
+ * Resolve a caller-supplied alphabet against the default. Returns the
+ * default when the caller passed nothing; otherwise validates the
+ * override is exactly 32 unique chars. Throws on bad alphabets so callers
+ * fail fast instead of producing silently-degraded encodings.
+ */
+function base32Alphabet(alphabet) {
+    if (alphabet === undefined) {
+        return BASE32_ALPHABET;
+    }
+    else if (new Set(alphabet).size !== 32) {
+        throw new Error("Base32 alphabet must contain 32 unique characters");
+    }
+    return alphabet;
+}
+/**
+ * Encode a 32-bit unsigned integer as base-32 using the default
+ * Crockford-style alphabet (or `alphabet` when provided). The encoding
+ * has **no** zero-padding by default - `toBase32(0)` returns the
+ * alphabet's zero character, otherwise the result is the minimal number
+ * of digits that fits the value. Pad / truncate at the call site when you
+ * need a fixed width.
+ *
+ * `disableAlphabetValidation` skips the unique-32-char check for hot
+ * paths that have already validated the alphabet. The function still
+ * requires `alphabet.length === 32` either way.
+ *
+ * @example
+ * toBase32(0);        // "0"
+ * toBase32(31);       // "z"
+ * toBase32(0xdeadbe); // "6vmtw"
+ */
+export function toBase32(value, alphabet, disableAlphabetValidation) {
+    if (!disableAlphabetValidation) {
+        alphabet = base32Alphabet(alphabet);
+    }
+    if (alphabet.length !== 32) {
+        throw new Error(`Base32 alphabet must contain exactly 32 characters, got ${alphabet.length}`);
+    }
+    value >>>= 0;
+    if (value === 0) {
+        return alphabet[0];
+    }
+    let result = "";
+    while (value > 0) {
+        result = alphabet[value & 31] + result;
+        value >>>= 5;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Short, deterministic non-cryptographic hashing and id minting.\n *\n * {@link fnvHash} / {@link fnvHashWithOptions} produce a stable FNV-1a\n * digest over arbitrary structured input; {@link toBase32} encodes a\n * 32-bit integer compactly; {@link id} mints v4 UUIDs (or short hex\n * slices). All browser-safe - built on `globalThis.crypto`, no\n * `node:crypto` import. **Never** use these for tokens, signatures, or\n * anything an attacker shouldn't be able to forge.\n *\n * @module\n */\n\n/**\n * Mint a v4 UUID, or a short hex slice of one when `length` is set.\n *\n * - `id()` returns a full RFC 4122 v4 UUID. Pick this when global\n *   uniqueness matters: long-running batches, ids that cross a storage /\n *   process boundary, anything that may collide across machines.\n * - `id(length)` returns the first `length` hex chars of a fresh UUID\n *   with dashes stripped (e.g. `id(8) -> \"a3f1c92b\"`). Pick this when the\n *   id has to be short / typeable and the scope is bounded - cache keys\n *   local to a request, slug suffixes. `length <= 0` throws.\n *\n * Prefers `crypto.randomUUID()`, which covers Node (>= 19) and a browser on\n * a secure origin. Browsers gate `randomUUID` behind a secure context, so a\n * page served over plain http (a LAN dev host) has `crypto` but not that\n * method; this package is browser-safe and its callers mint ids on the\n * render path, so it degrades instead of throwing: `getRandomValues` when\n * present, else `Math.random`. Every branch returns a well-formed v4 UUID -\n * only the entropy source differs.\n *\n * @example\n * id();   // \"123e4567-e89b-12d3-a456-426614174000\"\n * id(8);  // \"a3f1c92b\"\n */\nexport function id(length?: number): string {\n  if (length !== undefined && length <= 0) {\n    throw new Error(\"Length must be greater than 0\");\n  }\n  const id = uuidV4();\n  if (length !== undefined) {\n    return id.replace(/-/g, \"\").slice(0, length);\n  }\n  return id;\n}\n\n/**\n * The two `crypto` members this module uses, declared structurally. `Crypto`\n * itself is not nameable here: this package compiles with neither the DOM nor\n * the Node lib, and a consumer that does pull in Node types resolves `Crypto`\n * to a global value rather than a type.\n */\ntype CryptoLike = {\n  randomUUID?: () => string;\n  getRandomValues?: (bytes: Uint8Array) => unknown;\n};\n\n/** A v4 UUID from the strongest randomness source this runtime offers. */\nfunction uuidV4(): string {\n  const webCrypto = globalThis.crypto as CryptoLike | undefined;\n  if (typeof webCrypto?.randomUUID === \"function\") return webCrypto.randomUUID();\n\n  const bytes = new Uint8Array(16);\n  if (typeof webCrypto?.getRandomValues === \"function\") {\n    webCrypto.getRandomValues(bytes);\n  } else {\n    for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);\n  }\n  // Stamp the version (4) and variant (10xx) fields RFC 4122 requires.\n  bytes[6] = (bytes[6]! & 0x0f) | 0x40;\n  bytes[8] = (bytes[8]! & 0x3f) | 0x80;\n\n  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n}\n\n/**\n * Short, deterministic FNV-1a hash over one or more values. Wraps\n * {@link fnvHashWithOptions} with all defaults: 6-char Crockford-style\n * base-32 output (digits + lowercase, minus `i`/`l`/`o`/`u`).\n * Browser-safe (no `node:crypto`).\n *\n * Accepts any mix of primitives, arrays, plain objects, `Map`s, and\n * `Set`s; nested structures are walked deterministically so the hash is\n * order-stable for objects / maps / sets and order-sensitive for arrays.\n * Cycles are detected and folded into a `circular:` marker.\n *\n * Use for cache keys, slug suffixes, log correlation ids, and other\n * \"give me something short and stable\" needs - **never** for tokens or\n * signatures. FNV-1a is a non-cryptographic hash.\n *\n * @example\n * fnvHash(\"databricks-claude-sonnet-4-6\"); // \"k3p9q7\"\n * fnvHash([1, 2, 3]) !== fnvHash([3, 2, 1]);\n */\nexport function fnvHash(...values: unknown[]): string {\n  return fnvHashWithOptions({}, ...values);\n}\n\n/**\n * Configurable counterpart to {@link fnvHash}.\n *\n * Options:\n *   - `length` (default `6`): number of base-32 chars to return. Capped\n *     at 7 - the underlying digest is 32 bits, which base-32-encodes to\n *     at most 7 chars. Output is left-padded with the alphabet's zero\n *     character so short digests still hit the requested width.\n *   - `alphabet` (default Crockford-style\n *     `\"0123456789abcdefghjkmnpqrstvwxyz\"`): 32 distinct characters used\n *     to encode the digest. Throws when not exactly 32 unique chars.\n *   - `digest` (default `0x811c9dc5`, the FNV-1a offset basis): the seed\n *     the running digest starts from. Useful for namespacing so\n *     otherwise-identical inputs hashed under different namespaces never\n *     collide, and for chaining hashes across pipeline stages.\n *\n * The hash is **not** stable across changes to the alphabet or `length` -\n * those tune the output, not the digest input.\n *\n * @example\n * fnvHashWithOptions({ length: 4 }, \"user@example.com\");        // 4 chars\n * fnvHashWithOptions({ digest: nsHash }, key) !== fnvHash(key); // namespaced\n */\nexport function fnvHashWithOptions(\n  options: { length?: number; alphabet?: string; digest?: number } = {},\n  ...values: unknown[]\n): string {\n  const { length = 6 } = options;\n\n  let digest = options.digest ?? 0x811c9dc5;\n\n  for (const value of hashAttributes(values)) {\n    for (let i = 0; i < value.length; i++) {\n      digest ^= value.charCodeAt(i);\n      digest = Math.imul(digest, 0x01000193);\n    }\n  }\n  const alphabet = base32Alphabet(options.alphabet);\n  return toBase32(digest, alphabet, true).padStart(7, alphabet[0]).slice(0, Math.min(length, 7));\n}\n\n/**\n * Walk an arbitrary value as a stream of canonicalized string tokens\n * suitable for feeding into a streaming hash like FNV-1a. Used by\n * {@link fnvHashWithOptions} so structured inputs hash deterministically\n * without a stringification round-trip through `JSON.stringify` (which\n * silently drops `undefined`, has no canonical key order, and can't\n * represent cycles).\n *\n * Canonicalization rules:\n *\n *   - `null` / `undefined` collapse to `null:`.\n *   - Primitives (`string` / `number` / `boolean`) are tagged with their\n *     `typeof` so `\"1\"` and `1` produce different digests.\n *   - Arrays preserve order: `[1,2]` and `[2,1]` hash differently.\n *   - Plain objects emit keys in lexical order of each key's own\n *     hash-token stream, so `{a:1,b:2}` and `{b:2,a:1}` collapse.\n *   - `Map` keys go through the same key-sort path as objects.\n *   - `Set`s are sorted by each element's hash-token stream and emit only\n *     the elements, so insertion order doesn't leak into the digest.\n *   - Cycles emit `circular:` and stop descending.\n *   - Anything else falls through to a `${typeof}:${JSON.stringify}`\n *     token.\n */\nfunction* hashAttributes(input: any, seen?: WeakSet<object>): Generator<string> {\n  if (input === null || input === undefined) {\n    yield \"null:\";\n    return;\n  }\n\n  const inputType = typeof input;\n  if (inputType === \"string\" || inputType === \"number\" || inputType === \"boolean\") {\n    yield `${inputType}:`;\n    yield input.toString();\n    return;\n  }\n  seen ??= new WeakSet<object>();\n\n  if (inputType === \"object\") {\n    if (seen.has(input)) {\n      yield \"circular:\";\n      return;\n    }\n    seen.add(input);\n    try {\n      if (Array.isArray(input)) {\n        yield \"[\";\n        for (const item of input) {\n          yield* hashAttributes(item, seen);\n          yield \",\";\n        }\n        yield \"]\";\n        return;\n      } else {\n        const hashAttributeKeys = (keys: Array<unknown>) => {\n          return keys\n            .map((key) => {\n              const keyHashAttributes = [...hashAttributes(key, seen)];\n              return {\n                key,\n                keyHashAttributes,\n                sortKey: keyHashAttributes.join(\"\\0\"),\n              };\n            })\n            .sort((a, b) => a.sortKey.localeCompare(b.sortKey));\n        };\n        if (input instanceof Set) {\n          yield \"[\";\n          for (const hashAttributeKey of hashAttributeKeys(Array.from(input))) {\n            yield* hashAttributeKey.keyHashAttributes;\n            yield \",\";\n          }\n          yield \"]\";\n          return;\n        } else {\n          yield \"{\";\n          const keys = input instanceof Map ? Array.from(input.keys()) : Object.keys(input);\n          for (const hashAttributeKey of hashAttributeKeys(keys)) {\n            const value =\n              input instanceof Map\n                ? input.get(hashAttributeKey.key)\n                : input[hashAttributeKey.key as keyof typeof input];\n            yield* hashAttributeKey.keyHashAttributes;\n            yield \":\";\n            yield* hashAttributes(value, seen);\n            yield \",\";\n          }\n          yield \"}\";\n          return;\n        }\n      }\n    } finally {\n      seen.delete(input);\n    }\n  }\n  yield `${inputType}:${JSON.stringify(input)}`;\n}\n\n/**\n * Default Crockford-style base-32 alphabet: digits `0-9` then lowercase\n * letters with `i`, `l`, `o`, `u` removed. Output is safe to drop into\n * URLs, filenames, and `[A-Za-z0-9_-]`-bound marker captures.\n */\nconst BASE32_ALPHABET = \"0123456789abcdefghjkmnpqrstvwxyz\";\n\n/**\n * Resolve a caller-supplied alphabet against the default. Returns the\n * default when the caller passed nothing; otherwise validates the\n * override is exactly 32 unique chars. Throws on bad alphabets so callers\n * fail fast instead of producing silently-degraded encodings.\n */\nfunction base32Alphabet(alphabet?: string): string {\n  if (alphabet === undefined) {\n    return BASE32_ALPHABET;\n  } else if (new Set(alphabet).size !== 32) {\n    throw new Error(\"Base32 alphabet must contain 32 unique characters\");\n  }\n  return alphabet;\n}\n\n/**\n * Encode a 32-bit unsigned integer as base-32 using the default\n * Crockford-style alphabet (or `alphabet` when provided). The encoding\n * has **no** zero-padding by default - `toBase32(0)` returns the\n * alphabet's zero character, otherwise the result is the minimal number\n * of digits that fits the value. Pad / truncate at the call site when you\n * need a fixed width.\n *\n * `disableAlphabetValidation` skips the unique-32-char check for hot\n * paths that have already validated the alphabet. The function still\n * requires `alphabet.length === 32` either way.\n *\n * @example\n * toBase32(0);        // \"0\"\n * toBase32(31);       // \"z\"\n * toBase32(0xdeadbe); // \"6vmtw\"\n */\nexport function toBase32(\n  value: number,\n  alphabet?: string,\n  disableAlphabetValidation?: boolean,\n): string {\n  if (!disableAlphabetValidation) {\n    alphabet = base32Alphabet(alphabet);\n  }\n  if (alphabet!.length !== 32) {\n    throw new Error(`Base32 alphabet must contain exactly 32 characters, got ${alphabet!.length}`);\n  }\n  value >>>= 0;\n  if (value === 0) {\n    return alphabet![0]!;\n  }\n  let result = \"\";\n  while (value > 0) {\n    result = alphabet![value & 31] + result;\n    value >>>= 5;\n  }\n  return result;\n}\n"]}

package/lib/src/http.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Framework-agnostic readers for HTTP requests, shared across AppKit
+ * plugins: header and cookie extraction. Works uniformly across
+ * Express, Node `IncomingMessage`, WHATWG `Request` / `Response` /
+ * `Headers`, Hono, and any object that exposes a `headers` field of one
+ * of those shapes. Dependency-free and browser-safe so it can run in
+ * either a server or a client bundle.
+ *
+ * URL path matching lives in `./net.browser.ts` (`pathMatch`).
+ *
+ * @module
+ */
+/**
+ * Anything that contains HTTP headers. Accepts:
+ *
+ * - A WHATWG `Headers` instance (fetch / undici / Hono `c.req.raw.headers`).
+ * - A header record (`Record<string, string | string[] | undefined>`),
+ *   Node / Express style.
+ * - Any object with a `headers` field of one of the above. This covers
+ *   Express `req`, Node `IncomingMessage`, WHATWG `Request` / `Response`,
+ *   Hono `c.req.raw`, and similar shapes.
+ */
+export type HeaderLike = Headers | HeaderRecord | {
+    headers: Headers | HeaderRecord;
+};
+/**
+ * Single header value as exposed by Node `IncomingMessage.headers` and
+ * Express `req.headers` (string for most headers, array for repeated
+ * headers such as `Set-Cookie`).
+ */
+type HeaderValueLike = string[] | string | undefined;
+/** Header bag with case-insensitive keys (Node / Express style). */
+type HeaderRecord = Record<string, HeaderValueLike>;
+/**
+ * Invokes `consumer` once per value for `headerName`, case-insensitive.
+ *
+ * - **Record input:** if the field is an array (e.g. repeated `Set-Cookie`),
+ *   `consumer` runs once per array item.
+ * - **`Headers` input:** uses `get(name)` (which spec-joins repeats with
+ *   `, `) except for `Set-Cookie`, which uses `getSetCookie()` so each
+ *   cookie is delivered separately.
+ *
+ * @example
+ * forEachHeaderValue(req, "x-trace-id", (v) => spans.push(v));     // Express
+ * forEachHeaderValue(c.req.raw, "set-cookie", (v) => log(v));      // Hono
+ * forEachHeaderValue(headersInstance, "cookie", parse);            // fetch
+ */
+export declare function forEachHeaderValue(input: HeaderLike | null | undefined, headerName: string, consumer: (value: string) => void): void;
+/**
+ * Parses `Cookie` header values into a name-to-value map (URI-decoded).
+ *
+ * Accepts:
+ *
+ * - A raw `Cookie` string (`"a=1; b=2"`).
+ * - An array of such strings (e.g. multiple `Cookie` headers).
+ * - Any {@link HeaderLike}: a WHATWG `Headers` instance, a header
+ *   record, or a request-like object with a `headers` field.
+ *
+ * First occurrence of each cookie name wins; later duplicates are ignored.
+ *
+ * @example
+ * parseCookies("session=abc; theme=dark");
+ * // { session: "abc", theme: "dark" }
+ *
+ * parseCookies(req);              // Express / Node
+ * parseCookies(c.req.raw);        // Hono
+ * parseCookies(request);          // fetch Request
+ * parseCookies(request.headers);  // WHATWG Headers directly
+ */
+export declare function parseCookies(input: HeaderLike | HeaderValueLike | null): Record<string, string>;
+/**
+ * Build an `Error` describing a failed `fetch` response: status line,
+ * the URL(s) involved (the requested `url` and the final `response.url`
+ * after redirects, de-duplicated), and a truncated snapshot of the
+ * response body. Reads the body defensively - a body that can't be read
+ * is simply omitted. Call only on a non-`ok` response.
+ */
+export declare function createFetchError(response: Response, url?: string): Promise<Error>;
+export {};

package/lib/src/http.js

@@ -0,0 +1,189 @@
+/**
+ * Framework-agnostic readers for HTTP requests, shared across AppKit
+ * plugins: header and cookie extraction. Works uniformly across
+ * Express, Node `IncomingMessage`, WHATWG `Request` / `Response` /
+ * `Headers`, Hono, and any object that exposes a `headers` field of one
+ * of those shapes. Dependency-free and browser-safe so it can run in
+ * either a server or a client bundle.
+ *
+ * URL path matching lives in `./net.browser.ts` (`pathMatch`).
+ *
+ * @module
+ */
+// ────────────────────────────────────────────────────────────────
+// Header helpers
+// ────────────────────────────────────────────────────────────────
+/**
+ * Invokes `consumer` once per value for `headerName`, case-insensitive.
+ *
+ * - **Record input:** if the field is an array (e.g. repeated `Set-Cookie`),
+ *   `consumer` runs once per array item.
+ * - **`Headers` input:** uses `get(name)` (which spec-joins repeats with
+ *   `, `) except for `Set-Cookie`, which uses `getSetCookie()` so each
+ *   cookie is delivered separately.
+ *
+ * @example
+ * forEachHeaderValue(req, "x-trace-id", (v) => spans.push(v));     // Express
+ * forEachHeaderValue(c.req.raw, "set-cookie", (v) => log(v));      // Hono
+ * forEachHeaderValue(headersInstance, "cookie", parse);            // fetch
+ */
+export function forEachHeaderValue(input, headerName, consumer) {
+    const headers = unwrap(input);
+    if (!headers)
+        return;
+    const target = headerName.toLowerCase();
+    if (isHeaders(headers)) {
+        // `Headers.get` joins repeated values with `, ` per spec, which
+        // mangles `Set-Cookie` (cookies legitimately contain commas in
+        // their `expires=` attribute). `getSetCookie` is the dedicated
+        // splitter and is the only safe path for that header.
+        if (target === "set-cookie") {
+            for (const value of headers.getSetCookie())
+                consumer(value);
+            return;
+        }
+        const value = headers.get(headerName);
+        if (value !== null)
+            consumer(value);
+        return;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (value == null || key.toLowerCase() !== target)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                consumer(item);
+        }
+        else {
+            consumer(value);
+        }
+    }
+}
+/**
+ * Parses `Cookie` header values into a name-to-value map (URI-decoded).
+ *
+ * Accepts:
+ *
+ * - A raw `Cookie` string (`"a=1; b=2"`).
+ * - An array of such strings (e.g. multiple `Cookie` headers).
+ * - Any {@link HeaderLike}: a WHATWG `Headers` instance, a header
+ *   record, or a request-like object with a `headers` field.
+ *
+ * First occurrence of each cookie name wins; later duplicates are ignored.
+ *
+ * @example
+ * parseCookies("session=abc; theme=dark");
+ * // { session: "abc", theme: "dark" }
+ *
+ * parseCookies(req);              // Express / Node
+ * parseCookies(c.req.raw);        // Hono
+ * parseCookies(request);          // fetch Request
+ * parseCookies(request.headers);  // WHATWG Headers directly
+ */
+export function parseCookies(input) {
+    if (input == null)
+        return {};
+    const out = {};
+    if (typeof input === "string") {
+        parseCookieString(input, out);
+        return out;
+    }
+    if (Array.isArray(input)) {
+        for (const item of input) {
+            if (typeof item === "string")
+                parseCookieString(item, out);
+        }
+        return out;
+    }
+    forEachHeaderValue(input, "cookie", (value) => {
+        parseCookieString(value, out);
+    });
+    return out;
+}
+/**
+ * Build an `Error` describing a failed `fetch` response: status line,
+ * the URL(s) involved (the requested `url` and the final `response.url`
+ * after redirects, de-duplicated), and a truncated snapshot of the
+ * response body. Reads the body defensively - a body that can't be read
+ * is simply omitted. Call only on a non-`ok` response.
+ */
+export async function createFetchError(response, url) {
+    let body = "";
+    try {
+        body = (await response.text()).trim();
+    }
+    catch {
+        // ignore
+    }
+    if (body.length > 1_000) {
+        body = `${body.slice(0, 1_000)}…`;
+    }
+    const urlSummary = [...new Set([url, response.url].filter(Boolean))].join(" -> ");
+    return new Error([
+        `Request failed.`,
+        `${response.status} ${response.statusText}`,
+        `${urlSummary}`,
+        body && `Response:\n${body}`,
+    ]
+        .filter(Boolean)
+        .join("\n"));
+}
+// ────────────────────────────────────────────────────────────────
+// Private helpers
+// ────────────────────────────────────────────────────────────────
+/**
+ * Type guard for WHATWG `Headers`. Duck-types on the two methods that
+ * matter to this module (`get` and `getSetCookie`) so polyfilled
+ * implementations and Hono's `HonoHeaders` are accepted without
+ * pulling `Headers` in as a hard dependency.
+ */
+function isHeaders(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.get === "function" &&
+        typeof value.getSetCookie === "function");
+}
+/**
+ * `HeaderRecord` is an index signature, so `"headers" in input` cannot
+ * discriminate it from the wrapped `{ headers }` shape at the type
+ * level. This guard inspects the runtime value of `headers`: only
+ * objects (`Headers` or a nested record) qualify as the wrapper shape,
+ * never stray string/array values that happen to live under a `headers`
+ * key on a header record.
+ */
+function isWrapped(input) {
+    const headers = input.headers;
+    return headers != null && typeof headers === "object" && !Array.isArray(headers);
+}
+/**
+ * Parse a single `Cookie`-style header string (`"a=1; b=2"`) into
+ * `out`. Names without a value are skipped; first occurrence wins so
+ * later duplicates are ignored. Cookie values are URI-decoded.
+ */
+function parseCookieString(input, out) {
+    for (const part of input.split(";")) {
+        const eq = part.indexOf("=");
+        if (eq < 0)
+            continue;
+        const name = part.slice(0, eq).trim();
+        if (!name || name in out)
+            continue;
+        const raw = part.slice(eq + 1).trim();
+        out[name] = decodeURIComponent(raw);
+    }
+}
+/**
+ * Normalize a {@link HeaderLike} input down to either a `Headers`
+ * instance or a header `Record`. Returns `null` for missing input so
+ * callers can short-circuit without a separate nullish check.
+ */
+function unwrap(input) {
+    if (input == null)
+        return null;
+    if (isHeaders(input))
+        return input;
+    if (isWrapped(input))
+        return input.headers;
+    return input;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../../src/http.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Framework-agnostic readers for HTTP requests, shared across AppKit\n * plugins: header and cookie extraction. Works uniformly across\n * Express, Node `IncomingMessage`, WHATWG `Request` / `Response` /\n * `Headers`, Hono, and any object that exposes a `headers` field of one\n * of those shapes. Dependency-free and browser-safe so it can run in\n * either a server or a client bundle.\n *\n * URL path matching lives in `./net.browser.ts` (`pathMatch`).\n *\n * @module\n */\n\n// ────────────────────────────────────────────────────────────────\n// Types\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Anything that contains HTTP headers. Accepts:\n *\n * - A WHATWG `Headers` instance (fetch / undici / Hono `c.req.raw.headers`).\n * - A header record (`Record<string, string | string[] | undefined>`),\n *   Node / Express style.\n * - Any object with a `headers` field of one of the above. This covers\n *   Express `req`, Node `IncomingMessage`, WHATWG `Request` / `Response`,\n *   Hono `c.req.raw`, and similar shapes.\n */\nexport type HeaderLike = Headers | HeaderRecord | { headers: Headers | HeaderRecord };\n\n/**\n * Single header value as exposed by Node `IncomingMessage.headers` and\n * Express `req.headers` (string for most headers, array for repeated\n * headers such as `Set-Cookie`).\n */\ntype HeaderValueLike = string[] | string | undefined;\n\n/** Header bag with case-insensitive keys (Node / Express style). */\ntype HeaderRecord = Record<string, HeaderValueLike>;\n\n// ────────────────────────────────────────────────────────────────\n// Header helpers\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Invokes `consumer` once per value for `headerName`, case-insensitive.\n *\n * - **Record input:** if the field is an array (e.g. repeated `Set-Cookie`),\n *   `consumer` runs once per array item.\n * - **`Headers` input:** uses `get(name)` (which spec-joins repeats with\n *   `, `) except for `Set-Cookie`, which uses `getSetCookie()` so each\n *   cookie is delivered separately.\n *\n * @example\n * forEachHeaderValue(req, \"x-trace-id\", (v) => spans.push(v));     // Express\n * forEachHeaderValue(c.req.raw, \"set-cookie\", (v) => log(v));      // Hono\n * forEachHeaderValue(headersInstance, \"cookie\", parse);            // fetch\n */\nexport function forEachHeaderValue(\n  input: HeaderLike | null | undefined,\n  headerName: string,\n  consumer: (value: string) => void,\n): void {\n  const headers = unwrap(input);\n  if (!headers) return;\n\n  const target = headerName.toLowerCase();\n\n  if (isHeaders(headers)) {\n    // `Headers.get` joins repeated values with `, ` per spec, which\n    // mangles `Set-Cookie` (cookies legitimately contain commas in\n    // their `expires=` attribute). `getSetCookie` is the dedicated\n    // splitter and is the only safe path for that header.\n    if (target === \"set-cookie\") {\n      for (const value of headers.getSetCookie()) consumer(value);\n      return;\n    }\n    const value = headers.get(headerName);\n    if (value !== null) consumer(value);\n    return;\n  }\n\n  for (const [key, value] of Object.entries(headers)) {\n    if (value == null || key.toLowerCase() !== target) continue;\n    if (Array.isArray(value)) {\n      for (const item of value) consumer(item);\n    } else {\n      consumer(value);\n    }\n  }\n}\n\n/**\n * Parses `Cookie` header values into a name-to-value map (URI-decoded).\n *\n * Accepts:\n *\n * - A raw `Cookie` string (`\"a=1; b=2\"`).\n * - An array of such strings (e.g. multiple `Cookie` headers).\n * - Any {@link HeaderLike}: a WHATWG `Headers` instance, a header\n *   record, or a request-like object with a `headers` field.\n *\n * First occurrence of each cookie name wins; later duplicates are ignored.\n *\n * @example\n * parseCookies(\"session=abc; theme=dark\");\n * // { session: \"abc\", theme: \"dark\" }\n *\n * parseCookies(req);              // Express / Node\n * parseCookies(c.req.raw);        // Hono\n * parseCookies(request);          // fetch Request\n * parseCookies(request.headers);  // WHATWG Headers directly\n */\nexport function parseCookies(input: HeaderLike | HeaderValueLike | null): Record<string, string> {\n  if (input == null) return {};\n  const out: Record<string, string> = {};\n\n  if (typeof input === \"string\") {\n    parseCookieString(input, out);\n    return out;\n  }\n\n  if (Array.isArray(input)) {\n    for (const item of input) {\n      if (typeof item === \"string\") parseCookieString(item, out);\n    }\n    return out;\n  }\n\n  forEachHeaderValue(input, \"cookie\", (value) => {\n    parseCookieString(value, out);\n  });\n  return out;\n}\n\n/**\n * Build an `Error` describing a failed `fetch` response: status line,\n * the URL(s) involved (the requested `url` and the final `response.url`\n * after redirects, de-duplicated), and a truncated snapshot of the\n * response body. Reads the body defensively - a body that can't be read\n * is simply omitted. Call only on a non-`ok` response.\n */\nexport async function createFetchError(response: Response, url?: string): Promise<Error> {\n  let body = \"\";\n  try {\n    body = (await response.text()).trim();\n  } catch {\n    // ignore\n  }\n  if (body.length > 1_000) {\n    body = `${body.slice(0, 1_000)}…`;\n  }\n  const urlSummary = [...new Set([url, response.url].filter(Boolean))].join(\" -> \");\n  return new Error(\n    [\n      `Request failed.`,\n      `${response.status} ${response.statusText}`,\n      `${urlSummary}`,\n      body && `Response:\\n${body}`,\n    ]\n      .filter(Boolean)\n      .join(\"\\n\"),\n  );\n}\n\n// ────────────────────────────────────────────────────────────────\n// Private helpers\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Type guard for WHATWG `Headers`. Duck-types on the two methods that\n * matter to this module (`get` and `getSetCookie`) so polyfilled\n * implementations and Hono's `HonoHeaders` are accepted without\n * pulling `Headers` in as a hard dependency.\n */\nfunction isHeaders(value: unknown): value is Headers {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as Headers).get === \"function\" &&\n    typeof (value as Headers).getSetCookie === \"function\"\n  );\n}\n\n/**\n * `HeaderRecord` is an index signature, so `\"headers\" in input` cannot\n * discriminate it from the wrapped `{ headers }` shape at the type\n * level. This guard inspects the runtime value of `headers`: only\n * objects (`Headers` or a nested record) qualify as the wrapper shape,\n * never stray string/array values that happen to live under a `headers`\n * key on a header record.\n */\nfunction isWrapped(\n  input: HeaderRecord | { headers: Headers | HeaderRecord },\n): input is { headers: Headers | HeaderRecord } {\n  const headers = (input as { headers?: unknown }).headers;\n  return headers != null && typeof headers === \"object\" && !Array.isArray(headers);\n}\n\n/**\n * Parse a single `Cookie`-style header string (`\"a=1; b=2\"`) into\n * `out`. Names without a value are skipped; first occurrence wins so\n * later duplicates are ignored. Cookie values are URI-decoded.\n */\nfunction parseCookieString(input: string, out: Record<string, string>): void {\n  for (const part of input.split(\";\")) {\n    const eq = part.indexOf(\"=\");\n    if (eq < 0) continue;\n    const name = part.slice(0, eq).trim();\n    if (!name || name in out) continue;\n    const raw = part.slice(eq + 1).trim();\n    out[name] = decodeURIComponent(raw);\n  }\n}\n\n/**\n * Normalize a {@link HeaderLike} input down to either a `Headers`\n * instance or a header `Record`. Returns `null` for missing input so\n * callers can short-circuit without a separate nullish check.\n */\nfunction unwrap(input: HeaderLike | null | undefined): Headers | HeaderRecord | null {\n  if (input == null) return null;\n  if (isHeaders(input)) return input;\n  if (isWrapped(input)) return input.headers;\n  return input;\n}\n"]}

package/lib/src/json.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Browser-safe JSON helpers for the parse-untrusted-text case.
+ *
+ * `JSON.parse` throws on malformed input and returns `any`, so almost every
+ * caller in this repo wrapped it in the same try/catch and then re-narrowed the
+ * result by hand. {@link parse} collapses the try/catch (a bad document yields
+ * the fallback instead of throwing) and {@link parseRecord} adds the narrowing
+ * that untrusted JSON almost always needs before it can be indexed.
+ *
+ * Use these when the document comes from OUTSIDE the process - a request body,
+ * an env var, a config file, a subprocess's stdout, a third-party API. Keep
+ * bare `JSON.parse` where a throw is the correct outcome (an internally
+ * produced document that must be well-formed).
+ *
+ * These deliberately do NOT validate shape beyond "is it a record". Reach for
+ * a zod schema when the payload has a contract; these only get you from `string`
+ * to a safely typed starting point.
+ *
+ * @module
+ */
+/**
+ * Parse JSON text, returning `fallback` (default `undefined`) instead of
+ * throwing when `text` is absent or malformed.
+ *
+ * The return type is caller-asserted, exactly like `JSON.parse` - this only
+ * removes the try/catch, it does not validate. Prefer {@link parseRecord} or a
+ * schema when the result is indexed.
+ *
+ * @example
+ * const config = json.parse<Config>(await readFile(path, "utf8"));
+ * const tags = json.parse(process.env.TAGS, []);
+ */
+export declare function parse<T = unknown>(text: unknown, fallback: T): T;
+export declare function parse<T = unknown>(text: unknown): T | undefined;
+/**
+ * Parse JSON text that is expected to be an object, returning `undefined` when
+ * it is absent, malformed, or parses to a non-record (an array, a bare string,
+ * `null`, ...).
+ *
+ * This is the common case for manifests, env-var config blobs, and untyped API
+ * payloads: {@link parse} followed by {@link isRecord}, so the result can be
+ * indexed without an `as Record<string, unknown>` cast.
+ *
+ * @example
+ * const manifest = json.parseRecord(await readFile("package.json", "utf8")) ?? {};
+ * const name = manifest.name;
+ */
+export declare function parseRecord(text: unknown): Record<string, unknown> | undefined;