@blaze-cache/fetch 0.0.0-stage → 0.2.1-beta

package/dist/client.js

@@ -0,0 +1,398 @@
+import { NO_DIRECTIVES, parseAgeMs, parseCacheControl, varyIsStorable } from './cache-control.js';
+import { defaultCacheKey } from './key.js';
+import { normalizeInit, resolveMethod, resolveUrl } from './request.js';
+/** Freshness window when neither the option nor `Cache-Control` says otherwise. */
+const DEFAULT_TTL_MS = 60_000;
+/** Only `GET` is cached unless the caller says otherwise. */
+const DEFAULT_METHODS = ['GET'];
+/** A personalized response must never be replayed to a different user. */
+const DEFAULT_VARY_HEADERS = ['authorization'];
+const DEFAULT_MARKER_HEADER = 'x-blaze-cache';
+/** Statuses that cannot carry a body — a replay must pass `null` for them. */
+const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
+/**
+ * Wraps the platform `fetch` with a Blaze Cache layer.
+ *
+ * ```ts
+ * import { createCache } from '@blaze-cache/core';
+ * import { createBlazeFetch } from '@blaze-cache/fetch';
+ *
+ * const cache = await createCache({ capacity: 1000 });
+ * const fetch = createBlazeFetch(cache, { ttlMs: 30_000 });
+ *
+ * const response = await fetch('/api/users');
+ * response.headers.get('x-blaze-cache'); // 'MISS', then 'HIT' on the next call
+ * ```
+ *
+ * The returned function keeps the platform signature — hand it to anything expecting
+ * `typeof fetch`. Requests outside {@link BlazeFetchOptions.methods} pass through untouched,
+ * and a failing network call rejects exactly as it would have without the wrapper.
+ */
+export function createBlazeFetch(cache, options = {}) {
+    // Called as a member of `globalThis`, so the receiver stays correct in browsers, where an
+    // unbound `fetch` throws "Illegal invocation".
+    const network = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    const markerHeader = options.markerHeader === undefined ? DEFAULT_MARKER_HEADER : options.markerHeader;
+    const methods = new Set((options.methods ?? DEFAULT_METHODS).map((method) => method.toUpperCase()));
+    const cacheControl = options.cacheControl ?? true;
+    const varyHeaders = options.varyHeaders ?? DEFAULT_VARY_HEADERS;
+    const shouldCache = options.shouldCache ?? defaultShouldCache;
+    const swr = options.staleWhileRevalidate ?? false;
+    /** Whether stale entries may be served at all, and for how long when the header is absent. */
+    const swrEnabled = swr !== false;
+    const swrFallbackMs = typeof swr === 'number' && swr > 0 ? swr : 0;
+    /** Keys with a background refresh already running — one network call per key at a time. */
+    const revalidating = new Set();
+    /**
+     * Identical requests currently on the wire, keyed by cache key — one promise per key that
+     * opens only when the leader's store attempt has fully *settled*, so a joiner can trust
+     * whatever it then finds in the cache. See {@link dispatch}.
+     */
+    const inFlight = new Map();
+    /**
+     * Whether a cache-layer failure has been reported already.
+     *
+     * A throwing `cache.get`/`cache.set` or callback must never fail a request the network
+     * answered well — the first such failure is announced, then the wrapper keeps working
+     * (uncached) in silence rather than spamming the console on every call.
+     */
+    let warned = false;
+    /** The one place a cache-layer exception is allowed to surface: a single console warning. */
+    function warnCacheFailure(error) {
+        if (warned)
+            return;
+        warned = true;
+        console.warn('[blaze-cache] cache layer failed; continuing without it', error);
+    }
+    const keyOf = (url, init) => options.key ? options.key(url, init) : defaultCacheKey(url, init, varyHeaders);
+    async function dispatch(input, init) {
+        const method = resolveMethod(input, init);
+        const url = resolveUrl(input);
+        const request = normalizeInit(input, init, method);
+        const key = keyOf(url, request);
+        // `init.cache` is the caller's instruction, `Cache-Control` is the server's; with
+        // `cacheControl: false` only the former is still obeyed.
+        const control = cacheControl ? parseCacheControl(request.headers.get('Cache-Control')) : NO_DIRECTIVES;
+        const bypassWrite = control.noStore || request.cache === 'no-store';
+        // A request `max-age=0` is, per RFC 9111 §5.2.2.1, a demand to revalidate before reuse.
+        // This cache has no conditional requests, so the closest honest reading is a full
+        // refetch — exactly what `bypassRead` does — rather than replaying the entry untouched.
+        const bypassRead = bypassWrite ||
+            control.noCache ||
+            control.maxAgeMs === 0 ||
+            init.forceRefresh === true ||
+            request.cache === 'no-cache' ||
+            request.cache === 'reload';
+        const cacheable = methods.has(method);
+        if (cacheable) {
+            if (!bypassRead) {
+                const record = read(key);
+                if (record) {
+                    const now = Date.now();
+                    // `force-cache` means "use it whatever its age"; otherwise freshness decides.
+                    if (request.cache === 'force-cache' || now <= record.freshUntil) {
+                        return replay(record, 'HIT');
+                    }
+                    if (swrEnabled && now <= record.staleUntil) {
+                        // Refreshed in the background: the caller is served *now*, the next call a `HIT`.
+                        revalidate(input, init, key);
+                        return replay(record, 'STALE');
+                    }
+                }
+            }
+            // An identical request is already on the wire. Its `Response` cannot be handed over —
+            // a body stream can be consumed exactly once, and the leader's own caller is reading
+            // it — but the *stored record* is the replayable form of the very same bytes, so the
+            // cache doubles as the rendezvous: wait for the leader's write to settle, then replay
+            // what it landed. A leader that stored nothing (an unstorable response, a failed
+            // write) opens its gate over an empty cache, and the joiner falls through to the
+            // network itself — never an unstored response, never a deadlock: gates only ever wait
+            // on leaders, and no leader waits on a joiner.
+            //
+            // Joined only when this call would itself have accepted a cached read. A caller that
+            // explicitly demanded the network (`forceRefresh`, `cache: 'reload'`, request
+            // `no-cache`/`max-age=0`) is joined *out*: answering it from the cache — however
+            // recently written — breaks the promise it made, and it leads below instead.
+            if (!bypassRead) {
+                const pending = inFlight.get(key);
+                if (pending) {
+                    await pending;
+                    const shared = read(key);
+                    // Freshly written, but a pathologically short TTL may have aged it out already.
+                    if (shared && Date.now() <= shared.freshUntil)
+                        return replay(shared, 'HIT');
+                }
+            }
+        }
+        // From here on this call *leads* its key. The gate is registered before the network is
+        // touched — otherwise two callers could both miss and both fetch before either
+        // registers — and only cacheable, storable requests lead: a `POST` must never be
+        // silently coalesced with an identical one, side effects and all.
+        const leader = cacheable && !bypassWrite;
+        let settle = () => undefined;
+        const settled = new Promise((resolve) => {
+            settle = resolve;
+        });
+        if (leader)
+            inFlight.set(key, settled);
+        /**
+         * Opens the gate and retires the leadership — every exit passes through it.
+         *
+         * Identity-checked: a caller that demanded the network (`forceRefresh`, `reload`) leads
+         * too and may have replaced our gate with its own. Deleting whatever sits under `key`
+         * would retire *their* leadership while ours still stands, silently dropping the joiners
+         * waiting on them.
+         */
+        const done = () => {
+            if (leader && inFlight.get(key) === settled)
+                inFlight.delete(key);
+            settle();
+        };
+        let response;
+        try {
+            response = await network(input, init);
+        }
+        catch (error) {
+            // A failed leader still opens its gate — over an empty cache, so joiners wake and
+            // retry the network themselves instead of waiting on a promise that never settles.
+            done();
+            throw error;
+        }
+        let keep = false;
+        if (leader) {
+            try {
+                keep = shouldCache(response, url, request);
+            }
+            catch (error) {
+                // A callback that throws must not fail the response the network just delivered.
+                warnCacheFailure(error);
+            }
+        }
+        if (keep) {
+            // Deliberately fire-and-forget. `store` tees the body with `clone()` — the caller's
+            // copy of the stream is untouched — and fully buffers *its* copy before `cache.set`,
+            // so nothing about this call's latency depends on the write, and a later read can
+            // never race a half-written entry. The gate above, however, opens only once that
+            // write has settled: that is what lets a joiner trust the cache it finds.
+            void store(response, key, url, request)
+                .catch(warnCacheFailure)
+                .finally(done);
+        }
+        else {
+            // Nothing will be stored for this call: wake any joiners so they can lead in turn.
+            done();
+        }
+        // Marked last, so `shouldCache`/`tags`/`ttlMs` see exactly what the network sent.
+        return mark(response, 'MISS');
+    }
+    /** Fetches a fresh copy of a stale entry so the next read is a `HIT` again. */
+    function revalidate(input, init, key) {
+        if (revalidating.has(key))
+            return;
+        revalidating.add(key);
+        // The caller's `signal` is deliberately stripped. It belongs to the request that merely
+        // *happened* to notice the staleness — and such callers usually abort right after being
+        // served (an unmount, a route change), which would abort the refresh and leave the
+        // entry stale forever. A background refresh is the wrapper's own work and runs on the
+        // wrapper's own terms; `forceRefresh` keeps it from re-serving the stale entry to itself.
+        void dispatch(input, { ...init, signal: undefined, forceRefresh: true })
+            // A background refresh must never reject into a caller: the stale entry simply stays
+            // until the next attempt.
+            .catch(() => undefined)
+            .finally(() => revalidating.delete(key));
+    }
+    /**
+     * Buffers the body and writes the record. Returns early when nothing is worth keeping.
+     *
+     * Deliberately fire-and-forget at the call site: the body it reads comes from a `clone()`
+     * of the caller's response, so every millisecond it spends buffering is invisible to the
+     * caller — and the record is complete (never half-written) by the time `cache.set` runs.
+     */
+    async function store(response, key, url, request) {
+        // An opaque response exposes no status, headers or body: there is nothing to store.
+        if (response.status === 0)
+            return;
+        const control = cacheControl ? parseCacheControl(response.headers.get('Cache-Control')) : NO_DIRECTIVES;
+        // `no-store` forbids storing; `no-cache` demands revalidation on every use, and this
+        // cache has no conditional requests — so neither is worth an entry.
+        if (control.noStore || control.noCache)
+            return;
+        // `Vary` decides which *request* headers this response's identity hangs on. Only a
+        // response whose every named header is already folded into the cache key may be stored;
+        // anything else would be keyed wrongly, and a wrong key replays the wrong variant —
+        // another user's `Cookie`, another locale's `Accept-Language`. When we cannot key on a
+        // header, the safe answer is not to cache at all. (Checked unconditionally, not only
+        // under `cacheControl`: variant correctness is not a freshness preference.)
+        if (!varyIsStorable(response.headers.get('Vary'), varyHeaders))
+            return;
+        const configured = options.ttlMs;
+        const ttl = typeof configured === 'function' ? configured(response, url, request) : (configured ?? DEFAULT_TTL_MS);
+        const maxAge = control.maxAgeMs ?? ttl;
+        const age = cacheControl ? parseAgeMs(response.headers.get('Age')) : 0;
+        const freshMs = maxAge - age;
+        // Zero, negative or `NaN` means "keep nothing": already stale, or the caller opted out.
+        if (!(freshMs > 0))
+            return;
+        // The response's own directive wins; the numeric option is the fallback for servers that
+        // never send one. When the whole feature is off there is no stale window at all — and
+        // `must-revalidate` (or its shared-cache spelling `proxy-revalidate`) closes the window
+        // even when the feature is on: such a response must never be replayed past its
+        // freshness, so there is nothing it may serve "while revalidating".
+        const staleMs = !swrEnabled || control.mustRevalidate
+            ? 0
+            : cacheControl && control.staleWhileRevalidateMs !== undefined
+                ? control.staleWhileRevalidateMs
+                : swrFallbackMs;
+        let body;
+        try {
+            // `clone()` tees the stream: the caller's response still delivers every byte, while
+            // this copy is buffered in the background — and fully buffered *before* `cache.set`,
+            // so a follow-up read can never race a half-written entry.
+            body = await response.clone().arrayBuffer();
+        }
+        catch {
+            return; // a body that fails mid-flight must not poison the cache
+        }
+        const storedAt = Date.now();
+        const freshUntil = storedAt + freshMs;
+        const record = {
+            status: response.status,
+            statusText: response.statusText,
+            headers: storedHeaders(response.headers, body),
+            body,
+            url: response.url,
+            redirected: response.redirected,
+            storedAt,
+            freshUntil,
+            staleUntil: freshUntil + staleMs,
+        };
+        const totalMs = freshMs + staleMs;
+        cache.set(key, record, {
+            // `0` is how the core spells "never expires" — reached only via `ttlMs: Infinity`.
+            ttlMs: Number.isFinite(totalMs) ? totalMs : 0,
+            tags: options.tags?.(response, url, request) ?? defaultTags(request.method, url),
+        });
+    }
+    /**
+     * `cache.get`, guarded: a cache-layer failure reads as a plain miss — the caller falls
+     * through to the network instead of having its request fail over a broken cache.
+     */
+    function read(key) {
+        try {
+            return cache.get(key);
+        }
+        catch (error) {
+            warnCacheFailure(error);
+            return undefined;
+        }
+    }
+    /** Rebuilds a `Response` from a stored record, without touching cache statistics. */
+    function replay(record, marker) {
+        const headers = headersFromRecord(record.headers);
+        if (markerHeader !== false)
+            headers.set(markerHeader, marker);
+        const response = new Response(NULL_BODY_STATUSES.has(record.status) ? null : record.body, { status: record.status, statusText: record.statusText, headers });
+        // `url`/`redirected` are read-only accessors on the prototype; an own property shadows
+        // them so a hit carries the metadata of the network response it stands in for.
+        defineOwn(response, 'url', record.url);
+        defineOwn(response, 'redirected', record.redirected);
+        return response;
+    }
+    /** Stamps the marker on a network response, rebuilding it only if its headers refuse. */
+    function mark(response, marker) {
+        if (markerHeader === false)
+            return response;
+        try {
+            response.headers.set(markerHeader, marker);
+            return response;
+        }
+        catch {
+            // Immutable headers (network responses in undici, `Response.redirect()`): rebuild so
+            // the marker contract holds — the marker goes on the *rebuild*, since the original
+            // refused it. Status 0 cannot be rebuilt at all: pass it through unmarked.
+            if (response.status === 0)
+                return response;
+            const headers = new Headers(response.headers);
+            headers.set(markerHeader, marker);
+            const rebuilt = new Response(response.body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+            });
+            defineOwn(rebuilt, 'url', response.url);
+            defineOwn(rebuilt, 'redirected', response.redirected);
+            return rebuilt;
+        }
+    }
+    return (input, init = {}) => dispatch(input, init);
+}
+/** Successful responses only. The {@link BlazeFetchOptions.methods} gate has already applied. */
+function defaultShouldCache(response) {
+    return response.status >= 200 && response.status < 300;
+}
+/**
+ * `['fetch', '<method> <url>']` — one tag drops everything this wrapper stored
+ * (`cache.invalidateTags('fetch')`), the other drops a single resource.
+ */
+function defaultTags(method, url) {
+    return ['fetch', `${method.toLowerCase()} ${url}`];
+}
+/** Copies headers into a plain, structured-clone-friendly record. */
+function headersToRecord(headers) {
+    const record = {};
+    // `Headers.forEach` reports names already lower-cased. Defined, never assigned: a plain
+    // `record[name] = value` hands a literal `__proto__` to the inherited setter, which
+    // ignores primitives — silently dropping a perfectly legal header instead of storing it.
+    headers.forEach((value, name) => {
+        Object.defineProperty(record, name, { value, enumerable: true, writable: true, configurable: true });
+    });
+    return record;
+}
+/**
+ * Response headers as a plain record, corrected to describe the bytes we actually hold.
+ *
+ * `fetch` decodes `content-encoding` for us, so a stored body is always the plain payload
+ * while the headers still describe the *wire* format — `gzip` plus the compressed
+ * `content-length` (on a real API: 1425 bytes claimed for 6504 stored). Replaying those
+ * would hand back a response that contradicts itself, breaking anything that reads
+ * `content-length` — a file downloader, `blob().size`, a progress bar — or that trusts the
+ * encoding and tries to inflate plain bytes. `transfer-encoding` is hop-by-hop and stops
+ * being true the moment the body is buffered.
+ *
+ * HEAD is the one exception: no body was ever sent, so its `content-length` and
+ * `content-encoding` describe what a GET *would* return and stay as metadata.
+ */
+function storedHeaders(headers, body) {
+    const record = headersToRecord(headers);
+    delete record['transfer-encoding'];
+    if (body.byteLength > 0) {
+        delete record['content-encoding'];
+        if ('content-length' in record)
+            record['content-length'] = String(body.byteLength);
+    }
+    return record;
+}
+/** Shadows a read-only prototype accessor with an own property; never throws. */
+function defineOwn(target, key, value) {
+    try {
+        Object.defineProperty(target, key, { value, writable: true, enumerable: false, configurable: true });
+    }
+    catch {
+        // A frozen response: the missing metadata is cosmetic, never worth failing a hit over.
+    }
+}
+/**
+ * Rebuilds a `Headers` from a stored record, name by name.
+ *
+ * Never `new Headers(record)`: the platform's plain-object conversion drops a literal
+ * `__proto__` key on its way through the inherited setter, losing a legal header between
+ * the store and the replay. `append` accepts every name the store can hold.
+ */
+function headersFromRecord(record) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(record)) {
+        headers.append(name, value);
+    }
+    return headers;
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A drop-in `fetch()` replacement backed by Blaze Cache.
+ *
+ * `createBlazeFetch` returns a function with the platform signature, so it slots into any
+ * code that expects `typeof fetch` — and gets caching underneath: per-entry TTLs,
+ * `Cache-Control` on both sides of the exchange, tag-based invalidation, SIEVE eviction and
+ * optional IndexedDB persistence, all inherited from {@link createCache | `@blaze-cache/core`}.
+ *
+ * ```ts
+ * import { createCache } from '@blaze-cache/core';
+ * import { createBlazeFetch } from '@blaze-cache/fetch';
+ *
+ * const cache = await createCache({ capacity: 1000 });
+ * const fetch = createBlazeFetch(cache, { ttlMs: 30_000 });
+ *
+ * const response = await fetch('/api/users');
+ * response.headers.get('x-blaze-cache'); // 'MISS', then 'HIT'
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createBlazeFetch } from './client.js';
+export { parseCacheControl, parseAgeMs, varyIsStorable } from './cache-control.js';
+export type { CacheControl } from './cache-control.js';
+export { defaultCacheKey, fnv1a } from './key.js';
+export type { BlazeFetch, BlazeFetchCacheLike, BlazeFetchEffectiveInit, BlazeFetchInit, BlazeFetchMarker, BlazeFetchOptions, FetchCacheRecord, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACnF,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAElD,YAAY,EACV,UAAU,EACV,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+/**
+ * A drop-in `fetch()` replacement backed by Blaze Cache.
+ *
+ * `createBlazeFetch` returns a function with the platform signature, so it slots into any
+ * code that expects `typeof fetch` — and gets caching underneath: per-entry TTLs,
+ * `Cache-Control` on both sides of the exchange, tag-based invalidation, SIEVE eviction and
+ * optional IndexedDB persistence, all inherited from {@link createCache | `@blaze-cache/core`}.
+ *
+ * ```ts
+ * import { createCache } from '@blaze-cache/core';
+ * import { createBlazeFetch } from '@blaze-cache/fetch';
+ *
+ * const cache = await createCache({ capacity: 1000 });
+ * const fetch = createBlazeFetch(cache, { ttlMs: 30_000 });
+ *
+ * const response = await fetch('/api/users');
+ * response.headers.get('x-blaze-cache'); // 'MISS', then 'HIT'
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createBlazeFetch } from './client.js';
+export { parseCacheControl, parseAgeMs, varyIsStorable } from './cache-control.js';
+export { defaultCacheKey, fnv1a } from './key.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGnF,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC"}

package/dist/key.d.ts

@@ -0,0 +1,23 @@
+import type { BlazeFetchEffectiveInit } from './types.js';
+/**
+ * FNV-1a, 32-bit.
+ *
+ * Folds sensitive material (bearer tokens, `vary` headers) into a short, stable token. It is
+ * not a security primitive — the point is that a persisted cache key never contains a secret
+ * in readable form.
+ */
+export declare function fnv1a(input: string): string;
+/**
+ * Default cache key: method + URL, plus a hash of the `varyHeaders` values.
+ *
+ * ```ts
+ * defaultCacheKey('/api/users', init, ['authorization']); // "get /api/users?a3f9k"
+ * ```
+ *
+ * The hash is appended whenever `varyHeaders` is non-empty — including when every value is
+ * absent — so keys stay stable across calls. Pass `varyHeaders: []` to get the bare
+ * `"<method> <url>"` form. Call it from the {@link BlazeFetchOptions.key} callback with the
+ * `init` you were handed.
+ */
+export declare function defaultCacheKey(url: string, init: BlazeFetchEffectiveInit, varyHeaders: readonly string[]): string;
+//# sourceMappingURL=key.d.ts.map

package/dist/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../src/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,uBAAuB,EAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,MAAM,CAYR"}

package/dist/key.js

@@ -0,0 +1,41 @@
+/**
+ * FNV-1a, 32-bit.
+ *
+ * Folds sensitive material (bearer tokens, `vary` headers) into a short, stable token. It is
+ * not a security primitive — the point is that a persisted cache key never contains a secret
+ * in readable form.
+ */
+export function fnv1a(input) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < input.length; index += 1) {
+        hash ^= input.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(36);
+}
+/**
+ * Default cache key: method + URL, plus a hash of the `varyHeaders` values.
+ *
+ * ```ts
+ * defaultCacheKey('/api/users', init, ['authorization']); // "get /api/users?a3f9k"
+ * ```
+ *
+ * The hash is appended whenever `varyHeaders` is non-empty — including when every value is
+ * absent — so keys stay stable across calls. Pass `varyHeaders: []` to get the bare
+ * `"<method> <url>"` form. Call it from the {@link BlazeFetchOptions.key} callback with the
+ * `init` you were handed.
+ */
+export function defaultCacheKey(url, init, varyHeaders) {
+    const base = `${init.method.toLowerCase()} ${url}`;
+    if (varyHeaders.length === 0)
+        return base;
+    const headers = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    // JSON, never a plain join: the encoding must stay *injective*, because a collision here
+    // would replay one identity's payload to another. Joining with a space lets a value
+    // containing the separator impersonate the boundary — `['x y', '']` and `['x', 'y']` are
+    // two different identities, and only a length-delimited encoding (JSON being the simplest)
+    // keeps them apart.
+    const vary = JSON.stringify(varyHeaders.map((name) => headers.get(name) ?? ''));
+    return `${base}?${fnv1a(vary)}`;
+}
+//# sourceMappingURL=key.js.map

package/dist/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../src/key.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa;IACjC,IAAI,IAAI,GAAG,UAAU,CAAC;IACtB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACrD,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAW,EACX,IAA6B,EAC7B,WAA8B;IAE9B,MAAM,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,GAAG,EAAE,CAAC;IACnD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAE1C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,YAAY,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3F,yFAAyF;IACzF,oFAAoF;IACpF,yFAAyF;IACzF,2FAA2F;IAC3F,oBAAoB;IACpB,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAChF,OAAO,GAAG,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;AAClC,CAAC"}

package/dist/request.d.ts

@@ -0,0 +1,33 @@
+import type { BlazeFetchEffectiveInit } from './types.js';
+/**
+ * Normalising a `fetch` input.
+ *
+ * `fetch` accepts three shapes — a URL string, a {@link URL} or a whole {@link Request} —
+ * and the method/headers may live on the `Request`, on the `init` object, or on both (with
+ * `init` winning). Cache keys, `Cache-Control` and every user callback work from the
+ * *resolved* view instead: one absolute URL, one method, one merged header list.
+ *
+ * The network always receives the caller's original `input`/`init`, unchanged.
+ */
+/** `true` when `input` is a `Request`. Guarded, so exotic hosts without one still work. */
+export declare function isRequest(input: RequestInfo | URL): input is Request;
+/**
+ * Absolute URL of the request — the basis of every cache key.
+ *
+ * A `Request` and a `URL` are already absolute. A string is resolved against the page in a
+ * browser; in Node there is no document base, so it is kept verbatim, which is still a
+ * stable key as long as call sites are stable.
+ */
+export declare function resolveUrl(input: RequestInfo | URL): string;
+/** HTTP method, upper-cased — `GET` when nothing says otherwise. */
+export declare function resolveMethod(input: RequestInfo | URL, init: RequestInit): string;
+/**
+ * The **effective** request: `init` as the caller passed it, with `method`, `headers` and
+ * `cache` filled in from `input` when it is a `Request`.
+ *
+ * This is what `key`, `shouldCache`, `tags` and `ttlMs` receive — so a callback can read
+ * `authorization` whether the caller set it on a `Request` or on the `init` object. It never
+ * reaches the network.
+ */
+export declare function normalizeInit(input: RequestInfo | URL, init: RequestInit, method: string): BlazeFetchEffectiveInit;
+//# sourceMappingURL=request.d.ts.map

package/dist/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;;;;;GASG;AAEH,2FAA2F;AAC3F,wBAAgB,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,GAAG,KAAK,IAAI,OAAO,CAEpE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,GAAG,MAAM,CAS3D;AAED,oEAAoE;AACpE,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAGjF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,GACb,uBAAuB,CAOzB"}

package/dist/request.js

@@ -0,0 +1,55 @@
+/**
+ * Normalising a `fetch` input.
+ *
+ * `fetch` accepts three shapes — a URL string, a {@link URL} or a whole {@link Request} —
+ * and the method/headers may live on the `Request`, on the `init` object, or on both (with
+ * `init` winning). Cache keys, `Cache-Control` and every user callback work from the
+ * *resolved* view instead: one absolute URL, one method, one merged header list.
+ *
+ * The network always receives the caller's original `input`/`init`, unchanged.
+ */
+/** `true` when `input` is a `Request`. Guarded, so exotic hosts without one still work. */
+export function isRequest(input) {
+    return typeof Request !== 'undefined' && input instanceof Request;
+}
+/**
+ * Absolute URL of the request — the basis of every cache key.
+ *
+ * A `Request` and a `URL` are already absolute. A string is resolved against the page in a
+ * browser; in Node there is no document base, so it is kept verbatim, which is still a
+ * stable key as long as call sites are stable.
+ */
+export function resolveUrl(input) {
+    if (isRequest(input))
+        return input.url;
+    const raw = input instanceof URL ? input.href : String(input);
+    try {
+        return new URL(raw).href;
+    }
+    catch {
+        const base = globalThis.location?.href;
+        return base === undefined ? raw : new URL(raw, base).href;
+    }
+}
+/** HTTP method, upper-cased — `GET` when nothing says otherwise. */
+export function resolveMethod(input, init) {
+    const explicit = init.method ?? (isRequest(input) ? input.method : undefined);
+    return (explicit ?? 'GET').toUpperCase();
+}
+/**
+ * The **effective** request: `init` as the caller passed it, with `method`, `headers` and
+ * `cache` filled in from `input` when it is a `Request`.
+ *
+ * This is what `key`, `shouldCache`, `tags` and `ttlMs` receive — so a callback can read
+ * `authorization` whether the caller set it on a `Request` or on the `init` object. It never
+ * reaches the network.
+ */
+export function normalizeInit(input, init, method) {
+    return {
+        ...init,
+        method,
+        headers: new Headers(init.headers ?? (isRequest(input) ? input.headers : undefined)),
+        cache: init.cache ?? (isRequest(input) ? input.cache : undefined),
+    };
+}
+//# sourceMappingURL=request.js.map