@leejpsd/nextjs-cache-handler 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,13 +1,12 @@
+import path2 from 'path';
+import 'url';
+import { createRequire } from 'module';
+import { promisify } from 'util';
+import { gzip, gunzip, brotliCompress, brotliDecompress, constants } from 'zlib';
 import { createHash } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -15,6 +14,27 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+function nodeRequire(id) {
+  try {
+    return packageRequire(id);
+  } catch {
+    return cwdRequire(id);
+  }
+}
+var packageRequire, cwdRequire;
+var init_node_require = __esm({
+  "src/shared/node-require.ts"() {
+    init_esm_shims();
+    packageRequire = createRequire(import.meta.url);
+    cwdRequire = createRequire(
+      path2.join(process.cwd(), "__resolve-anchor__.js")
+    );
+  }
+});
 
 // src/shared/client/adapter-redis.ts
 var adapter_redis_exports = {};
@@ -26,7 +46,7 @@ function adaptRedisV5(client) {
   return client;
 }
 function createRedisV5Client(config) {
-  const { createClient } = __require("redis");
+  const { createClient } = nodeRequire("redis");
   const useTls = config.tls ?? config.url.startsWith("rediss://");
   const opts = {
     url: config.url,
@@ -41,6 +61,8 @@ function createRedisV5Client(config) {
 }
 var init_adapter_redis = __esm({
   "src/shared/client/adapter-redis.ts"() {
+    init_esm_shims();
+    init_node_require();
   }
 });
 
@@ -50,7 +72,8 @@ __export(adapter_ioredis_exports, {
   adaptCluster: () => adaptCluster,
   adaptIoredis: () => adaptIoredis,
   createIoredisClient: () => createIoredisClient,
-  createIoredisCluster: () => createIoredisCluster
+  createIoredisCluster: () => createIoredisCluster,
+  createIoredisSentinel: () => createIoredisSentinel
 });
 function adapt(client, isClusterClient = false) {
   return {
@@ -133,6 +156,9 @@ function adapt(client, isClusterClient = false) {
     on: (event, listener) => {
       client.on(event, listener);
       return client;
+    },
+    dispose: () => {
+      client.disconnect();
     }
   };
 }
@@ -143,18 +169,36 @@ function adaptCluster(cluster) {
   return adapt(cluster, true);
 }
 function createIoredisClient(config) {
-  const IORedis = __require("ioredis");
+  const IORedis = nodeRequire("ioredis");
   const Ctor = IORedis.default ?? IORedis;
   return new Ctor(config.url, {
     password: config.password,
     connectTimeout: config.connectTimeout ?? 1500,
     tls: config.tls ? {} : void 0,
     lazyConnect: true,
-    maxRetriesPerRequest: 1
+    maxRetriesPerRequest: 1,
+    // Batch same-tick commands into one RTT (matches redis@5's default
+    // behavior) — makes Promise.all fan-outs a single pipeline.
+    enableAutoPipelining: true
+  });
+}
+function createIoredisSentinel(config) {
+  const IORedis = nodeRequire("ioredis");
+  const Ctor = IORedis.default ?? IORedis;
+  return new Ctor({
+    sentinels: config.sentinels,
+    name: config.name,
+    password: config.password,
+    sentinelPassword: config.sentinelPassword,
+    connectTimeout: config.connectTimeout ?? 1500,
+    tls: config.tls ? {} : void 0,
+    lazyConnect: true,
+    maxRetriesPerRequest: 1,
+    enableAutoPipelining: true
   });
 }
 function createIoredisCluster(config) {
-  const IORedis = __require("ioredis");
+  const IORedis = nodeRequire("ioredis");
   const ClusterCtor = IORedis.Cluster ?? IORedis.default.Cluster;
   return new ClusterCtor(config.nodes, {
     redisOptions: {
@@ -162,15 +206,29 @@ function createIoredisCluster(config) {
       tls: config.tls ? {} : void 0
     },
     enableReadyCheck: true,
-    lazyConnect: true
+    lazyConnect: true,
+    // Same-slot commands issued in the same tick share one pipeline.
+    enableAutoPipelining: true
   });
 }
 var init_adapter_ioredis = __esm({
   "src/shared/client/adapter-ioredis.ts"() {
+    init_esm_shims();
+    init_node_require();
   }
 });
 
+// src/index.ts
+init_esm_shims();
+
+// src/cache-components/index.ts
+init_esm_shims();
+
+// src/cache-components/handler.ts
+init_esm_shims();
+
 // src/shared/abort.ts
+init_esm_shims();
 var CacheTimeoutError = class extends Error {
   constructor(opName, ms) {
     super(`[@leejpsd/nextjs-cache-handler] ${opName} timed out after ${ms}ms`);
@@ -202,7 +260,41 @@ async function withAbortSignal(opName, ms, fn) {
   }
 }
 
+// src/shared/compress.ts
+init_esm_shims();
+var gzipAsync = promisify(gzip);
+var gunzipAsync = promisify(gunzip);
+var brotliCompressAsync = promisify(brotliCompress);
+var brotliDecompressAsync = promisify(brotliDecompress);
+var GZIP_MARKER = "__ncgz__:";
+var BROTLI_MARKER = "__ncbr__:";
+var MIN_COMPRESS_BYTES = 1024;
+var BROTLI_OPTS = {
+  params: { [constants.BROTLI_PARAM_QUALITY]: 5 }
+};
+async function compressValue(value, algo) {
+  if (!algo || Buffer.byteLength(value) < MIN_COMPRESS_BYTES) return value;
+  const input = Buffer.from(value);
+  if (algo === "gzip") {
+    return GZIP_MARKER + (await gzipAsync(input)).toString("base64");
+  }
+  return BROTLI_MARKER + (await brotliCompressAsync(input, BROTLI_OPTS)).toString("base64");
+}
+async function decompressValue(value) {
+  if (value === null) return null;
+  if (value.startsWith(GZIP_MARKER)) {
+    const buf = Buffer.from(value.slice(GZIP_MARKER.length), "base64");
+    return (await gunzipAsync(buf)).toString("utf8");
+  }
+  if (value.startsWith(BROTLI_MARKER)) {
+    const buf = Buffer.from(value.slice(BROTLI_MARKER.length), "base64");
+    return (await brotliDecompressAsync(buf)).toString("utf8");
+  }
+  return value;
+}
+
 // src/shared/client/index.ts
+init_esm_shims();
 async function buildClient(source) {
   if (typeof source === "function") {
     return await source();
@@ -220,6 +312,10 @@ async function buildClient(source) {
       const { adaptCluster: adaptCluster2, createIoredisCluster: createIoredisCluster2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
       return adaptCluster2(createIoredisCluster2(source));
     }
+    case "sentinel": {
+      const { adaptIoredis: adaptIoredis2, createIoredisSentinel: createIoredisSentinel2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptIoredis2(createIoredisSentinel2(source));
+    }
     default: {
       const exhaustive = source;
       throw new Error(
@@ -229,28 +325,45 @@ async function buildClient(source) {
   }
 }
 var ConnectionManager = class {
-  constructor(source, onError) {
+  constructor(source, onError, retry = {}) {
     this.source = source;
     this.onError = onError;
+    this.baseCooldownMs = retry.baseCooldownMs ?? 1e3;
+    this.maxCooldownMs = retry.maxCooldownMs ?? 3e4;
   }
   source;
   onError;
   client = null;
   connecting = null;
-  failed = false;
+  consecutiveFailures = 0;
+  lastFailureAt = 0;
+  baseCooldownMs;
+  maxCooldownMs;
+  cooldownMs() {
+    if (this.consecutiveFailures === 0) return 0;
+    return Math.min(
+      this.maxCooldownMs,
+      this.baseCooldownMs * 2 ** (this.consecutiveFailures - 1)
+    );
+  }
   async getOrConnect() {
     if (this.client?.isOpen) return this.client;
-    if (this.failed) return null;
     if (this.connecting) return this.connecting;
+    if (Date.now() - this.lastFailureAt < this.cooldownMs()) return null;
+    const stale = this.client;
+    this.client = null;
     this.connecting = (async () => {
+      disposeQuietly(stale);
       try {
         const c = await buildClient(this.source);
         c.on("error", (err) => this.onError(err));
         if (!c.isOpen) await c.connect();
         this.client = c;
+        this.consecutiveFailures = 0;
         return c;
       } catch (err) {
-        this.failed = true;
+        this.consecutiveFailures += 1;
+        this.lastFailureAt = Date.now();
         this.onError(err);
         return null;
       } finally {
@@ -260,13 +373,24 @@ var ConnectionManager = class {
     return this.connecting;
   }
   reset() {
+    disposeQuietly(this.client);
     this.client = null;
     this.connecting = null;
-    this.failed = false;
+    this.consecutiveFailures = 0;
+    this.lastFailureAt = 0;
   }
 };
+function disposeQuietly(client) {
+  if (!client) return;
+  const c = client;
+  try {
+    (c.dispose ?? c.destroy ?? c.disconnect)?.call(c);
+  } catch {
+  }
+}
 
 // src/shared/logger.ts
+init_esm_shims();
 var defaultLogger = {
   debug: () => {
   },
@@ -282,6 +406,9 @@ var defaultLogger = {
   }
 };
 
+// src/shared/lua/index.ts
+init_esm_shims();
+
 // src/shared/lua/set-with-tags.lua
 var set_with_tags_default = `-- set-with-tags.lua
 --
@@ -385,13 +512,19 @@ async function execLuaScript(client, name, keys, args) {
 }
 
 // src/shared/memory-fallback.ts
+init_esm_shims();
 var MAX_TIMER_MS = 2147483647;
 function clampTimerMs(ms) {
   return Math.min(Math.max(0, ms), MAX_TIMER_MS);
 }
+var DEFAULT_MAX_ENTRIES = 1e3;
 var MemoryStore = class {
   kv = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+    this.maxEntries = Math.max(1, maxEntries);
+  }
   set(key, value, ttlSeconds) {
     this.delete(key);
     const expiresAt = Date.now() + ttlSeconds * 1e3;
@@ -401,6 +534,10 @@ var MemoryStore = class {
       timer.unref();
     }
     this.timers.set(key, timer);
+    while (this.kv.size > this.maxEntries) {
+      const oldest = this.kv.keys().next().value;
+      this.delete(oldest);
+    }
   }
   get(key) {
     const entry = this.kv.get(key);
@@ -409,6 +546,8 @@ var MemoryStore = class {
       this.delete(key);
       return null;
     }
+    this.kv.delete(key);
+    this.kv.set(key, entry);
     return entry.value;
   }
   delete(key) {
@@ -443,13 +582,19 @@ var MemorySetStore = class {
   sets = /* @__PURE__ */ new Map();
   expiresAt = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
+  maxSets;
+  constructor(maxSets = DEFAULT_MAX_ENTRIES) {
+    this.maxSets = Math.max(1, maxSets);
+  }
   sAdd(key, member) {
     const members = Array.isArray(member) ? member : [member];
     let set = this.sets.get(key);
     if (!set) {
       set = /* @__PURE__ */ new Set();
-      this.sets.set(key, set);
+    } else {
+      this.sets.delete(key);
     }
+    this.sets.set(key, set);
     let added = 0;
     for (const m of members) {
       if (!set.has(m)) {
@@ -457,6 +602,10 @@ var MemorySetStore = class {
         added += 1;
       }
     }
+    while (this.sets.size > this.maxSets) {
+      const oldest = this.sets.keys().next().value;
+      this.delete(oldest);
+    }
     return added;
   }
   sMembers(key) {
@@ -509,6 +658,7 @@ var MemorySetStore = class {
 };
 
 // src/shared/metrics.ts
+init_esm_shims();
 var counters = /* @__PURE__ */ new Map();
 function bump(event) {
   const existing = counters.get(event.type);
@@ -548,6 +698,7 @@ function getMetricSnapshot() {
 }
 
 // src/shared/namespace.ts
+init_esm_shims();
 var FALLBACK = "unversioned";
 function resolveBuildNamespace(override) {
   if (override !== void 0) {
@@ -561,6 +712,7 @@ function buildKey(prefix, namespace, rest, hashTag = false) {
 }
 
 // src/shared/build-phase.ts
+init_esm_shims();
 var PHASE_PRODUCTION_BUILD = "phase-production-build";
 function isBuildPhase() {
   return process.env.NEXT_PHASE === PHASE_PRODUCTION_BUILD;
@@ -573,6 +725,7 @@ function shouldUseRedis(opts) {
 }
 
 // src/cache-components/serialize.ts
+init_esm_shims();
 async function readStreamFully(stream) {
   const reader = stream.getReader();
   const chunks = [];
@@ -615,6 +768,7 @@ function decodeEnvelope(raw) {
 }
 
 // src/cache-components/swr.ts
+init_esm_shims();
 var SECOND_MS = 1e3;
 function partitionEntry(entry, now = Date.now()) {
   const ageMs = now - entry.timestamp;
@@ -673,8 +827,8 @@ function init(opts) {
     logger,
     emit,
     conn,
-    memEntries: new MemoryStore(),
-    memTags: new MemorySetStore(),
+    memEntries: new MemoryStore(opts.memoryMaxEntries),
+    memTags: new MemorySetStore(opts.memoryMaxEntries),
     memTagExp: /* @__PURE__ */ new Map(),
     localTagTimestamps: /* @__PURE__ */ new Map(),
     resolveNs: () => resolveBuildNamespace(opts.buildNamespace),
@@ -791,6 +945,12 @@ async function getImpl(state, cacheKey, softTags) {
     state.emit({ type: "cache.miss", ms: Date.now() - start });
     return void 0;
   }
+  try {
+    raw = await decompressValue(raw);
+  } catch {
+    state.emit({ type: "cache.miss", meta: { reason: "decode-error" } });
+    return void 0;
+  }
   envelope = decodeEnvelope(raw);
   if (!envelope) {
     state.emit({ type: "cache.miss", meta: { reason: "decode-error" } });
@@ -919,10 +1079,14 @@ async function setImpl(state, cacheKey, pendingEntry) {
           }
           return;
         }
+        const wirePayload = await compressValue(
+          payload,
+          state.opts.rest.compression
+        );
         if (entry.tags.length === 0) {
-          await client.set(eKey, payload, { EX: ttl });
+          await client.set(eKey, wirePayload, { EX: ttl });
         } else {
-          await luaSetWithTags(client, state, eKey, payload, ttl, entry.tags);
+          await luaSetWithTags(client, state, eKey, wirePayload, ttl, entry.tags);
         }
       }
     );
@@ -958,28 +1122,36 @@ async function refreshTagsImpl(state) {
       async () => {
         const client = await state.conn.getOrConnect();
         if (!client) return;
-        const pattern = `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}*`;
-        const seen = [];
+        const ns = state.opts.hashTag ? `{${state.resolveNs()}}` : state.resolveNs();
+        const pattern = `${escapeMatch(
+          `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}${ns}:`
+        )}*`;
+        const scanStartMs = Date.now();
+        const fresh = /* @__PURE__ */ new Map();
         for await (const chunk of client.scanIterator({
           MATCH: pattern,
           COUNT: 100
         })) {
           const keys = Array.isArray(chunk) ? chunk.map(String) : [String(chunk)];
-          seen.push(...keys);
-          if (seen.length >= 500) break;
+          if (keys.length === 0) continue;
+          const values = await client.mGet(keys);
+          for (let i = 0; i < keys.length; i += 1) {
+            const v = values[i];
+            if (!v) continue;
+            const ts = Number.parseInt(v, 10);
+            if (!Number.isFinite(ts)) continue;
+            const key = keys[i];
+            if (key === void 0) continue;
+            const tag = stripExpPrefix(state, key);
+            if (tag) fresh.set(tag, ts);
+          }
         }
-        if (seen.length === 0) return;
-        const values = await client.mGet(seen);
-        for (let i = 0; i < seen.length; i += 1) {
-          const v = values[i];
-          if (!v) continue;
-          const ts = Number.parseInt(v, 10);
-          if (!Number.isFinite(ts)) continue;
-          const key = seen[i];
-          if (key === void 0) continue;
-          const tag = stripExpPrefix(state, key);
-          if (tag) state.localTagTimestamps.set(tag, ts);
+        for (const [tag, ts] of state.localTagTimestamps) {
+          if (ts >= scanStartMs && (fresh.get(tag) ?? 0) < ts) {
+            fresh.set(tag, ts);
+          }
         }
+        state.localTagTimestamps = fresh;
       }
     );
   } catch (err) {
@@ -988,6 +1160,19 @@ async function refreshTagsImpl(state) {
     });
   }
 }
+function escapeMatch(s) {
+  return s.replace(/[\\*?[\]]/g, "\\$&");
+}
+var MAX_LOCAL_TAG_ENTRIES = 1e4;
+function pruneOldestByTimestamp(map, maxEntries) {
+  if (map.size <= maxEntries) return;
+  const byAge = [...map.entries()].sort((a, b) => a[1] - b[1]);
+  const drop = map.size - maxEntries;
+  for (let i = 0; i < drop; i += 1) {
+    const entry = byAge[i];
+    if (entry) map.delete(entry[0]);
+  }
+}
 function stripExpPrefix(state, fullKey) {
   const ns = state.resolveNs();
   const prefix = state.opts.hashTag ? `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}{${ns}}:` : `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}${ns}:`;
@@ -1039,6 +1224,7 @@ async function updateTagsImpl(state, tags, durations) {
     state.localTagTimestamps.set(t, now);
     state.memTagExp.set(t, now);
   }
+  pruneOldestByTimestamp(state.memTagExp, MAX_LOCAL_TAG_ENTRIES);
   if (!gateRedis(state)) {
     if (isHardExpire) {
       for (const t of tags) {
@@ -1068,20 +1254,18 @@ async function updateTagsImpl(state, tags, durations) {
           }
           return;
         }
-        for (const t of tags) {
-          if (isHardExpire) {
-            await execLuaScript(
+        await Promise.all(
+          tags.map(
+            (t) => isHardExpire ? execLuaScript(
               client,
               "revalidateHard",
               [tagKey(state, t), tagExpKey(state, t)],
               [String(now), String(TAG_EXP_MARKER_TTL_SEC)]
-            );
-          } else {
-            await client.set(tagExpKey(state, t), String(now), {
+            ) : client.set(tagExpKey(state, t), String(now), {
               EX: TAG_EXP_MARKER_TTL_SEC
-            });
-          }
-        }
+            })
+          )
+        );
       }
     );
     state.emit({
@@ -1111,7 +1295,14 @@ function createCacheComponentsHandler(opts) {
   };
 }
 
+// src/incremental/index.ts
+init_esm_shims();
+
+// src/incremental/handler.ts
+init_esm_shims();
+
 // src/incremental/serialize.ts
+init_esm_shims();
 function isEnvelope(value) {
   return typeof value === "object" && value !== null && "__type" in value && typeof value.__type === "string";
 }
@@ -1193,7 +1384,7 @@ function init2(opts) {
     logger,
     emit,
     conn,
-    memEntries: new MemoryStore(),
+    memEntries: new MemoryStore(opts.memoryMaxEntries),
     memTagStates: /* @__PURE__ */ new Map(),
     resolveNs: () => resolveBuildNamespace(opts.buildNamespace)
   };
@@ -1252,7 +1443,7 @@ function normalizeTtlSeconds(data, ctx) {
       return ONE_YEAR_SEC2;
     }
   }
-  const revalidate = ctx?.cacheControl?.revalidate;
+  const revalidate = ctx?.cacheControl?.revalidate ?? ctx?.revalidate;
   if (revalidate === false || revalidate === void 0) return ONE_YEAR_SEC2;
   if (typeof revalidate === "number" && revalidate > 0) {
     return Math.min(Math.max(Math.ceil(revalidate), MIN_TTL_SEC), ONE_YEAR_SEC2);
@@ -1290,10 +1481,49 @@ async function readTagStates(state, tags) {
 var IncrementalRedisCacheHandler = class {
   state;
   revalidatedTags;
+  /**
+   * Request-scoped memo of Redis entry reads. Next.js instantiates this class
+   * per request (and calls resetRequestCache() at request boundaries when it
+   * reuses an instance), so entries live at most one request. Bounded by the
+   * number of distinct cache keys a single request touches.
+   */
+  requestMemo = /* @__PURE__ */ new Map();
   constructor(state, ctx) {
     this.state = state;
     this.revalidatedTags = normalizeTags(ctx?.revalidatedTags);
   }
+  /**
+   * Redis entry read, deduplicated per request: parallel RSC renders or
+   * repeated fetch() calls hitting the same cache key share one GET. The
+   * memoized promise never rejects — errors are converted to a miss (with
+   * the same timeout metric the inline path emitted before).
+   */
+  readEntryDeduped(eKey) {
+    const memoized = this.requestMemo.get(eKey);
+    if (memoized) {
+      this.state.emit({ type: "cache.get.deduped" });
+      return memoized;
+    }
+    const read = withAbortSignal(
+      "incremental.get",
+      this.state.opts.abortTimeoutMs,
+      async () => {
+        const client = await this.state.conn.getOrConnect();
+        if (!client) return null;
+        return await decompressValue(await client.get(eKey));
+      }
+    ).catch((err) => {
+      if (err instanceof CacheTimeoutError) {
+        this.state.emit({
+          type: "redis.timeout",
+          meta: { op: "incremental.get" }
+        });
+      }
+      return null;
+    });
+    this.requestMemo.set(eKey, read);
+    return read;
+  }
   async get(cacheKey, ctx) {
     try {
       const requestedTags = normalizeTags([
@@ -1305,24 +1535,11 @@ var IncrementalRedisCacheHandler = class {
       const useRedis = !useLocal && gateRedis2(this.state);
       let raw = null;
       if (useRedis) {
-        try {
-          raw = await withAbortSignal(
-            "incremental.get",
-            this.state.opts.abortTimeoutMs,
-            async () => {
-              const client = await this.state.conn.getOrConnect();
-              if (!client) return null;
-              return await client.get(eKey);
-            }
-          );
-        } catch (err) {
-          if (err instanceof CacheTimeoutError) {
-            this.state.emit({ type: "redis.timeout", meta: { op: "incremental.get" } });
-          }
-          raw = null;
-        }
+        raw = await this.readEntryDeduped(eKey);
+      }
+      if (raw === null && (useLocal || this.state.opts.fallback !== "never")) {
+        raw = this.state.memEntries.get(eKey);
       }
-      if (raw === null) raw = this.state.memEntries.get(eKey);
       if (raw === null) {
         this.state.emit({ type: "cache.miss" });
         return null;
@@ -1335,7 +1552,7 @@ var IncrementalRedisCacheHandler = class {
         return null;
       }
       const tagStates = await readTagStates(this.state, tags);
-      const isFetch = ctx?.kind === "FETCH";
+      const isFetch = ctx?.kind === "FETCH" || ctx?.kindHint?.toLowerCase() === "fetch" || typeof parsed.value === "object" && parsed.value !== null && parsed.value.kind === "FETCH";
       if (tagStates.some((s) => isTagStateExpired(s, parsed.lastModified, isFetch))) {
         this.state.emit({ type: "cache.miss", meta: { reason: "tag-state-expired" } });
         return null;
@@ -1358,6 +1575,7 @@ var IncrementalRedisCacheHandler = class {
       const record = { lastModified: Date.now(), value: data };
       const serialized = serializeCacheRecord(record);
       const eKey = entryKey2(this.state, cacheKey);
+      this.requestMemo.delete(eKey);
       const useRedis = !useLocal && gateRedis2(this.state);
       if (useRedis) {
         try {
@@ -1367,10 +1585,19 @@ var IncrementalRedisCacheHandler = class {
             async () => {
               const client = await this.state.conn.getOrConnect();
               if (!client) {
-                this.state.memEntries.set(eKey, serialized, ttl);
+                if (this.state.opts.fallback !== "never") {
+                  this.state.memEntries.set(eKey, serialized, ttl);
+                }
                 return;
               }
-              await client.set(eKey, serialized, { EX: ttl });
+              await client.set(
+                eKey,
+                await compressValue(
+                  serialized,
+                  this.state.opts.rest.compression
+                ),
+                { EX: ttl }
+              );
             }
           );
           this.state.emit({ type: "cache.set", meta: { backend: "redis" } });
@@ -1381,8 +1608,15 @@ var IncrementalRedisCacheHandler = class {
           }
         }
       }
-      this.state.memEntries.set(eKey, serialized, ttl);
-      this.state.emit({ type: "cache.set", meta: { backend: "memory" } });
+      if (useLocal || this.state.opts.fallback !== "never") {
+        this.state.memEntries.set(eKey, serialized, ttl);
+        this.state.emit({ type: "cache.set", meta: { backend: "memory" } });
+      } else {
+        this.state.emit({
+          type: "cache.set.failed",
+          meta: { reason: "no-fallback" }
+        });
+      }
     } catch (err) {
       this.state.logger.error("set() error", {
         message: err.message
@@ -1436,6 +1670,7 @@ var IncrementalRedisCacheHandler = class {
     }
   }
   resetRequestCache() {
+    this.requestMemo.clear();
   }
 };
 function createIncrementalCacheHandler(opts) {