@driftengine/texture 4.0.0

package/src/residency/pageCache.ts

@@ -0,0 +1,233 @@
+/**
+ * Decoded pages, and the switch that decides when the decoding happens.
+ *
+ * **This carries a mode because the spec's §9 names the risk rather than hoping about it.** If
+ * per-sample neural decode turns out too slow in the general case, the fallback is to decode once
+ * when a tile becomes resident and sample it as an ordinary texture thereafter — which loses
+ * procedural and per-sample parameterisation for the affected materials and keeps the compression,
+ * the joint channels and the streaming. Building the switch now costs a field and a branch.
+ * Retrofitting it into a pipeline that assumes per-sample decode everywhere costs a great deal,
+ * and would be attempted on the day somebody discovered the frame time, which is the worst day.
+ *
+ * **A page acquired this frame is never evicted.** The same rule `table.ts` exists to enforce, one
+ * level down and for the same reason: reclaiming a page the current frame is sampling produces a
+ * frame drawn against bytes somebody else is writing, which is a corruption rather than a stall
+ * and does not look like a streaming problem at all. A cache with nothing else to give refuses —
+ * `acquirePage` returns `-1` — because a wrong page is worse than no page.
+ *
+ * **What was evicted is reported, and the plan's signature had nowhere to say it.** A residency
+ * table that still calls a tile resident after its page has been reused points at a slot another
+ * tile now owns. The eviction has to reach the table, so it is drained rather than dropped.
+ */
+
+/** Where the decode happens. See the header for which risk the second one is the answer to. */
+export type DecodeMode = 'per-sample' | 'on-residency';
+
+/** How a page's bytes are produced. Supplied by the caller: a cache cannot know a format. */
+export type PageDecode = (hash: string, into: Uint8Array) => void;
+
+export interface PageCacheOptions {
+  readonly mode?: DecodeMode;
+  /**
+   * What fills a page in `on-residency` mode.
+   *
+   * Optional, because a cache in `per-sample` mode never decodes and a test of the eviction policy
+   * has nothing to decode. Absent in `on-residency` mode, a page is acquired undecoded and
+   * `pageDecoded` says so rather than the cache pretending.
+   */
+  readonly decode?: PageDecode;
+}
+
+export interface PageCache {
+  readonly pages: number;
+  readonly pageBytes: number;
+  /** Every page, back to back. Slot `n` is `[n * pageBytes, (n + 1) * pageBytes)`. */
+  readonly bytes: Uint8Array;
+  /** Which hash holds each slot, or `''` where it is free. */
+  readonly holder: string[];
+  /** Whether each slot's bytes have been decoded into. */
+  readonly decoded: boolean[];
+  slotOf: Map<string, number>;
+  /** Monotonic, standing in for time, so eviction needs no clock. As `table.ts` does. */
+  touchedAt: Map<string, number>;
+  clock: number;
+  /** The clock at the start of the frame. Nothing touched after it may be evicted. */
+  frameStart: number;
+  mode: DecodeMode;
+  decode: PageDecode | null;
+  /** Hashes whose pages have been taken since the caller last drained this. */
+  evicted: string[];
+}
+
+export function createPageCache(
+  pages: number,
+  pageBytes: number,
+  options: PageCacheOptions = {},
+): PageCache {
+  const count = Math.max(1, Math.floor(pages));
+  const size = Math.max(1, Math.floor(pageBytes));
+  return {
+    pages: count,
+    pageBytes: size,
+    bytes: new Uint8Array(count * size),
+    holder: new Array<string>(count).fill(''),
+    decoded: new Array<boolean>(count).fill(false),
+    slotOf: new Map<string, number>(),
+    touchedAt: new Map<string, number>(),
+    clock: 0,
+    frameStart: 0,
+    mode: options.mode ?? 'per-sample',
+    decode: options.decode ?? null,
+    evicted: [],
+  };
+}
+
+/**
+ * Say a new frame has begun, so everything acquired from here is protected from eviction.
+ *
+ * A caller that never calls this gets a cache that protects everything and fills up, which is a
+ * visible stall rather than a silent corruption — the right way round for a mistake to fail.
+ */
+export function beginCacheFrame(cache: PageCache): void {
+  cache.frameStart = cache.clock;
+}
+
+function touch(cache: PageCache, hash: string): void {
+  cache.clock += 1;
+  cache.touchedAt.set(hash, cache.clock);
+}
+
+/**
+ * The slot holding this tile's page, acquiring one if it is not held. `-1` where none can be given.
+ *
+ * Acquiring a hash that is already here returns the same slot and takes no page from anybody: the
+ * commonest call by far, and the one that must not evict.
+ */
+export function acquirePage(cache: PageCache, hash: string): number {
+  const held = cache.slotOf.get(hash);
+  if (held !== undefined) {
+    touch(cache, hash);
+    return held;
+  }
+
+  let slot = cache.holder.indexOf('');
+  if (slot < 0) {
+    const victim = evictable(cache);
+    if (victim === null) return -1;
+    slot = cache.slotOf.get(victim) as number;
+    release(cache, victim, slot);
+    cache.evicted.push(victim);
+  }
+
+  cache.holder[slot] = hash;
+  cache.slotOf.set(hash, slot);
+  /* No `decoded[slot] = false` here: `release` owns that, and every slot reaching this point came
+     either from `release` or from never having been used. A second reset changed nothing, which a
+     perturbation showed by failing no test. */
+  cache.bytes.fill(0, slot * cache.pageBytes, (slot + 1) * cache.pageBytes);
+  touch(cache, hash);
+
+  /* The whole of the mode switch: in one, the bytes are produced now; in the other, at sample
+     time by whoever samples, and this cache holds the compressed page unchanged. */
+  if (cache.mode === 'on-residency') ensurePageDecoded(cache, hash);
+  return slot;
+}
+
+/** The least recently used page that this frame has not touched, or null. */
+function evictable(cache: PageCache): string | null {
+  let worst: string | null = null;
+  let at = Infinity;
+  for (const hash of cache.slotOf.keys()) {
+    const when = cache.touchedAt.get(hash) ?? 0;
+    if (when > cache.frameStart) continue;
+    if (when >= at) continue;
+    at = when;
+    worst = hash;
+  }
+  return worst;
+}
+
+/**
+ * Take a page back, leaving the slot free and claimed by nobody.
+ *
+ * **`touchedAt` is deleted as well**, which is not tidiness: without it the map grows by one entry
+ * per tile the cache has ever seen, so a three-page cache that streamed a level holds three pages
+ * and thousands of timestamps. There is a test that counts them.
+ */
+function release(cache: PageCache, hash: string, slot: number): void {
+  cache.holder[slot] = '';
+  cache.decoded[slot] = false;
+  cache.slotOf.delete(hash);
+  cache.touchedAt.delete(hash);
+}
+
+/** Give a page back. Its slot is free for the next acquisition, and its bytes are not kept. */
+export function releasePage(cache: PageCache, hash: string): void {
+  const slot = cache.slotOf.get(hash);
+  if (slot === undefined) return;
+  release(cache, hash, slot);
+}
+
+export function pageSlot(cache: PageCache, hash: string): number {
+  return cache.slotOf.get(hash) ?? -1;
+}
+
+export function pageDecoded(cache: PageCache, hash: string): boolean {
+  const slot = cache.slotOf.get(hash);
+  return slot === undefined ? false : (cache.decoded[slot] ?? false);
+}
+
+/**
+ * Decode a held page if the mode says the cache owns that, and it has not been done.
+ *
+ * Returns whether the page's bytes are now the decoded ones. `false` in `per-sample` mode is the
+ * ordinary answer rather than a failure: the bytes are the compressed page and whoever samples
+ * decodes them.
+ */
+export function ensurePageDecoded(cache: PageCache, hash: string): boolean {
+  if (cache.mode !== 'on-residency') return false;
+  const slot = cache.slotOf.get(hash);
+  if (slot === undefined) return false;
+  if (cache.decoded[slot] === true) return true;
+  if (cache.decode === null) return false;
+  cache.decode(hash, cache.bytes.subarray(slot * cache.pageBytes, (slot + 1) * cache.pageBytes));
+  cache.decoded[slot] = true;
+  return true;
+}
+
+export function decodeMode(cache: PageCache): DecodeMode {
+  return cache.mode;
+}
+
+/**
+ * Change where the decode happens, invalidating every page that was decoded under the old rule.
+ *
+ * **Invalidating rather than converting.** A page decoded per-sample and one decoded on residency
+ * hold different bytes, so keeping them and changing the flag serves a sampler the wrong ones —
+ * silently, and only for the pages that happened to be resident when somebody flipped the switch.
+ * The pages stay held; what is lost is the claim that their contents are current.
+ */
+export function setDecodeMode(cache: PageCache, mode: DecodeMode): void {
+  if (mode === cache.mode) return;
+  cache.mode = mode;
+  cache.decoded.fill(false);
+}
+
+/** How many pages are held. What a profiler panel shows beside the resident tile count. */
+export function occupiedPages(cache: PageCache): number {
+  return cache.slotOf.size;
+}
+
+/**
+ * Drain the hashes whose pages have been taken, into `out`. Returns how many.
+ *
+ * A caller that never drains this leaks a string per eviction, which is why it is a drain rather
+ * than a log: the list is a message to the residency table, and a message nobody reads is a bug in
+ * the caller that should grow rather than hide.
+ */
+export function takeEvicted(cache: PageCache, out: string[]): number {
+  out.length = 0;
+  for (const hash of cache.evicted) out.push(hash);
+  cache.evicted.length = 0;
+  return out.length;
+}

package/src/residency/predict.ts

@@ -0,0 +1,74 @@
+/**
+ * Running the world forward to see what it will need, then putting it back.
+ *
+ * **This is the part no competitor can copy, and the reason is not the code.** The state of the art
+ * in texture streaming is reactive: the documentation for the most widely deployed implementation
+ * says so in as many words — streaming is *reactive by nature*, because the processor cannot know a
+ * tile is needed until after a frame has already needed it. Hence pop-in, and hence the further
+ * limitation that passes which write no feedback can sample tiles they are unable to request.
+ *
+ * That is true only of an engine that cannot run its simulation forward and put it back. This one
+ * can, and already does every frame for the netcode. So residency is decided by looking at where
+ * the camera *will* be:
+ *
+ * ```text
+ * every engine                    DriftEngine
+ * ────────────                    ───────────
+ * render frame N                  save the simulation
+ * read the feedback buffer        advance it N frames, deterministic, no rendering
+ *   ↓ two to three frames late    sample which tiles those views want
+ * request the tiles               restore
+ * pop-in                          prefetch → resident before it is ever visible
+ * ```
+ *
+ * **The simulation is taken as a handle the caller supplies**, in the save/restore shape
+ * `@driftengine/network`'s `Snapshotter` already uses, for two reasons: this package must not
+ * import a simulation, and a consumer with their own loop has to be able to supply their own.
+ *
+ * **A misprediction costs a wasted fetch and nothing else.** The tile arrives late, exactly as it
+ * would in a reactive engine — so the floor of this mechanism is everyone else's ceiling.
+ */
+
+/**
+ * What prediction needs from a simulation.
+ *
+ * Save and restore rather than a snapshot value, matching `Snapshotter` in the network package:
+ * the buffer is the handle's own and is reused, so predicting allocates nothing.
+ */
+export interface SimulationHandle {
+  /** Capture the current state into the handle's own storage. */
+  save(): void;
+  /** Put back what `save` captured. */
+  restore(): void;
+  /** Advance one fixed step. Deterministic, and the same step the simulation really runs. */
+  advance(dt: number): void;
+  /** Write the current view matrix into `out`, sixteen floats. */
+  viewAt(out: Float32Array): void;
+}
+
+/**
+ * Fill `out` with one view matrix per predicted frame, and leave the simulation exactly as found.
+ *
+ * Returns how many views were written — fewer than `frames` when `out` cannot hold them all.
+ *
+ * **Saved once and restored once**, however many frames are predicted: the intermediate states are
+ * not wanted, only the views they imply.
+ */
+export function predictViews(
+  sim: SimulationHandle,
+  frames: number,
+  dt: number,
+  out: Float32Array,
+): number {
+  const capacity = Math.floor(out.length / 16);
+  const wanted = Math.min(frames, capacity);
+  if (wanted <= 0) return 0;
+
+  sim.save();
+  for (let i = 0; i < wanted; i += 1) {
+    sim.advance(dt);
+    sim.viewAt(out.subarray(i * 16, i * 16 + 16));
+  }
+  sim.restore();
+  return wanted;
+}

package/src/residency/predictor.ts

@@ -0,0 +1,62 @@
+/**
+ * Prediction, generic over what is being streamed.
+ *
+ * **Written generic now rather than generalised later, and the reason is a contract rather than
+ * tidiness.** Wave 4B streams world cells by exactly this mechanism. Writing the tile case against
+ * a concrete type would mean a second speculative-advance implementation there — and therefore a
+ * second place for "put the simulation back exactly" to be got wrong, in a subsystem where being
+ * wrong means the world runs at double speed only when streaming is enabled.
+ *
+ * One prediction, two consumers.
+ */
+import { predictViews } from './predict.ts';
+import type { SimulationHandle } from './predict.ts';
+
+export interface Predictor<T> {
+  /** What this view needs, most important first. Fills `out` and returns how many. */
+  needs(view: Float32Array, out: T[], budget: number): number;
+  /** Whether this item is already here. */
+  resident(item: T): boolean;
+  /** Ask for it. Lower priority is sooner. */
+  request(item: T, priority: number): void;
+}
+
+const VIEWS = new Float32Array(16 * 32);
+const WANTED: unknown[] = [];
+
+/**
+ * Advance the simulation, ask the predictor what each predicted view needs, and put it back.
+ *
+ * Returns how many requests were made. `budget` bounds the total across every predicted frame
+ * rather than per frame, so a near frame cannot be starved by a distant one filling the queue.
+ */
+export function runPrediction<T>(
+  sim: SimulationHandle,
+  predictor: Predictor<T>,
+  frames: number,
+  dt: number,
+  budget: number,
+): number {
+  const horizon = Math.min(frames, Math.floor(VIEWS.length / 16));
+  const count = predictViews(sim, horizon, dt, VIEWS);
+
+  let requested = 0;
+  const out = WANTED as T[];
+  for (let frame = 0; frame < count && requested < budget; frame += 1) {
+    const view = VIEWS.subarray(frame * 16, frame * 16 + 16);
+    const wanted = predictor.needs(view, out, budget - requested);
+    for (let i = 0; i < wanted && requested < budget; i += 1) {
+      const item = out[i] as T;
+      if (predictor.resident(item)) continue;
+      /*
+       * Priority is how far ahead the frame is, so nearer frames come first — and within a frame,
+       * the place the predictor named the item in, as a fraction that never reaches the next
+       * frame. A frame's priority alone would tie its items, and a queue breaks a tie however it
+       * likes; a budget that cut the frame short would then keep an arbitrary part of it.
+       */
+      predictor.request(item, frame + i / wanted);
+      requested += 1;
+    }
+  }
+  return requested;
+}

package/src/residency/queue.ts

@@ -0,0 +1,78 @@
+/**
+ * What to fetch next, ordered by how soon it will be needed.
+ *
+ * **That ordering is not available to a reactive system at all.** Everything a feedback buffer
+ * reports is already needed; there is nothing to rank. Prediction produces a horizon, so a tile
+ * wanted in one frame can outrank one wanted in eight — which is the difference between spending a
+ * limited byte budget well and spending it arbitrarily.
+ *
+ * **A full queue drops its worst entry rather than refusing the best one.** Refusing on arrival
+ * would discard exactly the tiles a late prediction found most urgent.
+ */
+export interface PrefetchQueue {
+  /** Priority per hash. Lower is sooner, so it sorts naturally. */
+  priority: Map<string, number>;
+  capacity: number;
+}
+
+export function createPrefetchQueue(capacity: number): PrefetchQueue {
+  return { priority: new Map(), capacity };
+}
+
+export function enqueue(queue: PrefetchQueue, hash: string, priority: number): void {
+  const existing = queue.priority.get(hash);
+  /* One entry per tile, keeping the better claim on it. */
+  if (existing !== undefined) {
+    if (priority < existing) queue.priority.set(hash, priority);
+    return;
+  }
+  queue.priority.set(hash, priority);
+  if (queue.priority.size <= queue.capacity) return;
+
+  let worst = '';
+  let worstPriority = -Infinity;
+  for (const [key, value] of queue.priority) {
+    if (value > worstPriority) {
+      worstPriority = value;
+      worst = key;
+    }
+  }
+  queue.priority.delete(worst);
+}
+
+export function queueSize(queue: PrefetchQueue): number {
+  return queue.priority.size;
+}
+
+/**
+ * Take the next batch, soonest first, within a byte budget.
+ *
+ * **Residency is checked here rather than at enqueue**, because it may have changed in between —
+ * a tile requested eight frames ahead may well have arrived by the time its turn comes.
+ */
+export function takeBatch(
+  queue: PrefetchQueue,
+  isResident: (hash: string) => boolean,
+  bytesBudget: number,
+  tileBytes: number,
+  out: string[],
+): number {
+  const ordered = [...queue.priority.entries()].sort(
+    (a, b) => a[1] - b[1] || (a[0] < b[0] ? -1 : 1),
+  );
+  let spent = 0;
+  let written = 0;
+  for (const [hash] of ordered) {
+    if (isResident(hash)) {
+      queue.priority.delete(hash);
+      continue;
+    }
+    if (spent + tileBytes > bytesBudget) break;
+    out[written] = hash;
+    written += 1;
+    spent += tileBytes;
+    queue.priority.delete(hash);
+  }
+  out.length = written;
+  return written;
+}

package/src/residency/stream.ts

@@ -0,0 +1,194 @@
+/**
+ * Getting the bytes, and giving up on the ones that are not coming.
+ *
+ * **A tile that will not arrive stops being waited for.** That is the whole of this file's
+ * difficulty. A fetch that resolves with nothing — a tile the container does not hold, a name from
+ * a stale index, a range the server refused — leaves the tile marked requested and its slot
+ * occupied forever if nobody handles it. A handful of those and the in-flight budget is gone, so
+ * every subsequent fetch is refused and **streaming stops entirely**, with no error anywhere: the
+ * world simply never finishes loading, and the last thing that happened was unrelated.
+ *
+ * So a missing tile is remembered as missing. Not evicted-and-forgotten, which asks for it again on
+ * the next pump and turns one absent tile into a fetch every frame; and not left requested, which
+ * is the leak. `forgetMissing` exists because "missing" is a fact about a container and a caller
+ * that mounts a different one is entitled to ask again.
+ *
+ * **The source is the caller's.** What a tile's bytes are behind — a `.drft` container, a range
+ * request, a file — is not this package's business, and a streamer that knew would be a streamer
+ * every host had to agree with. It is one method returning a promise of bytes or nothing.
+ *
+ * **Nothing here awaits.** `pumpStreamer` starts work and returns; a source that never resolves
+ * costs an in-flight slot and nothing else. A streamer that awaited its own fetches would stall the
+ * frame that called it, which is the failure streaming exists to avoid.
+ */
+import {
+  TILE_ABSENT,
+  TILE_REQUESTED,
+  evict,
+  markRequested,
+  markResident,
+  tileState,
+  type ResidencyTable,
+} from './table.ts';
+import { acquirePage, takeEvicted, type PageCache } from './pageCache.ts';
+
+/** Where a tile's bytes come from. Resolving `null` means the source does not have it. */
+export interface TileSource {
+  fetch(hash: string): Promise<Uint8Array | null>;
+}
+
+export interface StreamerOptions {
+  /**
+   * How many fetches may be outstanding at once.
+   *
+   * A bound rather than none, because an unbounded streamer asked for a thousand tiles opens a
+   * thousand connections and finishes none of them sooner.
+   */
+  readonly maxInFlight?: number;
+}
+
+export interface Streamer {
+  readonly source: TileSource;
+  readonly table: ResidencyTable;
+  readonly cache: PageCache;
+  readonly maxInFlight: number;
+  /** Tiles asked for and not yet answered. */
+  readonly inFlight: Set<string>;
+  /** Tiles the source answered `null` for. Not asked for again until forgotten. */
+  readonly missing: Set<string>;
+  /** Fetches that landed after their tile had been evicted. Counted, not silently dropped. */
+  stale: number;
+  /** Fetches that landed with no page free to put them in. The tile stays absent and is retried. */
+  deferred: number;
+  /** Fetches whose bytes were larger than a page. A container and a cache disagreeing. */
+  oversize: number;
+}
+
+export function createStreamer(
+  source: TileSource,
+  table: ResidencyTable,
+  cache: PageCache,
+  options: StreamerOptions = {},
+): Streamer {
+  return {
+    source,
+    table,
+    cache,
+    maxInFlight: Math.max(1, Math.floor(options.maxInFlight ?? 8)),
+    inFlight: new Set<string>(),
+    missing: new Set<string>(),
+    stale: 0,
+    deferred: 0,
+    oversize: 0,
+  };
+}
+
+export function streamerInFlight(streamer: Streamer): number {
+  return streamer.inFlight.size;
+}
+
+/** Stop calling a tile missing, so the next pump asks for it again. */
+export function forgetMissing(streamer: Streamer, hash: string): void {
+  streamer.missing.delete(hash);
+}
+
+export function clearMissing(streamer: Streamer): void {
+  streamer.missing.clear();
+}
+
+/**
+ * Ask for the first `count` tiles of `batch` that are worth asking for. Returns how many were sent.
+ *
+ * Skips anything already resident, already in flight, or known missing — which is what makes
+ * calling this every frame with the same batch correct rather than a fetch storm.
+ */
+export function pumpStreamer(streamer: Streamer, batch: readonly string[], count: number): number {
+  let sent = 0;
+  /* A bound on the loop rather than a correctness check — the `undefined` guard below is what
+     makes a short batch behave, and a perturbation removing this one fails no test. It stays
+     because without it `pumpStreamer(s, [], 1e9)` spins a billion times to do nothing. */
+  const wanted = Math.min(count, batch.length);
+  for (let at = 0; at < wanted; at += 1) {
+    if (streamer.inFlight.size >= streamer.maxInFlight) break;
+    const hash = batch[at];
+    if (hash === undefined) continue;
+    if (streamer.missing.has(hash)) continue;
+    /* Already asked for. Usually the table says so too, but not after an eviction while the fetch
+       was still out: the tile is absent again and a second fetch of bytes already on their way is
+       exactly what a content-addressed store makes pointless. */
+    if (streamer.inFlight.has(hash)) continue;
+    if (tileState(streamer.table, hash) !== TILE_ABSENT) continue;
+
+    markRequested(streamer.table, hash);
+    streamer.inFlight.add(hash);
+    sent += 1;
+    /*
+     * Not awaited: this returns to the frame that called it. A rejection is treated exactly as a
+     * missing tile, because from here they are the same fact — the bytes are not coming — and a
+     * streamer that let one through would be the leak this file is about, arriving by the one path
+     * nobody writes a test for.
+     */
+    void streamer.source
+      .fetch(hash)
+      .then((bytes) => {
+        land(streamer, hash, bytes);
+      })
+      .catch(() => {
+        land(streamer, hash, null);
+      });
+  }
+  return sent;
+}
+
+function land(streamer: Streamer, hash: string, bytes: Uint8Array | null): void {
+  streamer.inFlight.delete(hash);
+
+  /*
+   * Evicted while in flight. Its slot belongs to somebody else now, so these bytes go nowhere —
+   * and the tile is left absent rather than resurrected, because whatever evicted it decided it
+   * was not wanted and this arriving late does not change that.
+   */
+  if (tileState(streamer.table, hash) !== TILE_REQUESTED) {
+    streamer.stale += 1;
+    return;
+  }
+
+  if (bytes === null) {
+    evict(streamer.table, hash);
+    streamer.missing.add(hash);
+    return;
+  }
+
+  if (bytes.length > streamer.cache.pageBytes) {
+    /* A truncation here would be a tile that decodes to something nobody authored, found weeks
+       later as a corrupt-looking texture. Refused, counted, and left absent. */
+    streamer.oversize += 1;
+    evict(streamer.table, hash);
+    streamer.missing.add(hash);
+    return;
+  }
+
+  const slot = acquirePage(streamer.cache, hash);
+  if (slot < 0) {
+    /* Every page is in use by this frame. The tile stays absent, so the next pump asks again. */
+    streamer.deferred += 1;
+    evict(streamer.table, hash);
+    return;
+  }
+  drainEvictions(streamer);
+
+  streamer.cache.bytes.set(bytes, slot * streamer.cache.pageBytes);
+  markResident(streamer.table, hash, slot);
+}
+
+/**
+ * Tell the table about pages the cache took, so nothing is called resident in a slot it lost.
+ *
+ * The one piece of wiring between the two structures, and the reason `takeEvicted` exists: a table
+ * still pointing at a reused slot hands a frame another tile's bytes.
+ */
+function drainEvictions(streamer: Streamer): void {
+  const taken: string[] = [];
+  takeEvicted(streamer.cache, taken);
+  for (const hash of taken) evict(streamer.table, hash);
+}