Javascript cache memory leak weakref solution

Hard

You're building a caching system that shouldn't prevent objects from being garbage collected. What's wrong with the current implementation and which solution properly handles memory management?

Choose an option below

class Cache {
  constructor() {
    this.items = new WeakMap();
    this.metadata = new WeakMap();
  }
  
  set(key, value, metadata = {}) {
    this.items.set(key, value);
    this.metadata.set(key, {
      ...metadata,
      accessCount: 0,
      lastAccessed: Date.now()
    });
  }
  
  get(key) {
    const item = this.items.get(key);
    if (item) {
      const meta = this.metadata.get(key);
      meta.accessCount++;
      meta.lastAccessed = Date.now();
    }
    return item;
  }
}

class Cache {
  constructor() {
    this.items = new Map();
    this.metadata = new Map();
    
    setInterval(() => this.cleanup(), 5000);
  }
  
  cleanup() {
    const now = Date.now();
    for (const [key, meta] of this.metadata) {
      if (now - meta.lastAccessed > 3600000) {
        this.items.delete(key);
        this.metadata.delete(key);
      }
    }
  }
}

class Cache {
  constructor() {
    this.items = new Map();
    this.refs = new WeakMap();
    this.metadata = new Map();
  }
  
  set(key, value, metadata = {}) {
    const ref = new WeakRef(value);
    this.items.set(key, ref);
    this.refs.set(value, key);
    this.metadata.set(key, {
      ...metadata,
      accessCount: 0,
      lastAccessed: Date.now()
    });
  }
  
  get(key) {
    const ref = this.items.get(key);
    if (ref) {
      const value = ref.deref();
      if (value) {
        const meta = this.metadata.get(key);
        meta.accessCount++;
        meta.lastAccessed = Date.now();
        return value;
      }
      // Value was garbage collected
      this.items.delete(key);
      this.metadata.delete(key);
    }
    return undefined;
  }
}

class Cache {
  constructor() {
    this.cache = new Map();
  }
  
  set(key, value, metadata = {}) {
    this.cache.set(key, {
      value: value,
      metadata: {
        ...metadata,
        accessCount: 0,
        lastAccessed: Date.now()
      }
    });
    setTimeout(() => this.cache.delete(key), 3600000);
  }
}

JavascriptWeakrefGarbage collectionMemory managementCaching

1class Cache {
constructor() {
  this.items = new Map();
  this.metadata = new Map();
}

// Current implementation with memory leaks
set(key, value, metadata = {}) {
  this.items.set(key, value);
  this.metadata.set(key, {
    ...metadata,
    accessCount: 0,
    lastAccessed: Date.now()
  });
}

get(key) {
  const item = this.items.get(key);
  if (item) {
    const meta = this.metadata.get(key);
    meta.accessCount++;
    meta.lastAccessed = Date.now();
  }
  return item;
}
26}

You're building a caching system that shouldn't prevent objects from being garbage collected. What's wrong with the current implementation and which solution properly handles memory management?

Hint