@blamejs/blamejs-shop 0.5.12 → 0.5.13

package/lib/vendor/blamejs/test/layer-0-primitives/cache.test.js

@@ -16,6 +16,7 @@ var path           = helpers.path;
 var check          = helpers.check;
 var setupTestDb    = helpers.setupTestDb;
 var teardownTestDb = helpers.teardownTestDb;
+var waitUntil      = helpers.waitUntil;
 
 // ---- Surface ----
 
@@ -875,6 +876,580 @@ async function testValidationNewOpts() {
   check("validation: rejects non-bool slidingTtl", threw);
 }
 
+// ---- Uncovered-branch coverage: config-time validation ----
+
+async function testInfinityCapsAccepted() {
+  // maxEntries: Infinity and maxBytes: Infinity take the early-return
+  // branch in the validators (uncapped memory backend).
+  var c1 = b.cache.create({ namespace: "inf-entries", maxEntries: Infinity });
+  await c1.set("k", "v");
+  check("maxEntries: Infinity accepted (uncapped)", (await c1.get("k")) === "v");
+  await c1.close();
+
+  var c2 = b.cache.create({ namespace: "inf-bytes", maxBytes: Infinity });
+  await c2.set("k", "v");
+  check("maxBytes: Infinity accepted (uncapped)", (await c2.get("k")) === "v");
+  await c2.close();
+}
+
+async function testInvalidBackendString() {
+  var threwBogus = false;
+  try { b.cache.create({ namespace: "n", backend: "postgres-cache" }); }
+  catch (_e) { threwBogus = true; }
+  check("create() with unrecognized backend string throws", threwBogus);
+
+  // backend: "redis" with an empty-string redisUrl trips the length===0
+  // arm of the redisUrl guard (distinct from the missing-url arm).
+  var threwEmptyUrl = false;
+  try { b.cache.create({ namespace: "n", backend: "redis", redisUrl: "" }); }
+  catch (_e) { threwEmptyUrl = true; }
+  check("create() backend='redis' with empty redisUrl throws", threwEmptyUrl);
+}
+
+async function testDefaultSizeOfVariants() {
+  // No custom sizeOf → the framework's _defaultSizeOf runs on every set().
+  // Drive the null/undefined, Buffer, and JSON-unserializable arms that the
+  // existing number/object/string cases never reach.
+  var c = b.cache.create({ namespace: "sizeof-default" });
+  await c.set("nul", null);
+  await c.set("buf", Buffer.from("hello"));
+  await c.set("big", { n: 10n });        // JSON.stringify throws on BigInt → catch → 0
+  check("default sizeOf: null value stored (0 bytes arm)",   (await c.get("nul")) === null);
+  check("default sizeOf: Buffer value stored (length arm)",  Buffer.isBuffer(await c.get("buf")));
+  check("default sizeOf: JSON-unserializable value stored (catch arm)",
+        (await c.get("big")).n === 10n);
+  // bytes() reflects: null=0, Buffer("hello")=5, bigint-object=0 → total 5.
+  check("default sizeOf: bytes() totals the finite arms only", (await c.bytes()) === 5);
+  await c.close();
+}
+
+// ---- Uncovered-branch coverage: memory has() lazy expiry ----
+
+async function testHasExpiredEvicts() {
+  var clk = b.testing.fakeClock(1_000_000);
+  var captured = [];
+  var c = b.cache.create({
+    namespace:     "has-expired",
+    ttlMs:         100,
+    clock:         clk.now,
+    observability: { event: function (n, _v, l) { captured.push({ n: n, l: l }); } },
+  });
+  await c.set("k", "v");
+  clk.advance(200);   // past ttl
+  check("has() on expired key returns false + lazy-evicts", (await c.has("k")) === false);
+  check("has() lazy-evict emits cache.eviction.expired",
+        captured.filter(function (e) { return e.n === "cache.eviction.expired"; }).length >= 1);
+  // The entry is physically gone now.
+  check("has() lazy-evict removed the entry", (await c.size()) === 0);
+  await c.close();
+}
+
+// ---- Uncovered-branch coverage: backend-error catch on every method ----
+
+async function testBackendErrorAllMethods() {
+  var audit = b.testing.captureAudit();
+  var codedErr = function () { var e = new Error("backend down"); e.code = "ECONNREFUSED"; return e; };
+  var reject = function () { return Promise.reject(codedErr()); };
+  var failing = {
+    // required surface
+    get:   reject,
+    set:   reject,
+    del:   reject,
+    clear: reject,
+    size:  reject,
+    close: function () { return Promise.resolve(); },
+    // optional surface — present so the wrapper forwards (rather than
+    // falling back), letting the cache method's own catch fire.
+    has:           reject,
+    bytes:         reject,
+    invalidateTag: reject,
+    getTags:       reject,
+  };
+  var c = b.cache.create({ namespace: "fail-all", backend: failing, audit: audit });
+
+  async function expectThrow(label, fn) {
+    var threw = false;
+    try { await fn(); } catch (_e) { threw = true; }
+    check(label, threw);
+  }
+  await expectThrow("get() propagates backend error",           function () { return c.get("k"); });
+  await expectThrow("set() propagates backend error",           function () { return c.set("k", "v"); });
+  await expectThrow("del() propagates backend error",           function () { return c.del("k"); });
+  await expectThrow("has() propagates backend error",           function () { return c.has("k"); });
+  await expectThrow("clear() propagates backend error",         function () { return c.clear(); });
+  await expectThrow("size() propagates backend error",          function () { return c.size(); });
+  await expectThrow("bytes() propagates backend error",         function () { return c.bytes(); });
+  await expectThrow("invalidateTag() propagates backend error", function () { return c.invalidateTag("t"); });
+  await expectThrow("getTags() propagates backend error",       function () { return c.getTags("k"); });
+  await expectThrow("wrap() propagates backend get error",      function () { return c.wrap("k", function () { return "x"; }); });
+
+  var failedAudits = audit.byAction("cache.backend.failed");
+  check("every failing method emits a cache.backend.failed audit", failedAudits.length >= 10);
+  // The error's own .code rides in the audit metadata (the err.code arm).
+  check("backend.failed audit carries the backend error code",
+        failedAudits.some(function (e) { return e.metadata && e.metadata.code === "ECONNREFUSED"; }));
+  await c.close();
+}
+
+async function testUpdateMutatorThrows() {
+  // A mutatorFn that throws surfaces through backend.update as a backend
+  // error — driving cache.update's catch (emit + audit + rethrow).
+  var audit = b.testing.captureAudit();
+  var c = b.cache.create({ namespace: "upd-throw", audit: audit });
+  var threw = false;
+  try {
+    await c.update("k", function () { throw new Error("mutator boom"); });
+  } catch (_e) { threw = true; }
+  check("update() rethrows a throwing mutator", threw);
+  check("update() throwing mutator emits cache.backend.failed audit",
+        audit.byAction("cache.backend.failed").length === 1);
+  await c.close();
+}
+
+// ---- Uncovered-branch coverage: custom-backend optional-method fallbacks ----
+
+async function testCustomBackendOptionalFallbacks() {
+  // A custom backend that implements ONLY the required surface. The
+  // wrapper synthesizes has (get-and-coerce), bytes (0), invalidateTag
+  // (0), getTags (null).
+  var store = new Map();
+  var minimal = {
+    get:   function (k) { return Promise.resolve(store.get(k)); },
+    set:   function (k, v) { store.set(k, v); return Promise.resolve(); },
+    del:   function (k) { var ex = store.has(k); store.delete(k); return Promise.resolve(ex); },
+    clear: function () { var n = store.size; store.clear(); return Promise.resolve(n); },
+    size:  function () { return Promise.resolve(store.size); },
+    close: function () { return Promise.resolve(); },
+  };
+  var c = b.cache.create({ namespace: "custom-min", backend: minimal });
+  await c.set("present", "v");
+  check("custom has() falls back to get-and-coerce (present → true)",  (await c.has("present")) === true);
+  check("custom has() falls back to get-and-coerce (absent → false)",  (await c.has("absent")) === false);
+  check("custom bytes() falls back to 0",                              (await c.bytes()) === 0);
+  check("custom invalidateTag() falls back to 0",                      (await c.invalidateTag("t")) === 0);
+  check("custom getTags() falls back to null",                         (await c.getTags("present")) === null);
+  await c.close();
+}
+
+async function testSealRejectedOnNonCluster() {
+  var c = b.cache.create({ namespace: "seal-mem" });
+  var threwSet = false;
+  try { await c.set("k", "v", { seal: true }); } catch (_e) { threwSet = true; }
+  check("set(seal:true) on memory backend throws (cluster-only feature)", threwSet);
+
+  var threwUpd = false;
+  try { await c.update("k", function () { return { value: "v" }; }, { seal: true }); }
+  catch (_e) { threwUpd = true; }
+  check("update(seal:true) on memory backend throws (cluster-only feature)", threwUpd);
+  await c.close();
+}
+
+async function testUpdateUnsupportedAndBadMutator() {
+  // Custom backend has no atomic update → cache.update throws UNSUPPORTED.
+  var store = new Map();
+  var minimal = {
+    get:   function (k) { return Promise.resolve(store.get(k)); },
+    set:   function (k, v) { store.set(k, v); return Promise.resolve(); },
+    del:   function (k) { store.delete(k); return Promise.resolve(true); },
+    clear: function () { store.clear(); return Promise.resolve(0); },
+    size:  function () { return Promise.resolve(store.size); },
+    close: function () { return Promise.resolve(); },
+  };
+  var cCustom = b.cache.create({ namespace: "upd-unsupported", backend: minimal });
+  var threwUnsupported = false;
+  try { await cCustom.update("k", function () { return { value: 1 }; }); }
+  catch (_e) { threwUnsupported = true; }
+  check("update() on a custom backend without update throws UNSUPPORTED", threwUnsupported);
+  await cCustom.close();
+
+  // Non-function mutator → BAD_OPT (guarded before backend dispatch).
+  var cMem = b.cache.create({ namespace: "upd-badmutator" });
+  var threwBadMutator = false;
+  try { await cMem.update("k", "not-a-function"); } catch (_e) { threwBadMutator = true; }
+  check("update() with non-function mutator throws", threwBadMutator);
+  await cMem.close();
+}
+
+async function testInvalidateTagBadArg() {
+  var c = b.cache.create({ namespace: "tag-badarg" });
+  var threwNonString = false;
+  try { await c.invalidateTag(42); } catch (_e) { threwNonString = true; }
+  check("invalidateTag(non-string) throws", threwNonString);
+
+  var threwEmpty = false;
+  try { await c.invalidateTag(""); } catch (_e) { threwEmpty = true; }
+  check("invalidateTag('') throws", threwEmpty);
+  await c.close();
+}
+
+async function testUpdateMemoryExpiresAtDecision() {
+  // A committing decision may pin the written value's absolute expiry via
+  // { value, expiresAt } — the branch distinct from the { value, ttlMs }
+  // case the existing update test drives.
+  var nowMs = 6_000_000;
+  var c = b.cache.create({ namespace: "upd-expiresat", clock: function () { return nowMs; } });
+  await c.update("k", function () { return { value: "pinned", expiresAt: nowMs + 50 }; });
+  check("update decision.expiresAt honored (before expiry)", (await c.get("k")) === "pinned");
+  nowMs += 100;
+  check("update decision.expiresAt honored (after expiry)",  (await c.get("k")) === undefined);
+  await c.close();
+}
+
+async function testObservabilitySinkThrowsSwallowed() {
+  // The hot-path observability sink is drop-silent: a throwing operator
+  // sink must not surface to the caller.
+  var c = b.cache.create({
+    namespace:     "obs-throw",
+    observability: { event: function () { throw new Error("sink boom"); } },
+  });
+  var surfaced = false;
+  try {
+    await c.set("k", "v");
+    await c.get("k");
+  } catch (_e) { surfaced = true; }
+  check("throwing observability sink is swallowed (drop-silent)", surfaced === false);
+  await c.close();
+}
+
+// ---- Uncovered-branch coverage: SWR internals ----
+
+async function testSwrInfinityTtl() {
+  // SWR write path with an Infinity ttl: hard-TTL stays Infinity, no soft
+  // expiry is tracked (the else arm), entry never goes stale.
+  var nowMs = 1_700_000_000_000;
+  var c = b.cache.create({
+    namespace:            "swr-inf",
+    ttlMs:                b.constants.TIME.minutes(5),
+    staleWhileRevalidate: true,
+    clock:                function () { return nowMs; },
+  });
+  var calls = 0;
+  var fn = function () { calls++; return "v"; };
+  await c.wrap("k", fn, { ttlMs: Infinity });
+  nowMs += b.constants.TIME.days(365);
+  var again = await c.wrap("k", fn, { ttlMs: Infinity });
+  check("SWR Infinity ttl: value never goes stale (no recompute)",
+        again === "v" && calls === 1);
+  await c.close();
+}
+
+async function testSwrBackgroundRefreshFailure() {
+  // Past soft TTL, the background refresh runs fn again; when that fn
+  // rejects, the stale value was already served and the failure surfaces
+  // only via cache.refresh.failed observability.
+  var nowMs = 1_700_000_000_000;
+  var captured = [];
+  var c = b.cache.create({
+    namespace:            "swr-refresh-fail",
+    ttlMs:                100,
+    staleWhileRevalidate: true,
+    clock:                function () { return nowMs; },
+    observability:        { event: function (n, _v, l) { captured.push({ n: n, l: l }); } },
+  });
+  var mode = "ok";
+  var fn = function () {
+    if (mode === "boom") return Promise.reject(new Error("refresh failed"));
+    return Promise.resolve("fresh");
+  };
+  var first = await c.wrap("k", fn);
+  check("SWR refresh-fail: first call computes fresh", first === "fresh");
+
+  nowMs += 150;          // past soft (100), before hard (200)
+  mode = "boom";
+  var stale = await c.wrap("k", fn);   // serves stale + kicks background refresh
+  check("SWR refresh-fail: serves stale while refreshing", stale === "fresh");
+
+  await waitUntil(function () {
+    return captured.filter(function (e) { return e.n === "cache.refresh.failed"; }).length >= 1;
+  }, { timeoutMs: 4000, label: "swr background refresh failure emitted" });
+  check("SWR refresh-fail: emits cache.refresh.failed on background error",
+        captured.filter(function (e) { return e.n === "cache.refresh.failed"; }).length >= 1);
+  await c.close();
+}
+
+async function testSwrWriteFailure() {
+  // Under SWR, a miss computes the value then persists it through
+  // _writeWithSwr; when that backend.set rejects, the failure is captured
+  // via observability + audit and does not fail the wrap.
+  var audit = b.testing.captureAudit();
+  var readOnlyBackend = {
+    get:   function () { return Promise.resolve(undefined); },   // always a miss
+    set:   function () { return Promise.reject(new Error("read-only")); },
+    del:   function () { return Promise.resolve(false); },
+    clear: function () { return Promise.resolve(0); },
+    size:  function () { return Promise.resolve(0); },
+    close: function () { return Promise.resolve(); },
+  };
+  var c = b.cache.create({
+    namespace:            "swr-write-fail",
+    backend:              readOnlyBackend,
+    audit:                audit,
+    staleWhileRevalidate: true,
+    ttlMs:                100,
+  });
+  var v = await c.wrap("k", function () { return "computed"; });
+  check("SWR write-fail: wrap returns computed value despite failed set", v === "computed");
+  await waitUntil(function () { return audit.byAction("cache.backend.failed").length >= 1; },
+    { timeoutMs: 4000, label: "SWR _writeWithSwr set failure audited" });
+  check("SWR write-fail: failed persist emits cache.backend.failed audit",
+        audit.byAction("cache.backend.failed").length >= 1);
+  await c.close();
+}
+
+async function testRedisBackendConstructs() {
+  // The redis backend wires through cache-redis with a lazy connect, so
+  // building + closing the instance is network-free (no op ever fires).
+  // This exercises the create() redis-backend resolution branch without a
+  // live server.
+  var c = b.cache.create({
+    namespace: "redis-construct",
+    backend:   "redis",
+    redisUrl:  "redis://127.0.0.1:6390/0",
+  });
+  check("redis backend: instance exposes get/set/close",
+        typeof c.get === "function" && typeof c.set === "function" && typeof c.close === "function");
+  check("redis backend: resolved as a custom-wrapped backend", c._backend && c._backend.name === "custom");
+  await c.close();   // never connected — close is a no-op teardown
+}
+
+async function testWrapSetFailureNonSwr() {
+  // Non-SWR wrap: a miss computes the value, then the backend.set rejects.
+  // The wrap still resolves to the computed value (failed write doesn't
+  // fail the wrap) but emits cache.backend.failed.
+  var audit = b.testing.captureAudit();
+  var readOnlyBackend = {
+    get:   function () { return Promise.resolve(undefined); },   // always a miss
+    set:   function () { return Promise.reject(new Error("read-only")); },
+    del:   function () { return Promise.resolve(false); },
+    clear: function () { return Promise.resolve(0); },
+    size:  function () { return Promise.resolve(0); },
+    close: function () { return Promise.resolve(); },
+  };
+  var c = b.cache.create({ namespace: "wrap-set-fail", backend: readOnlyBackend, audit: audit });
+  var v = await c.wrap("k", function () { return "computed"; });
+  check("wrap: computed value returned despite failed backend write", v === "computed");
+  check("wrap: failed backend write emits cache.backend.failed audit",
+        audit.byAction("cache.backend.failed").length >= 1);
+  await c.close();
+}
+
+// ---- Uncovered-branch coverage: cross-node invalidation via pubsub ----
+
+async function testMemoryInfinityWriteArms() {
+  // The Infinity-lifetime arm of set / update / wrap expiry resolution
+  // (expiresAt = Infinity rather than clock()+ttlMs), plus getTags on an
+  // entry stored without any tags (the empty-array arm).
+  var c = b.cache.create({ namespace: "inf-arms", ttlMs: 100 });
+  await c.set("s", "v", { ttlMs: Infinity });
+  check("set(ttlMs:Infinity): getTags on an untagged entry returns []",
+        Array.isArray(await c.getTags("s")) && (await c.getTags("s")).length === 0);
+
+  await c.update("u", function () { return { value: 1 }; }, { ttlMs: Infinity });
+  check("update(ttlMs:Infinity): value written", (await c.get("u")) === 1);
+
+  var w = await c.wrap("w", function () { return "computed"; }, { ttlMs: Infinity });
+  check("wrap(ttlMs:Infinity): value computed + cached", w === "computed" && (await c.get("w")) === "computed");
+  await c.close();
+}
+
+async function testClusterInfinityAndEmptyClear() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-cache-infclu-"));
+  try {
+    await setupTestDb(tmpDir);
+    var c = b.cache.create({ namespace: "cb-inf", backend: "cluster", ttlMs: 100 });
+    // clear() over an empty namespace: rowCount is falsy → the `|| 0` arm.
+    check("cluster clear on empty namespace returns 0", (await c.clear()) === 0);
+
+    await c.set("s", { forever: true }, { ttlMs: Infinity });   // storedExpires = MAX_SAFE arm
+    check("cluster set(ttlMs:Infinity): value round-trips", (await c.get("s")).forever === true);
+
+    await c.update("u", function () { return { value: "kept" }; }, { ttlMs: Infinity });
+    check("cluster update(ttlMs:Infinity): value written", (await c.get("u")) === "kept");
+    await c.close();
+  } finally {
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testInvalidationPubsubBadShape() {
+  var threw = false;
+  try {
+    b.cache.create({ namespace: "bad-ps", invalidationPubsub: { publish: function () {} } });
+  } catch (_e) { threw = true; }
+  check("create() rejects an invalidationPubsub missing subscribe/unsubscribe", threw);
+}
+
+async function testInvalidationPubsubCrossNode() {
+  var ps = b.pubsub.create({ backend: "local" });
+  // Two memory-backed instances sharing one namespace + pubsub simulate two
+  // nodes: a mutation on one mirrors to the other's local store.
+  var nodeA = b.cache.create({ namespace: "xnode", invalidationPubsub: ps });
+  var nodeB = b.cache.create({ namespace: "xnode", invalidationPubsub: ps });
+  try {
+    // del propagation
+    await nodeB.set("k", "v");
+    await nodeA.del("k");
+    await waitUntil(async function () { return (await nodeB.get("k")) === undefined; },
+      { timeoutMs: 4000, label: "cross-node del propagates to nodeB" });
+    check("cross-node del propagates", (await nodeB.get("k")) === undefined);
+
+    // tag propagation
+    await nodeB.set("t1", "v", { tags: ["grp"] });
+    await nodeA.invalidateTag("grp");
+    await waitUntil(async function () { return (await nodeB.get("t1")) === undefined; },
+      { timeoutMs: 4000, label: "cross-node invalidateTag propagates to nodeB" });
+    check("cross-node invalidateTag propagates", (await nodeB.get("t1")) === undefined);
+
+    // clear propagation
+    await nodeB.set("c1", "v");
+    await nodeB.set("c2", "v");
+    await nodeA.clear();
+    await waitUntil(async function () { return (await nodeB.size()) === 0; },
+      { timeoutMs: 4000, label: "cross-node clear propagates to nodeB" });
+    check("cross-node clear propagates", (await nodeB.size()) === 0);
+  } finally {
+    await nodeA.close();   // exercises the pubsub unsubscribe-on-close path
+    await nodeB.close();
+    if (ps.close) await ps.close();
+  }
+}
+
+// ---- Uncovered-branch coverage: cluster sliding TTL / seal / sweep ----
+
+async function testClusterSlidingTtl() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-cache-slide-"));
+  try {
+    await setupTestDb(tmpDir);
+    var nowMs = 2_000_000;
+    var c = b.cache.create({
+      namespace:  "cb-slide",
+      backend:    "cluster",
+      ttlMs:      100,
+      slidingTtl: true,
+      clock:      function () { return nowMs; },
+    });
+    await c.set("k", "v");     // expiresAt = 2_000_100
+    nowMs += 80;               // clock 2_000_080
+    // This read fires the best-effort sliding extension: expiresAt →
+    // 2_000_080 + 100 = 2_000_180 (a fire-and-forget UPDATE).
+    check("cluster sliding: read before original expiry returns", (await c.get("k")) === "v");
+    // Advance PAST the original 100ms expiry but before the extended one.
+    // has() (a non-mutating select honoring expiresAt) becomes true only
+    // once the extension UPDATE has committed — a deterministic signal that
+    // the slide landed, with no lazy-purge / re-slide side effects.
+    nowMs = 2_000_150;
+    await waitUntil(async function () { return (await c.has("k")) === true; },
+      { timeoutMs: 2000, label: "cluster sliding extension committed past original ttl" });
+    check("cluster sliding: read after original ttl still returns (extended)",
+          (await c.get("k")) === "v");
+    await c.close();
+  } finally {
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testClusterSealAndUpdateLifetimes() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-cache-seal-"));
+  try {
+    await setupTestDb(tmpDir);
+    var nowMs = 3_000_000;
+    var c = b.cache.create({
+      namespace: "cb-seal",
+      backend:   "cluster",
+      ttlMs:     b.constants.TIME.minutes(5),
+      clock:     function () { return nowMs; },
+    });
+    // Sealed write + sealed read (marker-prefix encode/decode path).
+    await c.set("s", { secret: "top" }, { seal: true });
+    check("cluster seal: sealed value round-trips", (await c.get("s")).secret === "top");
+
+    // Atomic update over the sealed row: reads+unseals current, reseals new.
+    var r = await c.update("s", function (cur) {
+      return { value: { secret: (cur && cur.secret) + "!" }, seal: true };
+    }, { seal: true });
+    check("cluster seal: update over sealed row reseals",
+          r.updated === true && (await c.get("s")).secret === "top!");
+
+    // update decision that pins the written value's own lifetime.
+    await c.update("ttlkey", function () { return { value: "short", ttlMs: 100 }; });
+    check("cluster update decision.ttlMs: present before expiry", (await c.get("ttlkey")) === "short");
+
+    await c.update("expkey", function () { return { value: "pinned", expiresAt: nowMs + 100 }; });
+    check("cluster update decision.expiresAt: present before expiry", (await c.get("expkey")) === "pinned");
+
+    nowMs += 200;
+    check("cluster update decision.ttlMs: expired after advance",     (await c.get("ttlkey")) === undefined);
+    check("cluster update decision.expiresAt: expired after advance", (await c.get("expkey")) === undefined);
+    await c.close();
+  } finally {
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testClusterBytesReturnsZero() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-cache-bytes-"));
+  try {
+    await setupTestDb(tmpDir);
+    var c = b.cache.create({ namespace: "cb-bytes", backend: "cluster" });
+    // The cluster backend does not track byte accounting → bytes() → 0.
+    check("cluster bytes() returns 0 (no byte accounting)", (await c.bytes()) === 0);
+    await c.close();
+  } finally {
+    await teardownTestDb(tmpDir);
+  }
+}
+
+async function testMemorySweepTimerFires() {
+  // The periodic sweep purges expired entries and emits one
+  // cache.eviction.expired per purged key. Uses the real timer (minimum
+  // 1000ms cadence) with real wall-clock TTL so entries are expired when
+  // the sweep runs; polls the observability signal.
+  var captured = [];
+  var c = b.cache.create({
+    namespace:       "mem-sweep",
+    ttlMs:           100,            // real-clock 100ms — expired well before first sweep
+    sweepIntervalMs: 1000,
+    observability:   { event: function (n, _v, l) { captured.push({ n: n, l: l }); } },
+  });
+  try {
+    await c.set("a", 1);
+    await c.set("b", 2);
+    // Do NOT read — let the sweep timer, not lazy purge, do the eviction.
+    await waitUntil(function () {
+      return captured.filter(function (e) { return e.n === "cache.eviction.expired"; }).length >= 2;
+    }, { timeoutMs: 5000, label: "memory sweep timer purges expired entries" });
+    check("memory sweep timer emits cache.eviction.expired for purged entries",
+          captured.filter(function (e) { return e.n === "cache.eviction.expired"; }).length >= 2);
+  } finally {
+    await c.close();
+  }
+}
+
+async function testClusterSweepTimerFires() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-cache-sweep-"));
+  try {
+    await setupTestDb(tmpDir);
+    var c = b.cache.create({
+      namespace:       "cb-sweep",
+      backend:         "cluster",
+      ttlMs:           100,          // real-clock 100ms
+      sweepIntervalMs: 1000,
+    });
+    // Tag rows are read without an expiry filter, so getTags keeps returning
+    // the tag until the sweep physically deletes the junction row — a clean
+    // signal that the sweep DELETE (not lazy purge) ran.
+    await c.set("k", "v", { tags: ["swept"] });
+    check("cluster sweep: tag present before sweep", (await c.getTags("k")).length === 1);
+    await waitUntil(async function () { return (await c.getTags("k")).length === 0; },
+      { timeoutMs: 5000, label: "cluster sweep timer deletes expired rows + tags" });
+    check("cluster sweep timer deletes expired rows + their tag rows",
+          (await c.getTags("k")).length === 0);
+    await c.close();
+  } finally {
+    await teardownTestDb(tmpDir);
+  }
+}
+
 async function run() {
   await testSurface();
   await testValidation();
@@ -919,6 +1494,34 @@ async function run() {
   await testTagsValidateFormat();
   await testInvalidateTagAuditEmit();
   await testInvalidateTagOnCluster();
+
+  // Uncovered-branch coverage sweep
+  await testInfinityCapsAccepted();
+  await testInvalidBackendString();
+  await testDefaultSizeOfVariants();
+  await testHasExpiredEvicts();
+  await testBackendErrorAllMethods();
+  await testUpdateMutatorThrows();
+  await testCustomBackendOptionalFallbacks();
+  await testSealRejectedOnNonCluster();
+  await testUpdateUnsupportedAndBadMutator();
+  await testInvalidateTagBadArg();
+  await testUpdateMemoryExpiresAtDecision();
+  await testObservabilitySinkThrowsSwallowed();
+  await testSwrInfinityTtl();
+  await testSwrBackgroundRefreshFailure();
+  await testSwrWriteFailure();
+  await testRedisBackendConstructs();
+  await testWrapSetFailureNonSwr();
+  await testMemoryInfinityWriteArms();
+  await testClusterInfinityAndEmptyClear();
+  await testInvalidationPubsubBadShape();
+  await testInvalidationPubsubCrossNode();
+  await testClusterSlidingTtl();
+  await testClusterSealAndUpdateLifetimes();
+  await testClusterBytesReturnsZero();
+  await testMemorySweepTimerFires();
+  await testClusterSweepTimerFires();
 }
 
 module.exports = { run: run };