perf: plug three HIGH-impact leaks in preview pipeline

- runtime overlay: make 200ms reattach interval stoppable via
  window.__cs_reattach_interval, clear on pagehide/beforeunload so
  iframe teardown actually stops the poll loop
- hub DesignCardPreview: bound the module-level memCache to 40 entries
  with insertion-order LRU, matching the existing localStorage cap
- renderer store: clear autoPolishFired[designId] in softDeleteDesign
  so deleted designs don't accumulate in the dedupe set

Identified by audit pass; runtime tests 15/15 green, desktop typecheck clean.

Author: hqhq1025

apps/desktop/src/renderer/src/store.ts

@@ -1679,6 +1679,9 @@ export const useCodesignStore = create<CodesignState>((set, get) => ({
     }
     try {
       await window.codesign.snapshots.softDeleteDesign(id);
+      const nextFired = new Set(get().autoPolishFired);
+      nextFired.delete(id);
+      set({ autoPolishFired: nextFired });
       const wasCurrent = get().currentDesignId === id;
       await get().loadDesigns();
       if (wasCurrent) {

apps/desktop/src/renderer/src/views/hub/DesignCardPreview.tsx

@@ -50,26 +50,43 @@ const memCache = new Map<string, string>();
 const LS_PREFIX = 'designCardPreview:';
 const LS_MAX_CHARS = 300_000; // ~ 300 KB per entry ceiling; skip caching huge HTML
 const LS_MAX_ENTRIES = 40;
+const MEM_MAX_ENTRIES = 40;
 
 function cacheKey(id: string, updatedAt: string): string {
   return `${id}:${updatedAt}`;
 }
 
+// Map iteration order = insertion order, so delete+set on hit refreshes recency
+// and evicting the first key drops the least-recently-used entry.
+function memCacheTouch(key: string, value: string): void {
+  memCache.delete(key);
+  memCache.set(key, value);
+  while (memCache.size > MEM_MAX_ENTRIES) {
+    const oldest = memCache.keys().next().value;
+    if (oldest === undefined) break;
+    memCache.delete(oldest);
+  }
+}
+
 function readCache(key: string): string | null {
   const hit = memCache.get(key);
-  if (hit !== undefined) return hit;
+  if (hit !== undefined) {
+    memCache.delete(key);
+    memCache.set(key, hit);
+    return hit;
+  }
   if (typeof localStorage === 'undefined') return null;
   try {
     const raw = localStorage.getItem(LS_PREFIX + key);
-    if (raw !== null) memCache.set(key, raw);
+    if (raw !== null) memCacheTouch(key, raw);
     return raw;
   } catch {
     return null;
   }
 }
 
 function writeCache(key: string, html: string): void {
-  memCache.set(key, html);
+  memCacheTouch(key, html);
   if (typeof localStorage === 'undefined') return;
   if (html.length > LS_MAX_CHARS) return;
   try {

packages/runtime/src/overlay.ts

@@ -207,7 +207,26 @@ export const OVERLAY_SCRIPT = `(function() {
     }
   }
   reattach();
-  try { setInterval(reattach, 200); } catch (err) { console.warn('[overlay] setInterval reattach failed:', err); }
+  try {
+    if (window.__cs_reattach_interval) {
+      try { clearInterval(window.__cs_reattach_interval); } catch (_) {}
+      window.__cs_reattach_interval = 0;
+    }
+    window.__cs_reattach_interval = setInterval(reattach, 200);
+    if (!window.__cs_reattach_unload) {
+      window.__cs_reattach_unload = true;
+      var stopReattach = function() {
+        try {
+          if (window.__cs_reattach_interval) {
+            clearInterval(window.__cs_reattach_interval);
+            window.__cs_reattach_interval = 0;
+          }
+        } catch (_) {}
+      };
+      try { window.addEventListener('pagehide', stopReattach, false); } catch (_) {}
+      try { window.addEventListener('beforeunload', stopReattach, false); } catch (_) {}
+    }
+  } catch (err) { try { console.warn('[overlay] setInterval reattach failed:', err); } catch (_) {} }
 
   // Neutralize programmatic navigation — generated code may call
   // window.location = '/foo', location.assign('/x'), or window.open(...)