fix(plots): preserve cached history during replacement and startup cleanup

Reclaim superseded payloads before evicting retained plots.
Observe JGD history changes before asynchronous httpgd initialization.
Add regression coverage for full-quota replacement and R exit during startup.

Author: Fred Wu

src/plotViewer/index.ts

@@ -130,14 +130,8 @@ export class CommonPlotManager implements PlotManager {
             !this.historyCheckpointId ||
             trimmed ||
             saved?.sessions.length !== this.jgdManager.history.sessionIds().length;
-        const sources = extensionContext.workspaceState.get<unknown>('r.plot.standardSessions');
-        this.restoredStandardSessions = Array.isArray(sources)
-            ? sources.filter(isViewerSessionSource)
-            : [];
-        for (const source of this.restoredStandardSessions) {
-            this.lifecycle.observe(source);
-        }
-        await this.httpgdManager.initialize();
+        // Restored owners are already observed. Track exits before another
+        // backend's asynchronous initialization can yield to those callbacks.
         this.historySubscription = this.jgdManager.history.onDidChange((_id, selectionOnly) => {
             this.historyContentDirty ||= !selectionOnly;
             this.historySelectionDirty = true;
@@ -150,6 +144,14 @@ export class CommonPlotManager implements PlotManager {
                 }, 250);
             }
         });
+        const sources = extensionContext.workspaceState.get<unknown>('r.plot.standardSessions');
+        this.restoredStandardSessions = Array.isArray(sources)
+            ? sources.filter(isViewerSessionSource)
+            : [];
+        for (const source of this.restoredStandardSessions) {
+            this.lifecycle.observe(source);
+        }
+        await this.httpgdManager.initialize();
 
         for (const cmd of commands) {
             const fullCommand = `r.plot.${cmd}`;

src/plotViewer/persistentPlotCache.ts

@@ -90,7 +90,22 @@ export class PersistentPlotCache {
         }
     }
 
-    private async makeRoom(bytes: number): Promise<void> {
+    private async makeRoom(bytes: number, retained?: ReadonlySet<string>): Promise<void> {
+        // Replacements must release superseded payloads before evicting plots
+        // still referenced by the next checkpoint or the other backend.
+        if (retained) {
+            for (const key of this.files.keys()) {
+                if (this.bytes + bytes <= this.maxBytes) {
+                    break;
+                }
+                if (!retained.has(key)) {
+                    await this.remove(key);
+                }
+            }
+        }
+        if (this.bytes + bytes <= this.maxBytes) {
+            return;
+        }
         const oldest = [...this.files].sort((a, b) => a[1].created - b[1].created);
         for (const [key] of oldest) {
             if (this.bytes + bytes <= this.maxBytes) {
@@ -138,7 +153,10 @@ export class PersistentPlotCache {
         const operation = this.writes.then(async () => {
             await this.initialize();
             const references = new Set<string>();
-            const metadata = await build(async (plot) => {
+            // Keep snapshot objects, not a second serialized copy of the entire
+            // history. Only missing payloads need serialization again for writing.
+            const pending = new Map<string, { plot: object; bytes: number }>();
+            const metadata = await build((plot) => {
                 const content = JSON.stringify(plot);
                 const key = createHash('sha256').update(content).digest('hex');
                 references.add(key);
@@ -149,7 +167,22 @@ export class PersistentPlotCache {
                     !this.files.has(key) &&
                     !this.discarded.has(key)
                 ) {
-                    await this.makeRoom(bytes);
+                    pending.set(key, { plot, bytes });
+                }
+                return Promise.resolve({ cacheKey: key });
+            });
+            const retained = new Set(references);
+            for (const [other, keys] of this.references) {
+                if (other !== namespace) {
+                    for (const key of keys) {
+                        retained.add(key);
+                    }
+                }
+            }
+            for (const [key, { plot, bytes }] of pending) {
+                if (this.directory) {
+                    const content = JSON.stringify(plot);
+                    await this.makeRoom(bytes, retained);
                     const filename = path.join(this.directory, `${key}.json`);
                     try {
                         await fs.writeFile(filename, content);
@@ -160,8 +193,7 @@ export class PersistentPlotCache {
                     this.files.set(key, { bytes, created: Date.now() });
                     this.bytes += bytes;
                 }
-                return { cacheKey: key };
-            });
+            }
             await publish(metadata);
             this.register(namespace, references);
             await this.collect();

src/test/node/persistentPlotCache.test.ts

@@ -90,6 +90,43 @@ suite('Persistent workspace plot cache', () => {
         assert.equal(plot.data.length, 50);
     });
 
+    test('an equal-sized replacement at full quota preserves unchanged history across reload', async () => {
+        const a = { id: '1', data: '<svg>A</svg>', width: 800, height: 600, zoom: 1 };
+        const b = { ...a, id: '2', data: '<svg>B</svg>' };
+        const replacement = { ...b, data: '<svg>C</svg>' };
+        const bytes = Buffer.byteLength(JSON.stringify(a));
+        const cache = new PersistentPlotCache(directory, bytes * 2);
+        const original = await put(cache, 'httpgd', [a, b]);
+        const updated = await put(cache, 'httpgd', [a, replacement]);
+
+        assert.equal(await size(), bytes * 2);
+        assert.deepEqual(await cache.read(updated[0]), a);
+        assert.deepEqual(await cache.read(updated[1]), replacement);
+        assert.equal(await cache.read(original[1]), undefined);
+        const reload = new PersistentPlotCache(directory, bytes * 2);
+        reload.register(
+            'httpgd',
+            updated.map((ref) => ref.cacheKey),
+        );
+        assert.deepEqual(await reload.read(updated[0]), a);
+        assert.deepEqual(await reload.read(updated[1]), replacement);
+    });
+
+    test('replacement preserves payloads still referenced by another backend', async () => {
+        const a = { data: 'a' },
+            b = { data: 'b' },
+            replacement = { data: 'c' };
+        const bytes = Buffer.byteLength(JSON.stringify(a));
+        const cache = new PersistentPlotCache(directory, bytes * 3);
+        const shared = await put(cache, 'jgd', [b]);
+        await put(cache, 'httpgd', [a, b]);
+        const updated = await put(cache, 'httpgd', [a, replacement]);
+        assert.equal(await size(), bytes * 3);
+        assert.deepEqual(await cache.read(shared[0]), b);
+        assert.deepEqual(await cache.read(updated[0]), a);
+        assert.deepEqual(await cache.read(updated[1]), replacement);
+    });
+
     test('large histories share the byte budget without rewriting unchanged files', async () => {
         const cache = new PersistentPlotCache(directory, 20 * 1024 * 1024);
         const a = { data: 'a'.repeat(8 * 1024 * 1024) };

src/test/plot/plotRestoration.test.ts

@@ -468,6 +468,41 @@ suite('Standalone plot restoration', () => {
         assert.deepStrictEqual((state.get('r.plot.jgdState') as PlotHistoryState).sessions, []);
     });
 
+    test('JGD exit during httpgd initialization removes its saved checkpoint and payload', async () => {
+        const exits = processExits();
+        const source = owner('initializing-exit', '123');
+        const first = await manager();
+        first.jgdManager.history.addPlot('device', frame('device'));
+        first.jgdManager.history.setSessionSource('device', source);
+        await first.dispose();
+        const cacheDirectory = path.join(storageDirectory, 'plot-cache');
+        assert.strictEqual((await fs.readdir(cacheDirectory)).length, 1);
+
+        const restored = new CommonPlotManager();
+        managers.push(restored);
+        const started = deferred<void>();
+        const gate = deferred<void>();
+        const initialize = restored.httpgdManager.initialize.bind(restored.httpgdManager);
+        sandbox.stub(restored.httpgdManager, 'initialize').callsFake(async () => {
+            started.resolve();
+            await gate.promise;
+            await initialize();
+        });
+        const initializing = restored.initialize();
+        try {
+            await started.promise;
+            assert.strictEqual(restored.jgdManager.history.count('device'), 1);
+            exits.exit(source);
+            assert.deepStrictEqual(restored.jgdManager.history.sessionIds(), []);
+        } finally {
+            gate.resolve();
+            await initializing;
+        }
+        await restored.dispose();
+        assert.deepStrictEqual((state.get('r.plot.jgdState') as PlotHistoryState).sessions, []);
+        assert.deepStrictEqual(await fs.readdir(cacheDirectory), []);
+    });
+
     test('httpgd process exit clears history, connections and saved credentials without affecting other owners', async () => {
         const exits = processExits();
         const source = owner('httpgd-owner', '14001');