actly 1.1.0 → 1.2.0

package/dist/policies/cache.cjs

@@ -3,41 +3,242 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cachePolicy = cachePolicy;
 const base_js_1 = require("../stores/base.js");
 const NS = 'cache:';
+const INFLIGHT_NS = '__inflight:cache:';
+let generationCounter = 0;
+function nextGeneration() {
+    generationCounter = (generationCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return generationCounter;
+}
 /**
- * Short-circuits the entire downstream chain on a cache hit.
- * On a miss, runs fn and stores the result with TTL.
+ * Short-circuit the entire downstream chain on a cache hit.
+ * On a miss, run `fn` and store the result with TTL.
+ *
+ * # Properties
+ *
+ *  - **Single-flight originator isolation**: the stored in-flight promise is
+ *    the RAW `fn(signal)` — NOT raceAbort-wrapped. An originator's signal
+ *    abort no longer causes all cache-miss joiners to reject. Each caller
+ *    races against their OWN signal only.
+ *  - **Generation-safe inflight cleanup**: stale originators don't delete
+ *    newer entries (same pattern as dedupePolicy).
+ *  - **Signal-aware async store path**: between `await store.get()` and
+ *    `await store.set()`, we re-check `signal.aborted`. The previous
+ *    version would happily return a cached value even after the caller
+ *    aborted mid-Redis-latency.
+ *  - **Cache hit honours abort**: if `signal.aborted` is true at policy
+ *    entry, we reject immediately — consistent with `act()`'s contract.
+ *
+ * # Single-flight (cache stampede prevention)
+ *
+ * On a sync store, the policy also stores the in-flight Promise under a
+ * separate `__inflight:cache:<key>` slot. Concurrent callers that miss the
+ * cache but find an in-flight Promise join it instead of launching duplicate
+ * work. This is the same mechanism `dedupePolicy` uses, applied internally
+ * to cache misses so users don't need to combine `cache` + `dedupe` to
+ * avoid stampedes.
+ *
+ * On an async store, single-flight is not possible (the same sync-store
+ * constraint as dedupe applies). Stampedes are a known limitation — document
+ * and pair with dedupe at a higher layer if you need single-flight semantics.
  *
- * Must be the OUTERMOST policy so a hit skips dedupe, timeout, and retry.
+ * # Fail-open writes
  *
- * Supports both SyncStateStore and AsyncStateStore. The async branch
- * introduces two await points (get + set) but has no correctness
- * requirement for same-tick execution — worst case is a cache stampede
- * on a simultaneous miss, which is standard behaviour without locking.
+ * If `store.set()` throws (e.g. Redis transient error), we swallow the error
+ * and return the value anyway. The caller gets their result; the next call
+ * will simply re-run `fn` and try to cache again. Caching is an optimisation,
+ * not a correctness requirement.
+ *
+ * # Cache hit semantics
+ *
+ * On a cache hit, `meta.source` is set to `'cache'` and `meta.attempts` is
+ * set to `0` — no work was performed.
+ *
+ * Failures are NEVER cached. Only successful values are stored.
  */
 function cachePolicy(opts) {
-    return (fn, ctx) => async () => {
+    return (fn, ctx) => async (signal) => {
+        // Honour abort on cache hit too. Consistent with act()'s
+        // "reject immediately if signal aborted" contract.
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
         const key = NS + ctx.key;
+        const inflightKey = INFLIGHT_NS + ctx.key;
+        // ─── Sync store: fast path with single-flight ────────────────────────
         if ((0, base_js_1.isSyncStore)(ctx.store)) {
-            // Fast path — synchronous store, no await needed
-            const hit = ctx.store.get(key);
+            // Capture the narrowed sync store so closures (cleanup) keep the
+            // type information — TS doesn't carry `isSyncStore` narrowing
+            // into nested function bodies.
+            const store = ctx.store;
+            const obs = ctx.observability;
+            // 1. Cache hit?
+            const hit = store.get(key);
             if (hit) {
                 ctx.meta.source = 'cache';
+                ctx.meta.attempts = 0;
+                // Emit cache-hit event if hooks are registered.
+                // Compute actual age from the entry's insertion timestamp.
+                if (obs) {
+                    const ageMs = Date.now() - hit.insertedAt;
+                    obs.hooks.onCacheHit?.({
+                        type: 'cache-hit', key: ctx.key, traceId: obs.traceId,
+                        timestamp: Date.now(), ageMs: Math.max(0, ageMs),
+                    });
+                }
                 return hit.value;
             }
-            const value = await fn();
-            ctx.store.set(key, { value }, opts.ttl);
-            return value;
+            // Emit cache-miss event if hooks are registered.
+            if (obs) {
+                obs.hooks.onCacheMiss?.({
+                    type: 'cache-miss', key: ctx.key, traceId: obs.traceId,
+                    timestamp: Date.now(),
+                });
+            }
+            // 2. In-flight single-flight hit? Join it.
+            //
+            // The stored promise is RAW fn(signal). Joiners race it
+            // against their OWN signal only — originator abort doesn't
+            // propagate to joiners.
+            const inflight = store.get(inflightKey);
+            if (inflight) {
+                // Race the in-flight promise against OUR OWN signal. If we
+                // abort, we reject — but other joiners and the originator
+                // continue unaffected.
+                try {
+                    const value = await raceWithOwnSignal(inflight.promise, signal);
+                    // Mirror originator's meta so joiner's ActResult reflects
+                    // the real effort (attempts, source).
+                    ctx.meta.attempts = inflight.meta.attempts;
+                    ctx.meta.source = inflight.meta.source;
+                    return value;
+                }
+                catch (err) {
+                    // Copy meta on failure too (same as dedupe joiners)
+                    if (signal.aborted) {
+                        ctx.meta.attempts = 0;
+                    }
+                    else {
+                        ctx.meta.attempts = inflight.meta.attempts;
+                        ctx.meta.source = inflight.meta.source;
+                    }
+                    throw err;
+                }
+            }
+            // 3. Originator: launch fn, cache on success (fail-open).
+            //
+            // The stored promise is the RAW fn(signal) — NOT raceAbort-wrapped.
+            // Originator's own await is wrapped in raceWithOwnSignal so they
+            // can bail on their signal without affecting joiners.
+            const generation = nextGeneration();
+            const rawPromise = Promise.resolve(fn(signal)).then((value) => {
+                try {
+                    store.set(key, { value, insertedAt: Date.now() }, opts.ttl);
+                }
+                catch {
+                    // Fail-open: cache write failure should not surface to caller.
+                }
+                return value;
+            }, 
+            // Re-throw the error so joiners see it. Don't cache failures.
+            (err) => { throw err; });
+            // Publish the in-flight entry for single-flight. If store.set
+            // throws, single-flight is disabled for this call — concurrent
+            // callers will all run fn. Still correct, just less efficient.
+            try {
+                store.set(inflightKey, { promise: rawPromise, generation, meta: ctx.meta });
+            }
+            catch {
+                // Single-flight unavailable; proceed without publishing.
+                // Originator still gets their value (or error).
+            }
+            // Cleanup the in-flight slot on settle — generation-safe.
+            const cleanup = () => {
+                const current = store.get(inflightKey);
+                if (current && current.generation === generation) {
+                    try {
+                        store.delete(inflightKey);
+                    }
+                    catch { /* ignore */ }
+                }
+            };
+            rawPromise.then(cleanup, cleanup);
+            // Originator races the raw promise against their OWN signal.
+            return raceWithOwnSignal(rawPromise, signal);
         }
-        else {
-            // Async store path
-            const hit = await ctx.store.get(key);
-            if (hit) {
-                ctx.meta.source = 'cache';
-                return hit.value;
+        // Async store: no single-flight (race window unavoidable).
+        // Re-check signal.aborted between awaits.
+        const obs = ctx.observability;
+        const hit = await ctx.store.get(key);
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        if (hit) {
+            ctx.meta.source = 'cache';
+            ctx.meta.attempts = 0;
+            if (obs) {
+                const ageMs = Date.now() - hit.insertedAt;
+                obs.hooks.onCacheHit?.({
+                    type: 'cache-hit', key: ctx.key, traceId: obs.traceId,
+                    timestamp: Date.now(), ageMs: Math.max(0, ageMs),
+                });
             }
-            const value = await fn();
-            await ctx.store.set(key, { value }, opts.ttl);
-            return value;
+            return hit.value;
+        }
+        if (obs) {
+            obs.hooks.onCacheMiss?.({
+                type: 'cache-miss', key: ctx.key, traceId: obs.traceId,
+                timestamp: Date.now(),
+            });
+        }
+        const value = await fn(signal);
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        try {
+            await ctx.store.set(key, { value, insertedAt: Date.now() }, opts.ttl);
         }
+        catch {
+            // Fail-open: see sync path comment.
+        }
+        return value;
     };
 }
+/**
+ * Race a promise against a signal — but if the signal aborts, mark the
+ * underlying promise as handled (so its eventual rejection doesn't surface
+ * as an unhandled rejection). The underlying promise keeps running for any
+ * other consumers (e.g. joiners in single-flight).
+ *
+ * This is `raceAbort` from `utils/abort.ts`, inlined here to avoid an import
+ * cycle (cache.ts already imports from stores, dedupe imports from abort —
+ * keeping cache independent of abort reduces the import graph depth).
+ *
+ * Internal — not exported.
+ */
+function raceWithOwnSignal(promise, signal) {
+    if (signal.aborted) {
+        promise.catch(() => { }); // mark as handled
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort);
+        promise.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}

package/dist/policies/cache.d.ts

@@ -1,14 +1,49 @@
 import type { CacheOptions, PolicyApplier } from '../types/index.js';
 /**
- * Short-circuits the entire downstream chain on a cache hit.
- * On a miss, runs fn and stores the result with TTL.
+ * Short-circuit the entire downstream chain on a cache hit.
+ * On a miss, run `fn` and store the result with TTL.
  *
- * Must be the OUTERMOST policy so a hit skips dedupe, timeout, and retry.
+ * # Properties
  *
- * Supports both SyncStateStore and AsyncStateStore. The async branch
- * introduces two await points (get + set) but has no correctness
- * requirement for same-tick execution — worst case is a cache stampede
- * on a simultaneous miss, which is standard behaviour without locking.
+ *  - **Single-flight originator isolation**: the stored in-flight promise is
+ *    the RAW `fn(signal)` — NOT raceAbort-wrapped. An originator's signal
+ *    abort no longer causes all cache-miss joiners to reject. Each caller
+ *    races against their OWN signal only.
+ *  - **Generation-safe inflight cleanup**: stale originators don't delete
+ *    newer entries (same pattern as dedupePolicy).
+ *  - **Signal-aware async store path**: between `await store.get()` and
+ *    `await store.set()`, we re-check `signal.aborted`. The previous
+ *    version would happily return a cached value even after the caller
+ *    aborted mid-Redis-latency.
+ *  - **Cache hit honours abort**: if `signal.aborted` is true at policy
+ *    entry, we reject immediately — consistent with `act()`'s contract.
+ *
+ * # Single-flight (cache stampede prevention)
+ *
+ * On a sync store, the policy also stores the in-flight Promise under a
+ * separate `__inflight:cache:<key>` slot. Concurrent callers that miss the
+ * cache but find an in-flight Promise join it instead of launching duplicate
+ * work. This is the same mechanism `dedupePolicy` uses, applied internally
+ * to cache misses so users don't need to combine `cache` + `dedupe` to
+ * avoid stampedes.
+ *
+ * On an async store, single-flight is not possible (the same sync-store
+ * constraint as dedupe applies). Stampedes are a known limitation — document
+ * and pair with dedupe at a higher layer if you need single-flight semantics.
+ *
+ * # Fail-open writes
+ *
+ * If `store.set()` throws (e.g. Redis transient error), we swallow the error
+ * and return the value anyway. The caller gets their result; the next call
+ * will simply re-run `fn` and try to cache again. Caching is an optimisation,
+ * not a correctness requirement.
+ *
+ * # Cache hit semantics
+ *
+ * On a cache hit, `meta.source` is set to `'cache'` and `meta.attempts` is
+ * set to `0` — no work was performed.
+ *
+ * Failures are NEVER cached. Only successful values are stored.
  */
 export declare function cachePolicy<T>(opts: CacheOptions): PolicyApplier<T>;
 //# sourceMappingURL=cache.d.ts.map

package/dist/policies/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/policies/cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,YAAY,EAAE,aAAa,EAAiB,MAAM,mBAAmB,CAAA;AAU1F;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CA6BnE"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/policies/cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,YAAY,EAAE,aAAa,EAAiB,MAAM,mBAAmB,CAAA;AA8B1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,CAkJnE"}

package/dist/policies/cache.js

@@ -1,41 +1,242 @@
 import { isSyncStore } from '../stores/base.js';
 const NS = 'cache:';
+const INFLIGHT_NS = '__inflight:cache:';
+let generationCounter = 0;
+function nextGeneration() {
+    generationCounter = (generationCounter + 1) % Number.MAX_SAFE_INTEGER;
+    return generationCounter;
+}
 /**
- * Short-circuits the entire downstream chain on a cache hit.
- * On a miss, runs fn and stores the result with TTL.
+ * Short-circuit the entire downstream chain on a cache hit.
+ * On a miss, run `fn` and store the result with TTL.
+ *
+ * # Properties
+ *
+ *  - **Single-flight originator isolation**: the stored in-flight promise is
+ *    the RAW `fn(signal)` — NOT raceAbort-wrapped. An originator's signal
+ *    abort no longer causes all cache-miss joiners to reject. Each caller
+ *    races against their OWN signal only.
+ *  - **Generation-safe inflight cleanup**: stale originators don't delete
+ *    newer entries (same pattern as dedupePolicy).
+ *  - **Signal-aware async store path**: between `await store.get()` and
+ *    `await store.set()`, we re-check `signal.aborted`. The previous
+ *    version would happily return a cached value even after the caller
+ *    aborted mid-Redis-latency.
+ *  - **Cache hit honours abort**: if `signal.aborted` is true at policy
+ *    entry, we reject immediately — consistent with `act()`'s contract.
+ *
+ * # Single-flight (cache stampede prevention)
+ *
+ * On a sync store, the policy also stores the in-flight Promise under a
+ * separate `__inflight:cache:<key>` slot. Concurrent callers that miss the
+ * cache but find an in-flight Promise join it instead of launching duplicate
+ * work. This is the same mechanism `dedupePolicy` uses, applied internally
+ * to cache misses so users don't need to combine `cache` + `dedupe` to
+ * avoid stampedes.
+ *
+ * On an async store, single-flight is not possible (the same sync-store
+ * constraint as dedupe applies). Stampedes are a known limitation — document
+ * and pair with dedupe at a higher layer if you need single-flight semantics.
  *
- * Must be the OUTERMOST policy so a hit skips dedupe, timeout, and retry.
+ * # Fail-open writes
  *
- * Supports both SyncStateStore and AsyncStateStore. The async branch
- * introduces two await points (get + set) but has no correctness
- * requirement for same-tick execution — worst case is a cache stampede
- * on a simultaneous miss, which is standard behaviour without locking.
+ * If `store.set()` throws (e.g. Redis transient error), we swallow the error
+ * and return the value anyway. The caller gets their result; the next call
+ * will simply re-run `fn` and try to cache again. Caching is an optimisation,
+ * not a correctness requirement.
+ *
+ * # Cache hit semantics
+ *
+ * On a cache hit, `meta.source` is set to `'cache'` and `meta.attempts` is
+ * set to `0` — no work was performed.
+ *
+ * Failures are NEVER cached. Only successful values are stored.
  */
 export function cachePolicy(opts) {
-    return (fn, ctx) => async () => {
+    return (fn, ctx) => async (signal) => {
+        // Honour abort on cache hit too. Consistent with act()'s
+        // "reject immediately if signal aborted" contract.
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
         const key = NS + ctx.key;
+        const inflightKey = INFLIGHT_NS + ctx.key;
+        // ─── Sync store: fast path with single-flight ────────────────────────
         if (isSyncStore(ctx.store)) {
-            // Fast path — synchronous store, no await needed
-            const hit = ctx.store.get(key);
+            // Capture the narrowed sync store so closures (cleanup) keep the
+            // type information — TS doesn't carry `isSyncStore` narrowing
+            // into nested function bodies.
+            const store = ctx.store;
+            const obs = ctx.observability;
+            // 1. Cache hit?
+            const hit = store.get(key);
             if (hit) {
                 ctx.meta.source = 'cache';
+                ctx.meta.attempts = 0;
+                // Emit cache-hit event if hooks are registered.
+                // Compute actual age from the entry's insertion timestamp.
+                if (obs) {
+                    const ageMs = Date.now() - hit.insertedAt;
+                    obs.hooks.onCacheHit?.({
+                        type: 'cache-hit', key: ctx.key, traceId: obs.traceId,
+                        timestamp: Date.now(), ageMs: Math.max(0, ageMs),
+                    });
+                }
                 return hit.value;
             }
-            const value = await fn();
-            ctx.store.set(key, { value }, opts.ttl);
-            return value;
+            // Emit cache-miss event if hooks are registered.
+            if (obs) {
+                obs.hooks.onCacheMiss?.({
+                    type: 'cache-miss', key: ctx.key, traceId: obs.traceId,
+                    timestamp: Date.now(),
+                });
+            }
+            // 2. In-flight single-flight hit? Join it.
+            //
+            // The stored promise is RAW fn(signal). Joiners race it
+            // against their OWN signal only — originator abort doesn't
+            // propagate to joiners.
+            const inflight = store.get(inflightKey);
+            if (inflight) {
+                // Race the in-flight promise against OUR OWN signal. If we
+                // abort, we reject — but other joiners and the originator
+                // continue unaffected.
+                try {
+                    const value = await raceWithOwnSignal(inflight.promise, signal);
+                    // Mirror originator's meta so joiner's ActResult reflects
+                    // the real effort (attempts, source).
+                    ctx.meta.attempts = inflight.meta.attempts;
+                    ctx.meta.source = inflight.meta.source;
+                    return value;
+                }
+                catch (err) {
+                    // Copy meta on failure too (same as dedupe joiners)
+                    if (signal.aborted) {
+                        ctx.meta.attempts = 0;
+                    }
+                    else {
+                        ctx.meta.attempts = inflight.meta.attempts;
+                        ctx.meta.source = inflight.meta.source;
+                    }
+                    throw err;
+                }
+            }
+            // 3. Originator: launch fn, cache on success (fail-open).
+            //
+            // The stored promise is the RAW fn(signal) — NOT raceAbort-wrapped.
+            // Originator's own await is wrapped in raceWithOwnSignal so they
+            // can bail on their signal without affecting joiners.
+            const generation = nextGeneration();
+            const rawPromise = Promise.resolve(fn(signal)).then((value) => {
+                try {
+                    store.set(key, { value, insertedAt: Date.now() }, opts.ttl);
+                }
+                catch {
+                    // Fail-open: cache write failure should not surface to caller.
+                }
+                return value;
+            }, 
+            // Re-throw the error so joiners see it. Don't cache failures.
+            (err) => { throw err; });
+            // Publish the in-flight entry for single-flight. If store.set
+            // throws, single-flight is disabled for this call — concurrent
+            // callers will all run fn. Still correct, just less efficient.
+            try {
+                store.set(inflightKey, { promise: rawPromise, generation, meta: ctx.meta });
+            }
+            catch {
+                // Single-flight unavailable; proceed without publishing.
+                // Originator still gets their value (or error).
+            }
+            // Cleanup the in-flight slot on settle — generation-safe.
+            const cleanup = () => {
+                const current = store.get(inflightKey);
+                if (current && current.generation === generation) {
+                    try {
+                        store.delete(inflightKey);
+                    }
+                    catch { /* ignore */ }
+                }
+            };
+            rawPromise.then(cleanup, cleanup);
+            // Originator races the raw promise against their OWN signal.
+            return raceWithOwnSignal(rawPromise, signal);
         }
-        else {
-            // Async store path
-            const hit = await ctx.store.get(key);
-            if (hit) {
-                ctx.meta.source = 'cache';
-                return hit.value;
+        // Async store: no single-flight (race window unavoidable).
+        // Re-check signal.aborted between awaits.
+        const obs = ctx.observability;
+        const hit = await ctx.store.get(key);
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        if (hit) {
+            ctx.meta.source = 'cache';
+            ctx.meta.attempts = 0;
+            if (obs) {
+                const ageMs = Date.now() - hit.insertedAt;
+                obs.hooks.onCacheHit?.({
+                    type: 'cache-hit', key: ctx.key, traceId: obs.traceId,
+                    timestamp: Date.now(), ageMs: Math.max(0, ageMs),
+                });
             }
-            const value = await fn();
-            await ctx.store.set(key, { value }, opts.ttl);
-            return value;
+            return hit.value;
+        }
+        if (obs) {
+            obs.hooks.onCacheMiss?.({
+                type: 'cache-miss', key: ctx.key, traceId: obs.traceId,
+                timestamp: Date.now(),
+            });
+        }
+        const value = await fn(signal);
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        try {
+            await ctx.store.set(key, { value, insertedAt: Date.now() }, opts.ttl);
         }
+        catch {
+            // Fail-open: see sync path comment.
+        }
+        return value;
     };
 }
+/**
+ * Race a promise against a signal — but if the signal aborts, mark the
+ * underlying promise as handled (so its eventual rejection doesn't surface
+ * as an unhandled rejection). The underlying promise keeps running for any
+ * other consumers (e.g. joiners in single-flight).
+ *
+ * This is `raceAbort` from `utils/abort.ts`, inlined here to avoid an import
+ * cycle (cache.ts already imports from stores, dedupe imports from abort —
+ * keeping cache independent of abort reduces the import graph depth).
+ *
+ * Internal — not exported.
+ */
+function raceWithOwnSignal(promise, signal) {
+    if (signal.aborted) {
+        promise.catch(() => { }); // mark as handled
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort);
+        promise.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
 //# sourceMappingURL=cache.js.map

package/dist/policies/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/policies/cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C,MAAM,EAAE,GAAG,QAAQ,CAAA;AAOnB;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAAI,IAAkB;IAC/C,OAAO,CAAC,EAAY,EAAE,GAAkB,EAAY,EAAE,CACpD,KAAK,IAAI,EAAE;QACT,MAAM,GAAG,GAAG,EAAE,GAAG,GAAG,CAAC,GAAG,CAAA;QAExB,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,iDAAiD;YACjD,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAgB,GAAG,CAAC,CAAA;YAC7C,IAAI,GAAG,EAAE,CAAC;gBACR,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAA;gBACzB,OAAO,GAAG,CAAC,KAAK,CAAA;YAClB,CAAC;YAED,MAAM,KAAK,GAAG,MAAM,EAAE,EAAE,CAAA;YACxB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAgB,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAA;YACtD,OAAO,KAAK,CAAA;QACd,CAAC;aAAM,CAAC;YACN,mBAAmB;YACnB,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,GAAG,CAAgB,GAAG,CAAC,CAAA;YACnD,IAAI,GAAG,EAAE,CAAC;gBACR,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAA;gBACzB,OAAO,GAAG,CAAC,KAAK,CAAA;YAClB,CAAC;YAED,MAAM,KAAK,GAAG,MAAM,EAAE,EAAE,CAAA;YACxB,MAAM,GAAG,CAAC,KAAK,CAAC,GAAG,CAAgB,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAA;YAC5D,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC,CAAA;AACL,CAAC"}
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/policies/cache.ts"],"names":[],"mappings":"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"}