waveform-analysis 0.1.47 → 0.1.50

package/src/core/workerSampling/repositoryDataset.ts

@@ -0,0 +1,194 @@
+import type { WaveformPoint } from '@/types'
+import type { WorkerSamplingDataset } from '../waveformPointSource'
+import type { WasmDatasetSamplingBackend } from '../wasmSampling'
+import { MultiResolutionSamplingIndex } from './multiresolution'
+import type { WorkerSamplingBackend, WorkerSamplingDatasetMetrics } from './protocol'
+import { copyFinitePoints, metricsFor, metricsForValues } from './repositorySupport'
+
+export interface StoredDataset {
+  x?: Float64Array
+  y: Float64Array
+  sampleStartTime?: number
+  sampleRate?: number
+  sampleSourceIndexes?: Uint32Array
+  points?: WaveformPoint[]
+  revision: number
+  metrics: WorkerSamplingDatasetMetrics
+  index?: MultiResolutionSamplingIndex
+  wasmDatasetHandle?: number
+  wasmIndexBytes?: number
+}
+
+export function datasetLength(dataset: StoredDataset | undefined) {
+  return dataset?.y.length ?? 0
+}
+
+export function datasetXAt(dataset: StoredDataset, index: number) {
+  if (dataset.x) return dataset.x[index]!
+  return (
+    dataset.sampleStartTime! + (dataset.sampleSourceIndexes?.[index] ?? index) / dataset.sampleRate!
+  )
+}
+
+export function datasetVisibleRange(dataset: StoredDataset, domain: [number, number]) {
+  const lowerBound = (value: number, inclusive: boolean) => {
+    let start = 0
+    let end = datasetLength(dataset)
+    while (start < end) {
+      const middle = start + Math.floor((end - start) / 2)
+      if (inclusive ? datasetXAt(dataset, middle) <= value : datasetXAt(dataset, middle) < value) {
+        start = middle + 1
+      } else end = middle
+    }
+    return start
+  }
+  const startX = Math.min(domain[0], domain[1])
+  const endX = Math.max(domain[0], domain[1])
+  return { start: lowerBound(startX, false), end: lowerBound(endX, true) }
+}
+
+export function datasetXRange(dataset: StoredDataset, start: number, end: number) {
+  if (dataset.x) return dataset.x.subarray(start, end)
+  return Float64Array.from({ length: end - start }, (_, offset) =>
+    datasetXAt(dataset, start + offset),
+  )
+}
+
+export function isWasmDatasetBackend(
+  backend: WorkerSamplingBackend | undefined,
+): backend is WasmDatasetSamplingBackend {
+  return (
+    backend?.kind === 'wasm' &&
+    'registerDataset' in backend &&
+    'disposeDataset' in backend &&
+    'disposeAllDatasets' in backend &&
+    'datasetIndexBytes' in backend &&
+    'registerSamples' in backend &&
+    'sampleDataset' in backend
+  )
+}
+
+function copyFiniteNumericValues(sourceX: Float64Array, sourceY: Float32Array | Float64Array) {
+  const indexes: number[] = []
+  const length = Math.min(sourceX.length, sourceY.length)
+  for (let index = 0; index < length; index += 1) {
+    if (Number.isFinite(sourceX[index]) && Number.isFinite(sourceY[index])) indexes.push(index)
+  }
+  indexes.sort((left, right) => sourceX[left]! - sourceX[right]! || left - right)
+  return {
+    x: Float64Array.from(indexes, (index) => sourceX[index]!),
+    y: Float64Array.from(indexes, (index) => sourceY[index]!),
+  }
+}
+
+export function createStoredDataset(
+  input: readonly WaveformPoint[] | undefined,
+  numeric: WorkerSamplingDataset | undefined,
+  revision: number,
+  indexMaxBytes: number | undefined,
+): StoredDataset {
+  if (numeric?.kind === 'typed') {
+    const normalized = copyFiniteNumericValues(numeric.x, numeric.y)
+    return {
+      x: normalized.x,
+      y: normalized.y,
+      revision,
+      metrics: metricsForValues(
+        normalized.x,
+        normalized.y,
+        Math.max(numeric.x.length, numeric.y.length),
+      ),
+    }
+  }
+  if (numeric?.kind === 'samples') {
+    const validMetadata =
+      Number.isFinite(numeric.sampleRate) &&
+      numeric.sampleRate > 0 &&
+      Number.isFinite(numeric.startTime) &&
+      (!numeric.sourceIndexes || numeric.sourceIndexes.length === numeric.values.length)
+    if (!validMetadata) {
+      return {
+        y: new Float64Array(),
+        sampleStartTime: 0,
+        sampleRate: 1,
+        revision,
+        metrics: {
+          inputPointCount: numeric.values.length,
+          validPointCount: 0,
+          xDomain: null,
+          yDomain: null,
+        },
+      }
+    }
+    const indexes = Array.from({ length: numeric.values.length }, (_, index) => index).filter(
+      (index) => Number.isFinite(numeric.values[index]),
+    )
+    const sourceIndexAt = (index: number) => numeric.sourceIndexes?.[index] ?? index
+    indexes.sort((left, right) => sourceIndexAt(left) - sourceIndexAt(right) || left - right)
+    const y = Float64Array.from(indexes, (index) => numeric.values[index]!)
+    const sourceIndexes = Uint32Array.from(indexes, sourceIndexAt)
+    const xAt = (index: number) => numeric.startTime + sourceIndexes[index]! / numeric.sampleRate
+    let yMinimum = Number.POSITIVE_INFINITY
+    let yMaximum = Number.NEGATIVE_INFINITY
+    for (const value of y) {
+      yMinimum = Math.min(yMinimum, value)
+      yMaximum = Math.max(yMaximum, value)
+    }
+    return {
+      y,
+      sampleStartTime: numeric.startTime,
+      sampleRate: numeric.sampleRate,
+      sampleSourceIndexes:
+        sourceIndexes.length === numeric.values.length &&
+        sourceIndexes.every((value, index) => value === index)
+          ? undefined
+          : sourceIndexes,
+      revision,
+      metrics: {
+        inputPointCount: numeric.values.length,
+        validPointCount: y.length,
+        xDomain: y.length ? [xAt(0), xAt(y.length - 1)] : null,
+        yDomain: y.length ? [yMinimum, yMaximum] : null,
+      },
+    }
+  }
+  const copied = copyFinitePoints(input ?? numeric?.points ?? [])
+  const x = Float64Array.from(copied, (point) => point.x)
+  const y = Float64Array.from(copied, (point) => point.y)
+  return {
+    x,
+    y,
+    points: copied,
+    revision,
+    metrics: metricsFor(copied, input?.length ?? numeric?.points.length ?? 0),
+    index: new MultiResolutionSamplingIndex(copied, { maxBytes: indexMaxBytes }),
+  }
+}
+
+export function registerWasmDataset(
+  backend: WorkerSamplingBackend | undefined,
+  dataset: StoredDataset,
+  indexMaxBytes: number | undefined,
+) {
+  if (!isWasmDatasetBackend(backend) || dataset.wasmDatasetHandle !== undefined) return
+  dataset.wasmDatasetHandle = dataset.x
+    ? backend.registerDataset(dataset.x, dataset.y, indexMaxBytes)
+    : backend.registerSamples(
+        dataset.y,
+        dataset.sampleSourceIndexes,
+        dataset.sampleStartTime!,
+        dataset.sampleRate!,
+        indexMaxBytes,
+      )
+  dataset.wasmIndexBytes = backend.datasetIndexBytes(dataset.wasmDatasetHandle)
+}
+
+export function disposeDatasetIndexes(
+  backend: WorkerSamplingBackend | undefined,
+  dataset: StoredDataset,
+) {
+  dataset.index?.dispose()
+  if (dataset.wasmDatasetHandle !== undefined && isWasmDatasetBackend(backend)) {
+    backend.disposeDataset(dataset.wasmDatasetHandle)
+  }
+}

package/src/core/workerSampling/repositorySupport.ts

@@ -0,0 +1,225 @@
+import { bisector } from 'd3'
+
+import type { WaveformPoint } from '@/types'
+import {
+  DEFAULT_WORKER_SAMPLING_AUTO_THRESHOLD,
+  DEFAULT_WORKER_SAMPLING_MAX_POINTS_PER_PIXEL,
+  type WorkerSamplingBackendKind,
+  type WorkerSamplingDatasetMetrics,
+  type WorkerSamplingDiagnostics,
+  type WorkerSamplingOutput,
+  type WorkerSamplingSeriesRequest,
+  type WorkerSamplingStatus,
+} from './protocol'
+
+const pointBisector = bisector<WaveformPoint, number>((point) => point.x)
+
+export function copyFinitePoints(points: readonly WaveformPoint[]) {
+  const copied: WaveformPoint[] = []
+  let sorted = true
+  let previousX = Number.NEGATIVE_INFINITY
+  for (const point of points) {
+    if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) continue
+    if (point.x < previousX) sorted = false
+    previousX = point.x
+    copied.push({
+      x: point.x,
+      y: point.y,
+      ...(Number.isFinite(point.error) ? { error: point.error } : {}),
+      ...(Number.isFinite(point.lowerError) ? { lowerError: point.lowerError } : {}),
+      ...(Number.isFinite(point.upperError) ? { upperError: point.upperError } : {}),
+    })
+  }
+  if (!sorted) copied.sort((left, right) => left.x - right.x)
+  return copied
+}
+
+export function metricsFor(
+  points: readonly WaveformPoint[],
+  inputPointCount: number,
+): WorkerSamplingDatasetMetrics {
+  let xMinimum = Number.POSITIVE_INFINITY
+  let xMaximum = Number.NEGATIVE_INFINITY
+  let yMinimum = Number.POSITIVE_INFINITY
+  let yMaximum = Number.NEGATIVE_INFINITY
+  for (const point of points) {
+    xMinimum = Math.min(xMinimum, point.x)
+    xMaximum = Math.max(xMaximum, point.x)
+    yMinimum = Math.min(yMinimum, point.y)
+    yMaximum = Math.max(yMaximum, point.y)
+  }
+  return {
+    inputPointCount,
+    validPointCount: points.length,
+    xDomain: points.length ? [xMinimum, xMaximum] : null,
+    yDomain: points.length ? [yMinimum, yMaximum] : null,
+  }
+}
+
+export function metricsForValues(
+  x: Float64Array,
+  y: Float32Array | Float64Array,
+  inputPointCount = x.length,
+): WorkerSamplingDatasetMetrics {
+  let xMinimum = Number.POSITIVE_INFINITY
+  let xMaximum = Number.NEGATIVE_INFINITY
+  let yMinimum = Number.POSITIVE_INFINITY
+  let yMaximum = Number.NEGATIVE_INFINITY
+  for (let index = 0; index < x.length; index += 1) {
+    xMinimum = Math.min(xMinimum, x[index]!)
+    xMaximum = Math.max(xMaximum, x[index]!)
+    yMinimum = Math.min(yMinimum, y[index]!)
+    yMaximum = Math.max(yMaximum, y[index]!)
+  }
+  return {
+    inputPointCount,
+    validPointCount: x.length,
+    xDomain: x.length ? [xMinimum, xMaximum] : null,
+    yDomain: x.length ? [yMinimum, yMaximum] : null,
+  }
+}
+
+export function statusFor<T extends { revision: number }>(
+  dataset: T | undefined,
+  revision: number,
+): WorkerSamplingStatus {
+  if (!dataset) return 'not-found'
+  return dataset.revision === revision ? 'ok' : 'stale-revision'
+}
+
+export function selectedStrategy(strategy: WorkerSamplingSeriesRequest['strategy']) {
+  return strategy === 'auto' ? 'peak' : strategy
+}
+
+export function targetPointCount(request: WorkerSamplingSeriesRequest) {
+  const width = Number.isFinite(request.plotWidth) ? Math.max(0, request.plotWidth) : 0
+  const density = Number.isFinite(request.maxPointsPerPixel)
+    ? Math.max(0, request.maxPointsPerPixel ?? 0)
+    : DEFAULT_WORKER_SAMPLING_MAX_POINTS_PER_PIXEL
+  return Math.max(1, Math.floor(width * density))
+}
+
+export function shouldUseRaw(request: WorkerSamplingSeriesRequest, visiblePointCount: number) {
+  if (request.mode === 'raw') return true
+  if (request.mode !== 'auto') return false
+  const threshold = Number.isFinite(request.autoThreshold)
+    ? Math.max(1, Math.floor(request.autoThreshold ?? 0))
+    : DEFAULT_WORKER_SAMPLING_AUTO_THRESHOLD
+  if (!request.previousSelectedMode) return visiblePointCount <= threshold
+  const hysteresis = Number.isFinite(request.autoHysteresis)
+    ? Math.max(0, Math.floor(request.autoHysteresis ?? 0))
+    : 0
+  return request.previousSelectedMode === 'raw'
+    ? visiblePointCount <= threshold + hysteresis
+    : visiblePointCount <= Math.max(0, threshold - hysteresis)
+}
+
+export function visibleRange(points: readonly WaveformPoint[], domain: [number, number]) {
+  const startX = Math.min(domain[0], domain[1])
+  const endX = Math.max(domain[0], domain[1])
+  return { start: pointBisector.left(points, startX), end: pointBisector.right(points, endX) }
+}
+
+export function visibleValueRange(x: Float64Array, domain: [number, number]) {
+  const startX = Math.min(domain[0], domain[1])
+  const endX = Math.max(domain[0], domain[1])
+  let start = 0
+  let end = x.length
+  while (start < end) {
+    const middle = start + Math.floor((end - start) / 2)
+    if (x[middle]! < startX) start = middle + 1
+    else end = middle
+  }
+  const rangeStart = start
+  end = x.length
+  while (start < end) {
+    const middle = start + Math.floor((end - start) / 2)
+    if (x[middle]! <= endX) start = middle + 1
+    else end = middle
+  }
+  return { start: rangeStart, end: start }
+}
+
+export function nearestPoint(points: readonly WaveformPoint[], x: number) {
+  const first = points[0]
+  const last = points.at(-1)
+  return Number.isFinite(x) && first && last && x >= first.x && x <= last.x
+    ? points[pointBisector.center(points, x)]
+    : undefined
+}
+
+export function outputCount(output: WorkerSamplingOutput | undefined) {
+  if (!output) return 0
+  return output.kind === 'source-indexes' ? output.sourceIndexes.length : output.x.length
+}
+
+export function outputWithGlobalIndexes(
+  output: WorkerSamplingOutput,
+  offset: number,
+): WorkerSamplingOutput {
+  if (output.kind === 'aggregates') return output
+  return {
+    kind: 'source-indexes',
+    sourceIndexes: Uint32Array.from(output.sourceIndexes, (index) => index + offset),
+  }
+}
+
+export function cacheKey(
+  request: WorkerSamplingSeriesRequest,
+  range: { start: number; end: number },
+  strategy: ReturnType<typeof selectedStrategy>,
+  target: number,
+  backend: WorkerSamplingBackendKind,
+) {
+  return [
+    request.datasetId,
+    request.revision,
+    range.start,
+    range.end,
+    request.plotWidth,
+    target,
+    request.maxPointsPerPixel,
+    request.mode,
+    backend,
+    strategy,
+    request.lineType ?? 'linear',
+    request.pointType ?? 'none',
+    request.errorBarVisible === true ? 1 : 0,
+    request.pointMinSpacing ?? 0,
+    request.errorBarMinSpacing ?? 0,
+  ].join('\u0000')
+}
+
+export function diagnosticsFor(
+  request: WorkerSamplingSeriesRequest,
+  sourcePointCount: number,
+  visiblePointCount: number,
+  backend: WorkerSamplingBackendKind,
+  selectedMode: 'raw' | 'sampled',
+  durationMs: number,
+  renderedPointCount: number,
+  cacheHit: boolean,
+): WorkerSamplingDiagnostics {
+  return {
+    seriesId: request.seriesId,
+    datasetId: request.datasetId,
+    mode: request.mode,
+    selectedMode,
+    backend,
+    strategy: selectedStrategy(request.strategy),
+    sourcePointCount,
+    visiblePointCount,
+    renderedPointCount,
+    durationMs,
+    cacheHit,
+    requestId: 0,
+    revision: request.revision,
+    rawPointLimitExceeded:
+      selectedMode === 'raw' &&
+      Number.isFinite(request.rawPointLimit) &&
+      visiblePointCount > (request.rawPointLimit ?? Number.POSITIVE_INFINITY),
+    scheduledRequestCount: 0,
+    coalescedRequestCount: 0,
+    maxPendingRequestCount: 0,
+  }
+}

package/src/core/workerSampling/repositoryTypedDataset.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest'
+
+import { WorkerSamplingRepository } from './repository'
+
+describe('WorkerSamplingRepository typed datasets', () => {
+  it('copies, filters, and stably orders typed columns without materializing point objects', () => {
+    const repository = new WorkerSamplingRepository()
+    const x = Float64Array.from([2, Number.NaN, 1, 1, 3])
+    const y = Float32Array.from([20, 99, 10, 11, Number.POSITIVE_INFINITY])
+    repository.handle({
+      type: 'register-dataset',
+      requestId: 80,
+      datasetId: 'typed',
+      revision: 0,
+      dataset: { kind: 'typed', x, y },
+    })
+    x[0] = 99
+    y[2] = 99
+
+    const sampled = repository.handle({
+      type: 'sample-viewport',
+      requestId: 81,
+      series: [
+        {
+          seriesId: 'typed',
+          datasetId: 'typed',
+          revision: 1,
+          xDomain: [1, 2],
+          plotWidth: 10,
+          mode: 'raw',
+          strategy: 'peak',
+        },
+      ],
+    })
+    const belowRange = repository.handle({
+      type: 'find-nearest-point',
+      requestId: 82,
+      datasetId: 'typed',
+      revision: 1,
+      x: 0,
+    })
+
+    expect(sampled).toMatchObject({
+      results: [
+        {
+          output: { kind: 'source-indexes', sourceIndexes: Uint32Array.from([0, 1, 2]) },
+        },
+      ],
+    })
+    expect(belowRange).toMatchObject({ status: 'ok', point: undefined })
+  })
+
+  it('derives sample X values from compact metadata and preserves source-time gaps', () => {
+    const repository = new WorkerSamplingRepository()
+    const values = new Float32Array([2, 6])
+    repository.handle({
+      type: 'register-dataset',
+      requestId: 90,
+      datasetId: 'samples',
+      revision: 0,
+      dataset: {
+        kind: 'samples',
+        values,
+        sampleRate: 2,
+        startTime: 10,
+        sourceIndexes: new Uint32Array([0, 2]),
+      },
+    })
+    values[0] = 99
+
+    expect(
+      repository.handle({
+        type: 'find-nearest-point',
+        requestId: 91,
+        datasetId: 'samples',
+        revision: 1,
+        x: 10.9,
+      }),
+    ).toMatchObject({ point: { x: 11, y: 6 } })
+    expect(
+      repository.handle({
+        type: 'get-dataset-metrics',
+        requestId: 92,
+        datasetId: 'samples',
+        revision: 1,
+      }),
+    ).toMatchObject({ metrics: { validPointCount: 2, xDomain: [10, 11], yDomain: [2, 6] } })
+  })
+})

package/src/core/workerSampling/repositoryWasmDataset.test.ts

@@ -0,0 +1,70 @@
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+import { beforeAll, describe, expect, it } from 'vitest'
+
+import { createInitializedWasmSamplingBackend, initializeWasmSampling } from '../wasmSampling'
+import { WorkerSamplingRepository } from './repository'
+
+describe('WorkerSamplingRepository WASM datasets', () => {
+  beforeAll(async () => {
+    await initializeWasmSampling(
+      await readFile(resolve(process.cwd(), 'wasm/pkg/waveform_sampling_wasm_bg.wasm')),
+    )
+  })
+
+  it('registers typed columns in WASM, reports lazy index bytes, and releases handles on replace', () => {
+    const repository = new WorkerSamplingRepository({
+      wasmBackend: createInitializedWasmSamplingBackend(),
+      indexMaxBytes: 1024 * 1024,
+    })
+    const register = repository.handle({
+      type: 'register-dataset',
+      requestId: 1,
+      datasetId: 'typed',
+      revision: 0,
+      dataset: {
+        kind: 'typed',
+        x: Float64Array.from({ length: 65 }, (_, index) => index / 100),
+        y: Float32Array.from({ length: 65 }, (_, index) => (index === 31 ? 50 : index)),
+      },
+    })
+    const sampled = repository.handle({
+      type: 'sample-viewport',
+      requestId: 2,
+      series: [
+        {
+          seriesId: 'typed',
+          datasetId: 'typed',
+          revision: 1,
+          xDomain: [0.03, 0.61],
+          plotWidth: 4,
+          mode: 'wasm',
+          strategy: 'peak',
+          maxPointsPerPixel: 2,
+        },
+      ],
+    })
+
+    expect(register).toMatchObject({ status: 'ok', metrics: { indexBytes: 0 } })
+    expect(sampled).toMatchObject({ results: [{ diagnostics: { backend: 'wasm' } }] })
+    expect(repository.resourceMetrics.indexBytes).toBeGreaterThan(0)
+
+    const replaced = repository.handle({
+      type: 'replace-dataset',
+      requestId: 3,
+      datasetId: 'typed',
+      revision: 1,
+      dataset: {
+        kind: 'typed',
+        x: Float64Array.from([0, 1]),
+        y: Float32Array.from([1, 2]),
+      },
+    })
+
+    expect(replaced).toMatchObject({ status: 'ok', revision: 2, metrics: { indexBytes: 0 } })
+    expect(repository.resourceMetrics.indexBytes).toBe(0)
+    repository.handle({ type: 'dispose-all', requestId: 4 })
+    expect(repository.resourceMetrics).toMatchObject({ datasetCount: 0, indexBytes: 0 })
+  })
+})

package/src/core/workerSampling/samplingCache.ts

@@ -0,0 +1,94 @@
+import type { WorkerSamplingOutput } from './protocol'
+
+export interface SamplingCacheMetrics {
+  entries: number
+  bytes: number
+  maxEntries: number
+  maxBytes: number
+}
+
+interface CacheEntry {
+  output: WorkerSamplingOutput
+  bytes: number
+}
+
+export interface SamplingOutputCacheOptions {
+  maxEntries?: number
+  maxBytes?: number
+}
+
+const DEFAULT_MAX_ENTRIES = 96
+const DEFAULT_MAX_BYTES = 16 * 1024 * 1024
+
+function outputBytes(output: WorkerSamplingOutput) {
+  return output.kind === 'source-indexes'
+    ? output.sourceIndexes.byteLength
+    : output.x.byteLength + output.y.byteLength
+}
+
+/** A bounded LRU for immutable Worker sampling outputs. */
+export class SamplingOutputCache {
+  private readonly entries = new Map<string, CacheEntry>()
+  private bytes = 0
+  private readonly maxEntries: number
+  private readonly maxBytes: number
+
+  constructor(options: SamplingOutputCacheOptions = {}) {
+    this.maxEntries = Number.isFinite(options.maxEntries)
+      ? Math.max(0, Math.floor(options.maxEntries ?? 0))
+      : DEFAULT_MAX_ENTRIES
+    this.maxBytes = Number.isFinite(options.maxBytes)
+      ? Math.max(0, Math.floor(options.maxBytes ?? 0))
+      : DEFAULT_MAX_BYTES
+  }
+
+  get metrics(): SamplingCacheMetrics {
+    return {
+      entries: this.entries.size,
+      bytes: this.bytes,
+      maxEntries: this.maxEntries,
+      maxBytes: this.maxBytes,
+    }
+  }
+
+  get(key: string) {
+    const entry = this.entries.get(key)
+    if (!entry) return undefined
+    this.entries.delete(key)
+    this.entries.set(key, entry)
+    return entry.output
+  }
+
+  set(key: string, output: WorkerSamplingOutput) {
+    const bytes = outputBytes(output)
+    if (bytes > this.maxBytes || this.maxEntries === 0) return
+    const existing = this.entries.get(key)
+    if (existing) {
+      this.bytes -= existing.bytes
+      this.entries.delete(key)
+    }
+    this.entries.set(key, { output, bytes })
+    this.bytes += bytes
+    while (this.entries.size > this.maxEntries || this.bytes > this.maxBytes) {
+      const oldest = this.entries.entries().next().value
+      if (!oldest) break
+      const [oldestKey, oldestEntry] = oldest
+      this.entries.delete(oldestKey)
+      this.bytes -= oldestEntry.bytes
+    }
+  }
+
+  deleteDataset(datasetId: string) {
+    const prefix = `${datasetId}\u0000`
+    for (const [key, entry] of this.entries) {
+      if (!key.startsWith(prefix)) continue
+      this.entries.delete(key)
+      this.bytes -= entry.bytes
+    }
+  }
+
+  clear() {
+    this.entries.clear()
+    this.bytes = 0
+  }
+}