@@ -639,13 +854,16 @@ ${getRendererScript()}
function getRendererScript(): string {
return `
const vscode = acquireVsCodeApi();
+${getViewerSessionScript()}
const canvas = document.getElementById('plot-canvas');
const ctx = canvas.getContext('2d');
const metricsCanvas = document.getElementById('metrics-canvas');
const metricsCtx = metricsCanvas.getContext('2d');
let currentPlot = null;
-
+// A retained tab can be hidden without changing document.hidden.
+// VS Code's panel state is authoritative for whether this layout is usable.
+let panelVisible = false;
document.getElementById('btn-prev').addEventListener('click', () => {
vscode.postMessage({ type: 'navigate', direction: 'previous' });
});
@@ -667,21 +885,41 @@ const container = document.getElementById('canvas-container');
let resizeTimer = null;
let lastSentW = 0;
let lastSentH = 0;
+function reportViewportSize() {
+ if (!panelVisible || document.hidden) return;
+ const w = container.clientWidth;
+ const h = container.clientHeight;
+ if (w <= 0 || h <= 0) return;
+ if (w !== lastSentW || h !== lastSentH) {
+ lastSentW = w;
+ lastSentH = h;
+ vscode.postMessage({ type: 'resize', width: w, height: h });
+ }
+}
const resizeObserver = new ResizeObserver(() => {
+ if (!panelVisible || document.hidden) return;
if (currentPlot) replay(currentPlot);
clearTimeout(resizeTimer);
- resizeTimer = setTimeout(() => {
- const w = container.clientWidth;
- const h = container.clientHeight;
- if (w !== lastSentW || h !== lastSentH) {
- lastSentW = w;
- lastSentH = h;
- vscode.postMessage({ type: 'resize', width: w, height: h });
- }
- }, 300);
+ resizeTimer = setTimeout(reportViewportSize, 300);
});
resizeObserver.observe(container);
+function refreshVisibility() {
+ if (!panelVisible || document.hidden) {
+ clearTimeout(resizeTimer);
+ ++replayGeneration;
+ return;
+ }
+ // A retained, hidden webview has a temporary layout. Its visible size
+ // may be unchanged, so ResizeObserver alone cannot restore the canvas.
+ requestAnimationFrame(() => {
+ if (!panelVisible || document.hidden) return;
+ if (currentPlot) replay(currentPlot);
+ reportViewportSize();
+ });
+}
+document.addEventListener('visibilitychange', refreshVisibility);
+
(function warmupMetrics() {
const fonts = [
{ size: 12, family: 'sans-serif', face: 1 },
@@ -717,8 +955,13 @@ window.addEventListener('message', (event) => {
switch (msg.type) {
case 'render':
currentPlot = msg.plot;
+ panelVisible = msg.visible;
replay(msg.plot);
break;
+ case 'visibility':
+ panelVisible = msg.visible;
+ refreshVisibility();
+ break;
case 'clear':
currentPlot = null;
ctx.clearRect(0, 0, canvas.width, canvas.height);
@@ -739,6 +982,8 @@ window.addEventListener('message', (event) => {
}
});
+vscode.postMessage({ type: 'ready' });
+
function applyGc(ctx, gc) {
ctx.globalCompositeOperation = 'source-over';
ctx.globalAlpha = 1;
@@ -862,7 +1107,7 @@ async function replay(plot) {
}
async function doReplay(plot, gen) {
- if (replayGeneration !== gen) return;
+ if (replayGeneration !== gen || !panelVisible || document.hidden) return;
const dpr = window.devicePixelRatio || 1;
const containerW = container.clientWidth;
diff --git a/src/plotViewer/plotLifecycle.ts b/src/plotViewer/plotLifecycle.ts
new file mode 100644
index 000000000..ffc20215a
--- /dev/null
+++ b/src/plotViewer/plotLifecycle.ts
@@ -0,0 +1,73 @@
+import { getViewerSessionContext } from '../session';
+import { sessionProcessIdentity } from '../sessionIdentity';
+import type { ViewerSessionSource } from '../viewerSession';
+
+/** Confirmed R exit triggers full cleanup, regardless of panel visibility.
+ * Disposing the extension or losing its transport does not end an R session.
+ */
+export class PlotLifecycle {
+ private subscriptions = new Map
();
+ private exited = new Set();
+ private listeners = new Set<(source: ViewerSessionSource) => void>();
+ private disposed = false;
+
+ onExit(listener: (source: ViewerSessionSource) => void): { dispose(): void } {
+ this.listeners.add(listener);
+ return { dispose: () => this.listeners.delete(listener) };
+ }
+
+ hasExited(source?: ViewerSessionSource): boolean {
+ return (
+ !!source && (source.processExited || this.exited.has(sessionProcessIdentity(source)))
+ );
+ }
+
+ observe(source?: ViewerSessionSource): void {
+ if (!source || this.disposed) {
+ return;
+ }
+ const key = sessionProcessIdentity(source);
+ if (this.exited.has(key) || this.subscriptions.has(key)) {
+ return;
+ }
+ // Session adapters can clear PID metadata during detach. Keep the
+ // original process identity for the eventual exit callback.
+ const captured: ViewerSessionSource = {
+ sessionId: source.sessionId,
+ host: source.host,
+ pid: source.pid,
+ rVer: source.rVer,
+ processExited: source.processExited,
+ };
+ const context = getViewerSessionContext(captured.sessionId, captured);
+ const subscription = context?.observeExit(() => this.markExited(captured));
+ if (subscription) {
+ this.subscriptions.set(key, subscription);
+ }
+ if (source.processExited || context?.hasExited) {
+ this.markExited(captured);
+ }
+ }
+
+ markExited(source: ViewerSessionSource): void {
+ const key = sessionProcessIdentity(source);
+ if (this.disposed || this.exited.has(key)) {
+ return;
+ }
+ this.exited.add(key);
+ this.subscriptions.get(key)?.dispose();
+ this.subscriptions.delete(key);
+ for (const listener of this.listeners) {
+ listener(source);
+ }
+ }
+
+ dispose(): void {
+ this.disposed = true;
+ for (const subscription of this.subscriptions.values()) {
+ subscription.dispose();
+ }
+ this.subscriptions.clear();
+ this.listeners.clear();
+ }
+}
diff --git a/src/plotViewer/plotViewerRegistry.ts b/src/plotViewer/plotViewerRegistry.ts
new file mode 100644
index 000000000..8ecdef2e4
--- /dev/null
+++ b/src/plotViewer/plotViewerRegistry.ts
@@ -0,0 +1,100 @@
+import { sessionProcessIdentity } from '../sessionIdentity';
+import type { ViewerSessionSource } from '../viewerSession';
+import type { PlotViewer } from './types';
+import { PlotLifecycle } from './plotLifecycle';
+
+/** One viewer per R process, including devices whose owner is identified later. */
+export class PlotViewerRegistry {
+ private viewers = new Map();
+ private recent: T[] = [];
+ readonly lifecycle: PlotLifecycle;
+ private readonly ownsLifecycle: boolean;
+ private readonly exitSubscription: { dispose(): void };
+
+ constructor(onExit: (source: ViewerSessionSource) => void, lifecycle?: PlotLifecycle) {
+ this.ownsLifecycle = !lifecycle;
+ this.lifecycle = lifecycle ?? new PlotLifecycle();
+ this.exitSubscription = this.lifecycle.onExit((source) => {
+ const viewer = this.forSession(source);
+ if (viewer) {
+ this.remove(viewer);
+ viewer.dispose(true);
+ }
+ // Backing data may exist even when no viewer was opened.
+ onExit(source);
+ });
+ }
+
+ get(key: string): T | undefined {
+ return this.viewers.get(key);
+ }
+
+ forSession(source?: ViewerSessionSource): T | undefined {
+ return source ? this.get(sessionProcessIdentity(source)) : undefined;
+ }
+
+ values(): T[] {
+ return [...this.viewers.values()];
+ }
+
+ get recentlyActive(): readonly T[] {
+ return this.recent;
+ }
+
+ markActive(viewer: T): void {
+ this.recent = this.recent.filter((active) => active !== viewer);
+ this.recent.unshift(viewer);
+ }
+
+ remove(viewer: T): void {
+ for (const [key, value] of this.viewers) {
+ if (value === viewer) {
+ this.viewers.delete(key);
+ }
+ }
+ this.recent = this.recent.filter((active) => active !== viewer);
+ }
+
+ register(viewer: T, source?: ViewerSessionSource, deviceId = viewer.id): void {
+ const key = source ? sessionProcessIdentity(source) : deviceId;
+ // Preserve recent focus when moving an ownerless viewer to its owner.
+ if (this.viewers.get(key) !== viewer) {
+ for (const [oldKey, value] of this.viewers) {
+ if (value === viewer) {
+ this.viewers.delete(oldKey);
+ }
+ }
+ }
+ this.viewers.delete(key);
+ this.viewers.set(key, viewer);
+ this.lifecycle.observe(source);
+ if (this.lifecycle.hasExited(source) && this.viewers.get(key) === viewer) {
+ this.remove(viewer);
+ viewer.dispose(true);
+ }
+ }
+
+ getOrCreate(source: ViewerSessionSource | undefined, deviceId: string, create: () => T): T {
+ let viewer = this.forSession(source) ?? this.get(deviceId);
+ const previous = this.get(deviceId);
+ if (previous && previous !== viewer) {
+ this.remove(previous);
+ previous.dispose();
+ }
+ viewer ??= create();
+ this.register(viewer, source, deviceId);
+ return viewer;
+ }
+
+ dispose(): void {
+ this.exitSubscription.dispose();
+ if (this.ownsLifecycle) {
+ this.lifecycle.dispose();
+ }
+ for (const viewer of this.viewers.values()) {
+ viewer.dispose();
+ }
+ // Shutdown writers still read the owners/endpoints for live R sessions.
+ // Permanent exit instead removes entries immediately in the handler above.
+ }
+}
diff --git a/src/plotViewer/standardViewer.ts b/src/plotViewer/standardViewer.ts
index 7b4efa239..76cd175b8 100644
--- a/src/plotViewer/standardViewer.ts
+++ b/src/plotViewer/standardViewer.ts
@@ -2,6 +2,13 @@ import * as vscode from 'vscode';
import { asViewColumn, config, UriIcon } from '../util';
import * as session from '../session';
import { PlotViewer } from './types';
+import {
+ getViewerSessionScript,
+ viewerSessionStyle,
+ ViewerSessionContext,
+ ViewerSessionSource,
+} from '../viewerSession';
+import { extensionContext } from '../extension';
interface PlotResponse {
data: string;
@@ -11,7 +18,7 @@ interface PlotResponse {
interface PendingPlotRequest {
panel: vscode.WebviewPanel;
panelGeneration: number;
- targetSession: session.Session | undefined;
+ targetSession: session.Session;
width: number;
height: number;
format: string;
@@ -23,13 +30,41 @@ export class StandardPlotViewer implements PlotViewer {
private panel: vscode.WebviewPanel | undefined;
private viewWidth: number = 800;
private viewHeight: number = 600;
- private plotData: string | undefined;
- private plotFormat: string | undefined;
private panelGeneration = 0;
private pendingPlotRequest: PendingPlotRequest | undefined;
private plotRequest: Promise | undefined;
- public async update(): Promise {
+ private source!: ViewerSessionSource;
+ private sessionContext: ViewerSessionContext | undefined;
+
+ get sessionSource(): ViewerSessionSource {
+ return this.source;
+ }
+
+ constructor(owner: session.Session) {
+ this.bindSession(owner);
+ }
+
+ bindSession(owner: session.Session): void {
+ this.source = {
+ sessionId: owner.sessionId,
+ host: owner.host,
+ pid: owner.pid,
+ rVer: owner.rVer,
+ processExited: owner.processExited,
+ };
+ }
+
+ get isActive(): boolean {
+ return this.panel?.active ?? false;
+ }
+
+ public async update(restoring = false): Promise {
+ if (restoring) {
+ // Refresh retained panels without creating or revealing a viewer.
+ await this.requestPlot();
+ return;
+ }
const viewColumn = asViewColumn(
config().get('session.viewers.viewColumn.plot'),
vscode.ViewColumn.Two,
@@ -43,6 +78,16 @@ export class StandardPlotViewer implements PlotViewer {
}
public show(preserveFocus?: boolean): void {
+ if (!this.panel && !this.source.processExited && !this.sessionContext?.hasExited) {
+ this.createPanel(
+ asViewColumn(
+ config().get('session.viewers.viewColumn.plot'),
+ vscode.ViewColumn.Two,
+ ),
+ );
+ } else if (this.panel) {
+ void this.requestPlot();
+ }
if (this.panel) {
this.panel.reveal(undefined, preserveFocus);
}
@@ -52,12 +97,15 @@ export class StandardPlotViewer implements PlotViewer {
// Contextual plot commands are not supported by the standard viewer.
}
- public dispose(): void {
+ public dispose(keepPanel = false): void {
const panel = this.panel;
if (panel) {
this.panel = undefined;
this.panelGeneration++;
- panel.dispose();
+ this.pendingPlotRequest = undefined;
+ if (!keepPanel) {
+ panel.dispose();
+ }
}
}
@@ -105,23 +153,27 @@ export class StandardPlotViewer implements PlotViewer {
});
// Install the receiver before starting the document so its first ready
// message cannot be missed, even without a visible layout/resize event.
+ this.sessionContext = session.getViewerSessionContext(this.source.sessionId, this.source);
+ this.sessionContext?.attach(panel);
panel.webview.html = this.getHtml();
}
private requestPlot(): Promise {
const panel = this.panel;
- if (!session.globalPipePath || !panel) {
+ const targetSession = session.resolvePlotSession(this.source);
+ if (!panel || !targetSession) {
return Promise.resolve();
}
+ const conf = config();
this.pendingPlotRequest = {
panel,
panelGeneration: this.panelGeneration,
- targetSession: session.activeSession,
+ targetSession,
width: this.viewWidth,
height: this.viewHeight,
- format: config().get('plot.format', 'svglite'),
- devArgs: config().get>('plot.devArgs'),
+ format: conf.get('plot.format', 'svglite'),
+ devArgs: conf.get>('plot.devArgs'),
};
return this.startPlotDrain();
}
@@ -204,12 +256,10 @@ export class StandardPlotViewer implements PlotViewer {
}
if (this.isCurrentRequest(request)) {
- this.plotData = response.data;
- this.plotFormat = response.format || request.format;
void request.panel.webview.postMessage({
type: 'update',
- data: this.plotData,
- format: this.plotFormat,
+ data: response.data,
+ format: response.format || request.format,
});
}
}
@@ -217,26 +267,29 @@ export class StandardPlotViewer implements PlotViewer {
private isCurrentRequest(request: PendingPlotRequest): boolean {
return (
- Boolean(session.globalPipePath) &&
this.panel === request.panel &&
this.panelGeneration === request.panelGeneration &&
- session.activeSession === request.targetSession
+ session.resolvePlotSession(this.source) === request.targetSession
);
}
- private discardPendingForSession(targetSession: session.Session | undefined): void {
+ private discardPendingForSession(targetSession: session.Session): void {
if (this.pendingPlotRequest?.targetSession === targetSession) {
this.pendingPlotRequest = undefined;
}
}
private getHtml() {
+ const codicons = this.panel!.webview.asWebviewUri(
+ vscode.Uri.joinPath(extensionContext.extensionUri, 'dist', 'resources', 'codicon.css'),
+ );
return `
+
+ ${this.sessionContext?.getHtml() ?? ''}
`,
+ );
+ }
+}
+
+suite('Standalone plot restoration', () => {
+ let sandbox: sinon.SinonSandbox;
+ let state: Map;
+ let secrets: Map;
+ let managers: CommonPlotManager[];
+ let connect: sinon.SinonStub;
+ let callbacks: Map Promise>;
+ let panels: Array<{
+ panel: vscode.WebviewPanel;
+ receive: (message: unknown) => Promise;
+ post: sinon.SinonStub;
+ }>;
+
+ setup(() => {
+ sandbox = sinon.createSandbox();
+ state = new Map();
+ secrets = new Map();
+ managers = [];
+ callbacks = new Map();
+ panels = [];
+ mockExtensionContext(path.resolve(__dirname, '../../..'), sandbox);
+ (extensionContext.workspaceState.get as sinon.SinonStub).callsFake(
+ (key: string, fallback?: unknown) => state.get(key) ?? fallback,
+ );
+ (extensionContext.workspaceState.update as sinon.SinonStub).callsFake(
+ (key: string, value: unknown) => {
+ state.set(key, structuredClone(value));
+ return Promise.resolve();
+ },
+ );
+ (extensionContext.secrets.get as sinon.SinonStub).callsFake((key: string) =>
+ Promise.resolve(secrets.get(key)),
+ );
+ (extensionContext.secrets.store as sinon.SinonStub).callsFake(
+ (key: string, value: string) => {
+ secrets.set(key, value);
+ return Promise.resolve();
+ },
+ );
+ (extensionContext.secrets.delete as sinon.SinonStub).callsFake((key: string) => {
+ secrets.delete(key);
+ return Promise.resolve();
+ });
+ sandbox.stub(vscode.commands, 'registerCommand').callsFake((command, callback) => {
+ callbacks.set(command, callback as (...args: unknown[]) => Promise);
+ return new vscode.Disposable(() => {});
+ });
+ sandbox.stub(vscode.commands, 'executeCommand').resolves();
+ sandbox.stub(JgdManager.prototype, 'start');
+ connect = sandbox.stub(HttpgdClient.prototype, 'connect').resolves();
+ sandbox.stub(util, 'config').returns({
+ get: (_key: string, fallback: unknown) => fallback,
+ } as vscode.WorkspaceConfiguration);
+ sandbox.stub(vscode.window, 'createWebviewPanel').callsFake((viewType, title) => {
+ const panelId = panels.length;
+ const disposed = new vscode.EventEmitter();
+ const listeners = new Set<(message: unknown) => unknown>();
+ const post = sandbox.stub().resolves(true);
+ const panel = {
+ title,
+ viewType,
+ active: true,
+ reveal: sandbox.stub(),
+ webview: {
+ html: '',
+ postMessage: post,
+ asWebviewUri: (uri: vscode.Uri) =>
+ uri.with({
+ scheme: 'https',
+ authority: `panel${panelId}.vscode-resource.vscode-cdn.net`,
+ }),
+ onDidReceiveMessage: (callback: (message: unknown) => unknown) => {
+ listeners.add(callback);
+ return new vscode.Disposable(() => {
+ listeners.delete(callback);
+ });
+ },
+ },
+ onDidDispose: disposed.event,
+ onDidChangeViewState: () => new vscode.Disposable(() => {}),
+ dispose: () => disposed.fire(),
+ } as unknown as vscode.WebviewPanel;
+ panels.push({
+ panel,
+ post,
+ receive: async (message) => {
+ await Promise.all([...listeners].map((listener) => listener(message)));
+ },
+ });
+ return panel;
+ });
+ });
+
+ teardown(async () => {
+ for (const manager of managers) {
+ await manager.dispose();
+ }
+ for (const { panel } of panels) {
+ panel.dispose();
+ }
+ sandbox.restore();
+ });
+
+ function manager(): CommonPlotManager {
+ const value = new CommonPlotManager();
+ value.initialize();
+ managers.push(value);
+ return value;
+ }
+
+ function owner(id: string, pid: string): session.Session {
+ return {
+ sessionId: id,
+ host: 'external-host',
+ pid,
+ rVer: 'R version 4.6.0 (2026-04-24)',
+ processExited: false,
+ } as session.Session;
+ }
+
+ function focus(source: session.Session): void {
+ sandbox.stub(session, 'activeSession').value(source);
+ }
+
+ function processExits() {
+ const exited = new Set();
+ const listeners = new Map void>>();
+ sandbox.stub(session, 'getViewerSessionContext').callsFake((_id, source) => {
+ if (!source) {
+ return undefined;
+ }
+ const key = sessionProcessIdentity(source);
+ let callbacks = listeners.get(key);
+ if (!callbacks) {
+ callbacks = new Set();
+ listeners.set(key, callbacks);
+ }
+ const observers = callbacks;
+ return {
+ source,
+ sessionId: source.sessionId,
+ get hasExited() {
+ return exited.has(key);
+ },
+ observeExit: (callback) => {
+ observers.add(callback);
+ return { dispose: () => observers.delete(callback) };
+ },
+ attach: () => {},
+ getHtml: () => '',
+ };
+ });
+ return {
+ exit(source: ViewerSessionSource) {
+ const key = sessionProcessIdentity(source);
+ exited.add(key);
+ for (const callback of listeners.get(key) ?? []) {
+ callback();
+ }
+ },
+ listeners,
+ };
+ }
+
+ for (const backend of ['jgd', 'httpgd', 'standard'] as const) {
+ for (const closeFirst of [false, true]) {
+ test(`${backend} deletes history and saved state without altering the rendered document on R exit with closeFirst=${closeFirst}`, async () => {
+ const exits = processExits();
+ const clock = sandbox.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ const value = manager();
+ const source = owner('lifecycle', '123');
+ if (backend === 'jgd') {
+ value.jgdManager.history.addPlot('device', frame('device'));
+ value.jgdManager.history.setSessionSource('device', source);
+ value.jgdManager.showForSession(source);
+ } else if (backend === 'httpgd') {
+ await value.showHttpgdPlot('http://localhost:1234?token=secret', source);
+ value.httpgdManager.viewers[0].show();
+ } else {
+ await value.showStandardPlot(source);
+ }
+ const panel = panels[0].panel;
+ assert.ok(panel.webview.html.length > 0);
+ const rendered = panel.webview.html;
+ const close = sandbox.spy(panel, 'dispose');
+ if (closeFirst) {
+ panel.dispose();
+ }
+ await clock.tickAsync(250);
+ const captured: ViewerSessionSource = {
+ sessionId: source.sessionId,
+ host: source.host,
+ pid: source.pid,
+ rVer: source.rVer,
+ processExited: source.processExited,
+ };
+ // Detaching a Session clears transport metadata before its
+ // original process can exit. Cleanup must retain that identity.
+ source.pid = '';
+ source.rVer = '';
+ exits.exit(captured);
+ assert.strictEqual(value.viewers.length, 0, 'exit releases viewers immediately');
+ await clock.tickAsync(250);
+ assert.strictEqual(
+ close.callCount,
+ closeFirst ? 1 : 0,
+ "R exit must not close the user's viewer tab",
+ );
+ if (!closeFirst) {
+ assert.strictEqual(
+ panel.webview.html,
+ rendered,
+ 'the rendered document is unchanged',
+ );
+ }
+ if (backend === 'jgd') {
+ assert.deepStrictEqual(
+ (state.get('r.plot.jgdState') as PlotHistoryState).sessions,
+ [],
+ );
+ } else if (backend === 'httpgd') {
+ await value.httpgdManager.saveConnections();
+ assert.strictEqual(secrets.size, 0);
+ } else {
+ assert.deepStrictEqual(state.get('r.plot.standardSessions'), []);
+ }
+ assert.strictEqual(value.viewers.length, 0);
+ assert.strictEqual(exits.listeners.get(sessionProcessIdentity(captured))!.size, 0);
+ if (!closeFirst) {
+ panel.dispose();
+ }
+ await value.dispose();
+ const restored = manager();
+ assert.strictEqual(restored.viewers.length, 0);
+ assert.strictEqual(restored.jgdManager.history.sessionIds().length, 0);
+ });
+ }
+ }
+
+ test('all engines share one process-exit observer and release their backing data together', async () => {
+ const exits = processExits();
+ const value = manager();
+ const source = owner('shared-lifetime', '123');
+ await value.showStandardPlot(source);
+ await value.showHttpgdPlot('http://localhost:1234', source);
+ const httpgd = value.httpgdManager.viewers[0];
+ RefreshViewer.prototype.seedPlots.call(httpgd, [
+ { id: '1', data: '', width: 800, height: 600, zoom: 1 },
+ ]);
+ httpgd.activePlot = '1';
+ value.jgdManager.history.addPlot('device', frame('device'));
+ value.jgdManager.history.setSessionSource('device', source);
+ const jgd = value.jgdManager.getViewer('device')!;
+ const releaseHttpgd = sandbox.spy(httpgd, 'dispose');
+ const releaseJgd = sandbox.spy(jgd, 'dispose');
+ assert.strictEqual(exits.listeners.get(sessionProcessIdentity(source))!.size, 1);
+ exits.exit(source);
+ sinon.assert.calledOnce(releaseHttpgd);
+ sinon.assert.calledOnce(releaseJgd);
+ assert.deepStrictEqual(httpgd.plots, []);
+ assert.strictEqual(httpgd.activePlot, undefined);
+ assert.deepStrictEqual(value.jgdManager.history.sessionIds(), []);
+ assert.deepStrictEqual(value.viewers, []);
+ assert.strictEqual(exits.listeners.get(sessionProcessIdentity(source))!.size, 0);
+ });
+
+ for (const closeFirst of [false, true]) {
+ test(`JGD clears exited session history with viewer ${closeFirst ? 'closed' : 'open'}`, async () => {
+ const exits = processExits();
+ const clock = sandbox.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ const value = manager();
+ const disconnect = sandbox.spy(value.jgdManager.server, 'disconnect');
+ const source = owner('dead', '123');
+ const live = owner('live', '456');
+ for (const [id, owner] of [
+ ['a', source],
+ ['b', source],
+ ['c', live],
+ ] as const) {
+ value.jgdManager.history.addPlot(id, frame(id));
+ value.jgdManager.history.setSessionSource(id, owner);
+ }
+ value.jgdManager.showForSession(source);
+ const panel = panels[0].panel;
+ if (closeFirst) {
+ panel.dispose();
+ }
+ await clock.tickAsync(250);
+ exits.exit(source);
+ assert.deepStrictEqual(
+ disconnect.getCalls().map((call) => call.args[0]),
+ ['a', 'b'],
+ );
+ assert.strictEqual(value.jgdManager.history.count('a'), 0);
+ assert.strictEqual(value.jgdManager.history.count('b'), 0);
+ assert.strictEqual(value.jgdManager.showForSession(source), false);
+ await clock.tickAsync(250);
+ const saved = state.get('r.plot.jgdState') as PlotHistoryState;
+ assert.deepStrictEqual(
+ saved.sessions.map((entry) => entry.id),
+ ['c'],
+ );
+ assert.deepStrictEqual(value.jgdManager.history.sessionIds(), ['c']);
+ assert.strictEqual(exits.listeners.get(sessionProcessIdentity(source))!.size, 0);
+ await value.dispose();
+ assert.deepStrictEqual(manager().jgdManager.history.sessionIds(), ['c']);
+ });
+ }
+
+ test('JGD watches restored closed viewers and preserves temporary disconnections', async () => {
+ const exits = processExits();
+ const source = owner('saved', '123');
+ const first = manager();
+ first.jgdManager.history.addPlot('device', frame('device'));
+ first.jgdManager.history.setSessionSource('device', source);
+ await first.dispose();
+ const restored = manager();
+ assert.strictEqual(restored.jgdManager.history.count('device'), 1);
+ assert.strictEqual(restored.jgdManager.getViewers().length, 0);
+ assert.strictEqual(exits.listeners.get(sessionProcessIdentity(source))!.size, 1);
+ // Disconnection is not an exit; only the authoritative exit observer clears history.
+ assert.strictEqual(restored.jgdManager.server.isConnected('device'), false);
+ exits.exit(source);
+ assert.deepStrictEqual(restored.jgdManager.history.sessionIds(), []);
+ await restored.dispose();
+ assert.deepStrictEqual((state.get('r.plot.jgdState') as PlotHistoryState).sessions, []);
+ });
+
+ test('JGD corrects a saved checkpoint when exit was already confirmed before restoration', async () => {
+ const exits = processExits();
+ const source = owner('saved', '123');
+ const first = manager();
+ first.jgdManager.history.addPlot('device', frame('device'));
+ first.jgdManager.history.setSessionSource('device', source);
+ await first.dispose();
+ exits.exit(source);
+ const restored = manager();
+ assert.deepStrictEqual(restored.jgdManager.history.sessionIds(), []);
+ await restored.dispose();
+ assert.deepStrictEqual((state.get('r.plot.jgdState') as PlotHistoryState).sessions, []);
+ });
+
+ test('JGD exit during a checkpoint removes stale saved frames after the write completes', async () => {
+ const exits = processExits();
+ const clock = sandbox.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ const gate = deferred();
+ let writes = 0;
+ (extensionContext.workspaceState.update as sinon.SinonStub).callsFake(
+ async (key: string, data: unknown) => {
+ if (key === 'r.plot.jgdState' && ++writes === 1) {
+ await gate.promise;
+ }
+ state.set(key, structuredClone(data));
+ },
+ );
+ const value = manager();
+ const source = owner('pending-exit', '123');
+ value.jgdManager.history.addPlot('device', frame('device'));
+ value.jgdManager.history.setSessionSource('device', source);
+ await clock.tickAsync(250);
+ assert.strictEqual(writes, 1);
+ exits.exit(source);
+ gate.resolve();
+ await value.dispose();
+ assert.deepStrictEqual((state.get('r.plot.jgdState') as PlotHistoryState).sessions, []);
+ });
+
+ test('httpgd process exit clears history, connections and saved credentials without affecting other owners', async () => {
+ const exits = processExits();
+ const source = owner('httpgd-owner', '14001');
+ const replacement = owner(source.sessionId, '14002');
+ const value = manager();
+ await value.showHttpgdPlot('http://localhost:1234?token=old-1', source);
+ await value.showHttpgdPlot('http://localhost:1235?token=old-2', source);
+ const old = [...value.httpgdManager.viewers];
+ old[0].show();
+ const panel = old[0].webviewPanel;
+ const rendered = panel!.webview.html;
+ const close = sandbox.spy(panel!, 'dispose');
+ const disconnects = old.map((viewer) => sandbox.spy(viewer.api, 'disconnect'));
+ await value.showHttpgdPlot('http://localhost:1236?token=replacement', replacement);
+ await value.httpgdManager.showViewer('http://localhost:1237?token=unowned');
+ exits.exit(source);
+ await value.httpgdManager.saveConnections();
+ for (const disconnect of disconnects) {
+ sinon.assert.calledOnce(disconnect);
+ }
+ sinon.assert.notCalled(close);
+ assert.strictEqual(panel!.webview.html, rendered);
+ assert.strictEqual(old[0].webviewPanel, undefined);
+ assert.deepStrictEqual(old[0].plots, []);
+ assert.deepStrictEqual(old[0].api.getPlots(), []);
+ assert.strictEqual(value.httpgdManager.viewers.length, 2);
+ assert.ok(
+ old.every((viewer) => !value.httpgdManager.recentlyActiveViewers.includes(viewer)),
+ );
+ const saved = JSON.parse([...secrets.values()][0]) as Array<{
+ source?: ViewerSessionSource;
+ }>;
+ assert.strictEqual(saved.length, 2);
+ assert.ok(saved.some((connection) => connection.source?.pid === replacement.pid));
+ assert.ok(saved.some((connection) => !connection.source));
+ await value.dispose();
+ const restored = manager();
+ assert.strictEqual(await restored.httpgdManager.restoreConnection(source), undefined);
+ assert.ok(await restored.httpgdManager.restoreConnection(replacement));
+ });
+
+ test('httpgd saved connections are cleaned on exit even without reopening a viewer', async () => {
+ const exits = processExits();
+ const source = owner('httpgd-owner', '14001');
+ const first = manager();
+ await first.showHttpgdPlot('http://localhost:1234?token=secret', source);
+ await first.dispose();
+ const restored = manager();
+ await restored.httpgdManager.saveConnections();
+ assert.strictEqual(restored.httpgdManager.viewers.length, 0);
+ assert.strictEqual(secrets.size, 1, 'reload preserves the live session');
+ connect.resetHistory();
+ exits.exit(source);
+ await waitForValue(() =>
+ secrets.size === 0 && !state.get('r.plot.httpgdConnectionsKey') ? true : undefined,
+ );
+ await restored.httpgdManager.saveConnections();
+ assert.strictEqual(secrets.size, 0);
+ assert.strictEqual(state.get('r.plot.httpgdConnectionsKey'), undefined);
+ assert.strictEqual(exits.listeners.get(sessionProcessIdentity(source))?.size, 0);
+ assert.strictEqual(await restored.httpgdManager.restoreConnection(source), undefined);
+ sinon.assert.notCalled(connect);
+ });
+
+ test('httpgd exit during credential loading prevents a pending restore from reconnecting', async () => {
+ const exits = processExits();
+ const source = owner('httpgd-owner', '14001');
+ const first = manager();
+ await first.showHttpgdPlot('http://localhost:1234?token=secret', source);
+ await first.dispose();
+ const saved = [...secrets.values()][0];
+ let load!: (value: string) => void;
+ (extensionContext.secrets.get as sinon.SinonStub).returns(
+ new Promise((resolve) => {
+ load = resolve;
+ }),
+ );
+ const restored = manager();
+ const pending = restored.httpgdManager.restoreConnection(source);
+ exits.exit(source);
+ connect.resetHistory();
+ load(saved);
+ assert.strictEqual(await pending, undefined);
+ await restored.httpgdManager.saveConnections();
+ assert.strictEqual(secrets.size, 0);
+ assert.strictEqual(state.get('r.plot.httpgdConnectionsKey'), undefined);
+ sinon.assert.notCalled(connect);
+ });
+
+ test('httpgd exit during a credential write removes that write after it completes', async () => {
+ const exits = processExits();
+ const source = owner('httpgd-owner', '14001');
+ const value = manager();
+ let stored!: () => void;
+ let started!: () => void;
+ const writing = new Promise((resolve) => {
+ started = resolve;
+ });
+ (extensionContext.secrets.store as sinon.SinonStub).onFirstCall().callsFake(
+ (key: string, data: string) =>
+ new Promise((resolve) => {
+ stored = () => {
+ secrets.set(key, data);
+ resolve();
+ };
+ started();
+ }),
+ );
+ const opening = value.showHttpgdPlot('http://localhost:1234?token=secret', source);
+ await writing;
+ exits.exit(source);
+ stored();
+ await opening;
+ await value.httpgdManager.saveConnections();
+ assert.strictEqual(secrets.size, 0);
+ assert.strictEqual(state.get('r.plot.httpgdConnectionsKey'), undefined);
+ assert.deepStrictEqual(value.httpgdManager.viewers, []);
+ });
+
+ for (const failure of ['read', 'json', 'shape'] as const) {
+ test(`httpgd ${failure} failure is reported and cannot erase saved credentials`, async () => {
+ const source = owner('httpgd-owner', '14001');
+ const key = 'saved-connections';
+ const saved = failure === 'json' ? '{"token":"must-not-be-reported"' : '{}';
+ state.set('r.plot.httpgdConnectionsKey', key);
+ secrets.set(key, saved);
+ if (failure === 'read') {
+ (extensionContext.secrets.get as sinon.SinonStub).rejects(new Error('read failed'));
+ }
+ const report = sandbox.stub(vscode.window, 'showErrorMessage').resolves(undefined);
+ sandbox.stub(console, 'warn');
+ const value = manager();
+ await assert.rejects(value.httpgdManager.restoreConnection(source), {
+ message: 'Could not load saved httpgd plot connections.',
+ });
+ sinon.assert.calledOnce(report);
+ assert.deepStrictEqual(report.firstCall.args, [
+ 'Could not load saved httpgd plot connections.',
+ ]);
+ await value.httpgdManager.saveConnections();
+ // A newly announced device still works, but must not overwrite
+ // credentials for other sessions that could not be read.
+ await value.showHttpgdPlot('http://localhost:1234?token=new-device', source);
+ assert.ok(await value.httpgdManager.restoreConnection(source));
+ await value.dispose();
+ assert.strictEqual(state.get('r.plot.httpgdConnectionsKey'), key);
+ assert.strictEqual(secrets.get(key), saved);
+ assert.strictEqual((extensionContext.secrets.store as sinon.SinonStub).callCount, 0);
+ assert.strictEqual((extensionContext.secrets.delete as sinon.SinonStub).callCount, 0);
+ });
+ }
+
+ test('a missing httpgd secret is empty storage and accepts a new connection', async () => {
+ const source = owner('httpgd-owner', '14001');
+ state.set('r.plot.httpgdConnectionsKey', 'missing-secret');
+ const report = sandbox.stub(vscode.window, 'showErrorMessage').resolves(undefined);
+ const value = manager();
+ assert.strictEqual(await value.httpgdManager.restoreConnection(source), undefined);
+ await value.showHttpgdPlot('http://localhost:1234?token=new-device', source);
+ assert.ok(secrets.get('missing-secret')?.includes('new-device'));
+ sinon.assert.notCalled(report);
+ });
+
+ test('httpgd already exited owners cannot register a new connection', async () => {
+ const exits = processExits();
+ const source = owner('httpgd-owner', '14001');
+ exits.exit(source);
+ const value = manager();
+ await value.showHttpgdPlot('http://localhost:1234?token=secret', source);
+ await value.httpgdManager.saveConnections();
+ assert.deepStrictEqual(value.httpgdManager.viewers, []);
+ assert.strictEqual(secrets.size, 0);
+ sinon.assert.notCalled(connect);
+ });
+
+ test('all plot backends show the exact shared session indicator and retain it after reload', async () => {
+ const a = owner('indicator-a', '12101');
+ const b = owner('indicator-b', '12102');
+
+ sandbox.stub(session, 'sessionRequest').resolves({ data: 'plot', format: 'svg' });
+ sandbox
+ .stub(session, 'resolvePlotSession')
+ .callsFake((source) => (source.sessionId === a.sessionId ? a : b));
+ const first = manager();
+ for (const [index, source] of [a, b].entries()) {
+ await first.showStandardPlot(source);
+ await first.showHttpgdPlot(
+ `http://localhost:${1234 + index}/live?token=secret`,
+ source,
+ );
+ first.jgdManager.history.addPlot(source.sessionId, frame(source.sessionId));
+ first.jgdManager.history.setSessionSource(source.sessionId, source);
+ }
+ async function checkIndicators(value: CommonPlotManager) {
+ for (const source of [a, b]) {
+ await value.showStandardPlot(source);
+ (await value.httpgdManager.restoreConnection(source))!.show();
+ value.jgdManager.showForSession(source);
+ }
+ assert.strictEqual(panels.length, 6);
+ for (const source of [a, b]) {
+ const label = `R 4.6.0: ${source.pid}`;
+ const owned = panels.filter(({ panel }) =>
+ panel.webview.html.includes(`aria-label="${label}"`),
+ );
+ assert.strictEqual(owned.length, 3, 'each backend has its own session indicator');
+ for (const item of owned) {
+ assert.strictEqual(
+ item.panel.title,
+ item.panel.viewType === 'jgd.plotPane' ? 'R Plot (JGD)' : 'R Plot',
+ );
+ assert.ok(item.panel.webview.html.includes('class="viewer-session-tooltip"'));
+ assert.ok(item.panel.webview.html.includes('codicon.css'));
+ item.post.resetHistory();
+ await item.receive({ message: 'viewer-session/ready' });
+ sinon.assert.calledWithExactly(item.post, {
+ message: 'viewer-session/update',
+ text: label,
+ });
+ }
+ }
+ }
+ await checkIndicators(first);
+ for (const { panel } of panels) {
+ panel.dispose();
+ }
+ await first.dispose();
+ panels = [];
+ await checkIndicators(manager());
+ });
+
+ test('JGD binds live devices including late R attachments, but never guesses a restored owner', async () => {
+ const events = new vscode.EventEmitter();
+ sandbox.stub(session, 'onDidChangeSessionConnection').callsFake(events.event);
+ const a = owner('jgd-owner-a', '12111');
+ const b = owner('jgd-owner-b', '12112');
+ const resolve = sandbox.stub(session, 'resolveJgdSessionSource');
+ resolve.withArgs('r-12111-1').returns(a);
+ const value = manager();
+ const live = sandbox
+ .stub(value.jgdManager.server, 'isConnected')
+ .callsFake((id) => id !== 'restored');
+ const deliver = startJgd(value);
+ for (const [id, label] of [
+ ['a', 'r-12111-1'],
+ ['b', 'r-12112-1'],
+ ['restored', 'r-12113-1'],
+ ]) {
+ value.jgdManager.history.addPlot(id, frame(id));
+ value.jgdManager.history.setSessionLabel(id, label);
+ deliver(id, { type: 'frame' });
+ }
+ assert.ok(panels[0].panel.webview.html.includes('R 4.6.0: 12111'));
+ assert.ok(!panels[1].panel.webview.html.includes('class="viewer-session"'));
+ resolve.withArgs('r-12112-1').returns(b);
+ events.fire({
+ kind: 'connected',
+ session: { sessionId: b.sessionId, connectionId: 'late' },
+ });
+ assert.ok(panels[1].panel.webview.html.includes('R 4.6.0: 12112'));
+ sinon.assert.neverCalledWith(resolve, 'r-12113-1');
+ assert.strictEqual(value.jgdManager.history.sessionSource('b')?.sessionId, b.sessionId);
+ live.returns(false);
+ value.jgdManager.getViewer('a')!.updateToolbar();
+ await panels[0].receive({ message: 'viewer-session/ready' });
+ sinon.assert.calledWith(panels[0].post, {
+ message: 'viewer-session/update',
+ text: 'R 4.6.0: 12111',
+ });
+ events.dispose();
+ });
+
+ test('owning process exit releases all engines without changing rendered documents or continuing process polling', async () => {
+ const clock = sandbox.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] });
+ const kill = sandbox.stub(process, 'kill').returns(true);
+ const source = owner('plot-exit', '12120');
+ source.host = os.hostname();
+ const value = manager();
+ await value.showStandardPlot(source);
+ await value.showHttpgdPlot('http://localhost:1234', source);
+ value.jgdManager.history.addPlot('device', frame('device'));
+ value.jgdManager.history.setSessionSource('device', source);
+ value.httpgdManager.viewers[0].show();
+ value.jgdManager.showForSession(source);
+ assert.strictEqual(panels.length, 3);
+ const rendered = panels.map(({ panel }) => panel.webview.html);
+ const closes = panels.map(({ panel }) => sandbox.spy(panel, 'dispose'));
+ kill.callsFake(() => {
+ throw Object.assign(new Error('gone'), { code: 'ESRCH' });
+ });
+ await clock.tickAsync(1000);
+ closes.forEach((close) => sinon.assert.notCalled(close));
+ for (const [index, { panel }] of panels.entries()) {
+ assert.strictEqual(panel.webview.html, rendered[index]);
+ panel.dispose();
+ }
+ assert.deepStrictEqual(value.viewers, []);
+ kill.resetHistory();
+ await clock.tickAsync(2000);
+ sinon.assert.notCalled(kill);
+ });
+
+ test('httpgd gains the session indicator when an existing URL is attached to R', async () => {
+ const value = manager();
+ await value.showHttpgdPlot('http://localhost:1234');
+ value.httpgdManager.viewers[0].show();
+ assert.ok(!panels[0].panel.webview.html.includes('class="viewer-session"'));
+ await value.showHttpgdPlot('http://localhost:1234', owner('late-httpgd', '12130'));
+ assert.strictEqual(panels.length, 1);
+ assert.ok(panels[0].panel.webview.html.includes('R 4.6.0: 12130'));
+ await panels[0].receive({ message: 'viewer-session/ready' });
+ sinon.assert.calledWith(panels[0].post, {
+ message: 'viewer-session/update',
+ text: 'R 4.6.0: 12130',
+ });
+ });
+
+ test('JGD navigation checkpoints only cursors and restores them without rewriting frames', async () => {
+ const clock = sandbox.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ const first = manager();
+ const history = first.jgdManager.history;
+ history.addPlot('device', frame('device', 'first'));
+ history.addPlot('device', frame('device', 'second'));
+ await clock.tickAsync(250);
+ const snapshot = sandbox.spy(history, 'snapshot');
+ const update = (extensionContext.workspaceState as unknown as { update: sinon.SinonStub })
+ .update;
+ update.resetHistory();
+ history.navigateFirst('device');
+ await clock.tickAsync(250);
+ sinon.assert.notCalled(snapshot);
+ sinon.assert.neverCalledWith(update, 'r.plot.jgdState');
+ sinon.assert.calledWith(update, 'r.plot.jgdSelection');
+ assert.strictEqual(manager().jgdManager.history.currentPlot('device')?.device.bg, 'first');
+ await first.dispose();
+ sinon.assert.notCalled(snapshot);
+ sinon.assert.neverCalledWith(update, 'r.plot.jgdState');
+
+ // A crash between the content and cursor writes leaves mismatched IDs.
+ state.set('r.plot.jgdSelection', {
+ checkpointId: 'obsolete',
+ positions: [{ deviceId: 'device', currentIndex: 0 }],
+ });
+ assert.strictEqual(manager().jgdManager.history.currentPlot('device')?.device.bg, 'second');
+ });
+
+ test('JGD coalesces pending checkpoints without mutating an in-flight snapshot', async () => {
+ const clock = sandbox.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ const gate = deferred();
+ const writes: PlotHistoryState[] = [];
+ (extensionContext.workspaceState.update as sinon.SinonStub).callsFake(
+ async (key: string, value: unknown) => {
+ if (key === 'r.plot.jgdState') {
+ writes.push(value as PlotHistoryState);
+ if (writes.length === 1) {
+ await gate.promise;
+ }
+ }
+ state.set(key, structuredClone(value));
+ },
+ );
+ const first = manager();
+ const history = first.jgdManager.history;
+ history.addPlot('device', frame('device', 'first'));
+ await clock.tickAsync(250);
+ for (let i = 0; i < 3; i++) {
+ history.appendOps('device', {
+ ...frame('device'),
+ ops: [{ op: 'text', str: String(i) }],
+ });
+ await clock.tickAsync(250);
+ }
+ assert.strictEqual(writes.length, 1, 'do not queue full snapshots behind a slow write');
+ assert.deepStrictEqual(
+ writes[0].sessions[0].plots[0].ops,
+ [],
+ 'live drawing must not change the pending snapshot',
+ );
+ gate.resolve();
+ await first.dispose();
+ assert.strictEqual(writes.length, 2);
+ assert.strictEqual(manager().jgdManager.history.currentPlot('device')?.ops.length, 3);
+ });
+
+ test('JGD checkpoints a reduced history limit before saving new cursor positions', async () => {
+ const clock = sandbox.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ const first = manager();
+ for (const bg of ['first', 'second', 'third']) {
+ first.jgdManager.history.addPlot('device', frame('device', bg));
+ }
+ await first.dispose();
+ (util.config as sinon.SinonStub).returns({
+ get: (key: string, fallback: unknown) =>
+ key === 'plot.jgd.historyLimit' ? 2 : fallback,
+ });
+ const restored = manager();
+ assert.strictEqual(restored.jgdManager.history.count('device'), 2);
+ restored.jgdManager.history.navigateFirst('device');
+ await clock.tickAsync(250);
+ assert.strictEqual(manager().jgdManager.history.currentPlot('device')?.device.bg, 'second');
+ });
+
+ test('all backends checkpoint restoration state before shutdown', async () => {
+ const source = owner('checkpoint', '12150');
+ sandbox.stub(session, 'sessionRequest').resolves({ data: 'live', format: 'svg' });
+ sandbox.stub(session, 'resolvePlotSession').returns(source);
+ const first = manager();
+ await first.showStandardPlot(source);
+ await first.showHttpgdPlot('http://localhost:1234?token=checkpoint', source);
+ first.jgdManager.history.addPlot('device', frame('device'));
+ first.jgdManager.history.setSessionSource('device', source);
+ await waitForValue(() => (state.has('r.plot.jgdState') ? true : undefined));
+ assert.ok(state.has('r.plot.standardSessions'));
+ assert.ok(state.has('r.plot.httpgdConnectionsKey'));
+ for (const { panel } of panels) {
+ panel.dispose();
+ }
+ panels = [];
+ const restored = manager();
+ // Deliberately do not call first.dispose(): the old extension host may
+ // stop before its shutdown hook can write through VS Code's storage bridge.
+ restored.jgdManager.showForSession(source);
+ (await restored.httpgdManager.restoreConnection(source))!.show();
+ await restored.showStandardPlot(source);
+ assert.strictEqual(panels.length, 3);
+ assert.strictEqual(restored.jgdManager.history.count('device'), 1);
+ assert.strictEqual(restored.httpgdManager.viewers[0].token, 'checkpoint');
+ });
+
+ test('Show Viewers requests the standard plot from its original attached session after reload', async () => {
+ const first = manager();
+ const owner = {
+ sessionId: 'a',
+ host: 'host',
+ pid: '123',
+ rVer: '4.6.0',
+ processExited: false,
+ } as session.Session;
+ const request = sandbox
+ .stub(session, 'sessionRequest')
+ .resolves({ data: 'original', format: 'svg' });
+ focus(owner);
+ const resolve = sandbox.stub(session, 'resolvePlotSession').returns(owner);
+ await first.showStandardPlot(owner);
+ await panels[0].receive({ type: 'ready' });
+ await first.dispose();
+ assert.ok(
+ !JSON.stringify([...state.values()]).includes('original'),
+ 'standard images are not persisted',
+ );
+ panels = [];
+ request.resetHistory();
+ request.resolves({ data: 'fresh-from-R', format: 'svg' });
+ resolve.resetHistory();
+ manager();
+ assert.strictEqual(panels.length, 0);
+ await callbacks.get('r.plot.showViewers')!();
+ sinon.assert.calledOnce(resolve);
+ await panels[0].receive({ type: 'ready' });
+ assert.strictEqual(request.lastCall.args[1], owner);
+ sinon.assert.calledWith(panels[0].post, {
+ type: 'update',
+ data: 'fresh-from-R',
+ format: 'svg',
+ });
+ request.resetHistory();
+ resolve.resetHistory();
+ await callbacks.get('r.plot.showViewers')!();
+ sinon.assert.calledOnce(request);
+ assert.strictEqual(request.firstCall.args[1], owner);
+ assert.strictEqual(panels.length, 1);
+ request.resetHistory();
+ const reattached = {
+ sessionId: owner.sessionId,
+ host: owner.host,
+ pid: owner.pid,
+ rVer: owner.rVer,
+ processExited: false,
+ } as session.Session;
+ resolve.returns(reattached);
+ panels[0].panel.dispose();
+ await callbacks.get('r.plot.showViewers')!();
+ await panels[1].receive({ type: 'ready' });
+ sinon.assert.calledOnce(request);
+ assert.strictEqual(request.lastCall.args[1], reattached);
+ });
+
+ function startJgd(value: CommonPlotManager) {
+ (JgdManager.prototype.start as sinon.SinonStub).callThrough();
+ sandbox.stub(value.jgdManager.server, 'start');
+ const onFrame = sandbox.stub(value.jgdManager.server, 'setOnFrame');
+ value.jgdManager.start();
+ return onFrame.firstCall.args[0] as (id: string, message: JgdMessage) => void;
+ }
+
+ function frame(sessionId: string, bg = 'white'): PlotFrame {
+ return {
+ version: 1,
+ sessionId,
+ device: { width: 400, height: 300, dpi: 96, bg },
+ ops: [],
+ };
+ }
+
+ test('Show Viewer opens only the focused session and never ownerless or empty JGD viewers', async () => {
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ const active = sandbox.stub(session, 'activeSession').value(a);
+ const resolve = sandbox
+ .stub(session, 'resolvePlotSession')
+ .callsFake((source) => source as session.Session);
+ const value = manager();
+ const metrics = sandbox.spy(value.jgdManager.server, 'setMeasureText');
+ const deliver = startJgd(value);
+ await metrics.firstCall.args[0]({ type: 'metrics_request', id: 1 }, 96, 'temporary-socket');
+ assert.strictEqual(value.jgdManager.getViewers().length, 0);
+ for (const source of [a, b]) {
+ value.jgdManager.history.addPlot(source.sessionId, frame(source.sessionId));
+ value.jgdManager.history.setSessionSource(source.sessionId, source);
+ deliver(source.sessionId, { type: 'frame' });
+ }
+ value.jgdManager.history.addPlot('unknown', frame('unknown'));
+ value.jgdManager.history.addPlot('empty', frame('empty'));
+ value.jgdManager.history.clear('empty');
+ value.jgdManager.history.setSessionSource('empty', a);
+ for (const { panel } of panels) {
+ panel.dispose();
+ }
+ panels = [];
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ assert.ok(panels[0].panel.webview.html.includes('R 4.6.0: 123'));
+ sinon.assert.calledOnceWithExactly(resolve, a);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ active.value(b);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 2);
+ assert.ok(panels[1].panel.webview.html.includes('R 4.6.0: 456'));
+ active.value(undefined);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 2);
+ });
+
+ test('a missing saved JGD device does not select another session during restore', async () => {
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ focus(a);
+ sandbox.stub(session, 'resolvePlotSession').returns(a);
+ const first = manager();
+ for (const source of [a, b]) {
+ first.jgdManager.history.addPlot(source.sessionId, frame(source.sessionId));
+ first.jgdManager.history.setSessionSource(source.sessionId, source);
+ }
+ await first.dispose();
+ const saved = state.get('r.plot.jgdState') as PlotHistoryState;
+ saved.activeSessionId = 'missing-device';
+ const restored = manager();
+ assert.strictEqual(restored.jgdManager.history.getActiveSessionId(), '');
+ assert.strictEqual(restored.jgdManager.getViewer(), null);
+ assert.strictEqual(panels.length, 0);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ assert.ok(panels[0].panel.webview.html.includes('R 4.6.0: 123'));
+ assert.strictEqual(restored.jgdManager.history.count('b'), 1);
+ });
+
+ for (const backend of ['httpgd', 'jgd', 'standard'] as const) {
+ test(`${backend} recovers the active session across reloads without focusing its terminal`, async () => {
+ const source = owner('attached', '123');
+ focus(source);
+ sandbox.stub(session, 'resolvePlotSession').returns(source);
+ sandbox.stub(session, 'sessionRequest').resolves({ data: 'plot', format: 'svg' });
+ const showTerminal = sandbox.stub();
+ const unrelatedTerminal = { show: showTerminal } as unknown as vscode.Terminal;
+ sandbox.stub(vscode.window, 'activeTerminal').value(unrelatedTerminal);
+ let value = manager();
+ if (backend === 'httpgd') {
+ await value.showHttpgdPlot('http://localhost:1234/live?token=secret', source);
+ } else if (backend === 'jgd') {
+ value.jgdManager.history.addPlot('device', frame('device'));
+ value.jgdManager.history.setSessionSource('device', source);
+ } else {
+ await value.showStandardPlot(source);
+ }
+ for (let reload = 0; reload < 4; reload++) {
+ await value.dispose();
+ panels = [];
+ value = manager();
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1, `viewer recovered after reload ${reload}`);
+ assert.ok(panels[0].panel.webview.html.includes('R 4.6.0: 123'));
+ assert.strictEqual(session.activeSession, source);
+ sinon.assert.notCalled(showTerminal);
+ }
+ });
+ }
+
+ test('multiple JGD devices in one R session reuse one viewer', async () => {
+ const source = owner('a', '123');
+ focus(source);
+ sandbox.stub(session, 'resolvePlotSession').returns(source);
+ const value = manager();
+ const deliver = startJgd(value);
+ for (const id of ['device-1', 'device-2', 'device-1']) {
+ value.jgdManager.history.addPlot(id, frame(id));
+ value.jgdManager.history.setSessionSource(id, source);
+ deliver(id, { type: 'frame' });
+ }
+ assert.strictEqual(panels.length, 1);
+ assert.strictEqual(value.jgdManager.getViewers().length, 1);
+ assert.strictEqual(value.jgdManager.getViewers()[0].sessionId, 'device-1');
+ panels[0].panel.dispose();
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 2, 'one replacement tab after closing');
+ });
+
+ test('an explicit device joins the session history and gets the existing panel dimensions', async () => {
+ const value = manager();
+ const deliver = startJgd(value);
+ const history = value.jgdManager.history;
+ const source = owner('a', '123');
+ const resize = sandbox.stub(value.jgdManager.server, 'handleResize');
+ sandbox.stub(value.jgdManager.server, 'isConnected').returns(true);
+ sandbox
+ .stub(session, 'resolveJgdSessionSource')
+ .callsFake((label) => (label === 'r-123-2' ? source : undefined));
+ history.addPlot('managed', frame('managed', 'first'));
+ history.setSessionSource('managed', source);
+ deliver('managed', { type: 'frame' });
+ await panels[0].receive({ type: 'resize', width: 900, height: 700 });
+ resize.resetHistory();
+ history.addPlot('explicit', frame('explicit', 'second'));
+ history.setSessionLabel('explicit', 'r-123-2');
+ deliver('explicit', { type: 'frame', newPage: true });
+ assert.strictEqual(panels.length, 1);
+ assert.strictEqual(history.count('managed'), 2);
+ sinon.assert.calledOnceWithExactly(resize, 900, 700, 'explicit');
+ sinon.assert.calledWith(panels[0].post, { type: 'toolbar', current: 2, total: 2 });
+ const viewer = value.jgdManager.getViewers()[0];
+ await viewer.handleCommand('prevPlot');
+ assert.strictEqual(history.currentPlot('explicit')?.device.bg, 'first');
+ history.replaceLatest('explicit', frame('explicit', 'second resized'));
+ deliver('explicit', { type: 'frame', resizeReplay: true });
+ assert.strictEqual(history.currentPlot('explicit')?.device.bg, 'first');
+ await viewer.handleCommand('nextPlot');
+ assert.strictEqual(history.currentPlot('managed')?.device.bg, 'second resized');
+ });
+
+ test('JGD measures an earlier device through its session viewer without switching plots', async () => {
+ const value = manager();
+ const metrics = sandbox.spy(value.jgdManager.server, 'setMeasureText');
+ const deliver = startJgd(value);
+ const source = owner('a', '123');
+ for (const id of ['device-1', 'device-2', 'other-session']) {
+ value.jgdManager.history.addPlot(id, frame(id));
+ value.jgdManager.history.setSessionSource(
+ id,
+ id === 'other-session' ? owner('b', '456') : source,
+ );
+ deliver(id, { type: 'frame' });
+ }
+ const viewer = value.jgdManager.getViewers()[0];
+ const selectedPlot = value.jgdManager.history.currentPlot(viewer.sessionId);
+ for (const item of panels) {
+ item.post.resetHistory();
+ }
+ const measure = metrics.firstCall.args[0];
+ const measured = measure(
+ { type: 'metrics_request', id: 7, kind: 'strWidth', str: 'W' },
+ 96,
+ 'device-1',
+ );
+ sinon.assert.calledOnce(panels[0].post);
+ sinon.assert.notCalled(panels[1].post);
+ const request = panels[0].post.lastCall.args[0] as { type: string; id: number };
+ assert.strictEqual(request.type, 'metrics_request');
+ await panels[0].receive({
+ type: 'metrics_response',
+ id: request.id,
+ originalId: 7,
+ width: 42,
+ ascent: 10,
+ descent: 3,
+ });
+ assert.deepStrictEqual(await measured, {
+ type: 'metrics_response',
+ id: 7,
+ width: 42,
+ ascent: 10,
+ descent: 3,
+ });
+ assert.strictEqual(viewer.sessionId, 'device-2');
+ assert.strictEqual(value.jgdManager.history.currentPlot(viewer.sessionId), selectedPlot);
+ assert.strictEqual(panels.length, 2);
+
+ panels[0].panel.dispose();
+ assert.deepStrictEqual(await measure({ type: 'metrics_request', id: 8 }, 96, 'device-1'), {
+ type: 'metrics_response',
+ id: 8,
+ width: 0,
+ ascent: 0,
+ descent: 0,
+ });
+ assert.strictEqual(panels.length, 2, 'metrics must not reopen a closed viewer');
+ });
+
+ test('JGD reattachment after reload keeps closed viewers closed until Show Viewer or a new plot', async () => {
+ const source = owner('a', '123');
+ focus(source);
+ sandbox.stub(session, 'resolvePlotSession').returns(source);
+ const first = manager();
+ const deliver = startJgd(first);
+ first.jgdManager.history.addPlot('device', frame('device'));
+ first.jgdManager.history.setSessionSource('device', source);
+ deliver('device', { type: 'frame' });
+ panels[0].panel.dispose();
+ await first.dispose();
+ (JgdManager.prototype.start as sinon.SinonStub).resetBehavior();
+ panels = [];
+ const restored = manager();
+ const replay = startJgd(restored);
+ replay('device', { type: 'frame', ext: { vscodeR: { restoring: true } } });
+ replay('device', { type: 'frame', resizeReplay: true });
+ assert.strictEqual(panels.length, 0);
+ assert.strictEqual(restored.jgdManager.history.count('device'), 1);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ panels[0].panel.dispose();
+ replay('device', { type: 'frame', ext: { vscodeR: { restoring: true } } });
+ assert.strictEqual(panels.length, 1);
+ restored.jgdManager.history.addPlot('device', frame('device', 'new'));
+ replay('device', { type: 'frame' });
+ assert.strictEqual(panels.length, 2);
+ });
+
+ test('httpgd restoration connects only the focused session', async () => {
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ focus(a);
+ sandbox.stub(session, 'resolvePlotSession').returns(a);
+ const first = manager();
+ await first.showHttpgdPlot('http://localhost:1234?token=a', a);
+ await first.showHttpgdPlot('http://localhost:1235?token=b', b);
+ await first.dispose();
+ connect.resetHistory();
+ const restored = manager();
+ await callbacks.get('r.plot.showViewers')!();
+ sinon.assert.calledOnce(connect);
+ assert.strictEqual(restored.httpgdManager.viewers.length, 1);
+ assert.strictEqual(restored.httpgdManager.viewers[0].connection.source?.sessionId, 'a');
+ assert.strictEqual(panels.length, 1);
+ });
+
+ test('httpgd reattachment and existing plot updates keep closed panels closed', async () => {
+ const source = owner('a', '123');
+ const value = manager();
+ const viewer = new RefreshViewer('http://localhost:1234', {
+ ...value.httpgdManager.viewerOptions,
+ source,
+ restoring: true,
+ });
+ value.httpgdManager.registerViewer(viewer);
+ sandbox.stub(viewer.api, 'getPlotText').resolves('');
+ await viewer.receivePlots(['1']);
+ assert.strictEqual(panels.length, 0);
+ await viewer.receivePlots(['1']);
+ assert.strictEqual(panels.length, 0);
+ viewer.show();
+ assert.strictEqual(panels.length, 1);
+ panels[0].panel.dispose();
+ await value.showHttpgdPlot('http://localhost:1234', source, true);
+ await viewer.receivePlots(['1']);
+ assert.strictEqual(panels.length, 1);
+ await viewer.receivePlots(['1', '2']);
+ assert.strictEqual(panels.length, 2, 'a new plot opens one replacement panel');
+ });
+
+ test('httpgd devices reuse one session viewer and preserve its panel and settings', async () => {
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ focus(a);
+ sandbox.stub(session, 'resolvePlotSession').returns(a);
+ const value = manager();
+ await value.showHttpgdPlot('http://localhost:1234', a);
+ const first = value.httpgdManager.viewers[0];
+ first.show();
+ const panel = first.webviewPanel;
+ first.zoom = 2;
+ first.togglePreviewPlots('hidden');
+ await value.showHttpgdPlot('http://localhost:1235', b);
+ const other = value.httpgdManager.viewers[0];
+ other.show();
+ await value.showHttpgdPlot('http://localhost:1236', a);
+ assert.strictEqual(value.httpgdManager.viewers.length, 2);
+ assert.strictEqual(first.connections.length, 2);
+ assert.strictEqual(first.webviewPanel, panel);
+ assert.strictEqual(first.zoom, 2);
+ assert.strictEqual(first.previewPlotLayout, 'hidden');
+ assert.ok(other.webviewPanel);
+ panel!.dispose();
+ const count = panels.length;
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, count + 1);
+ assert.ok(first.webviewPanel);
+ assert.strictEqual(first.connections.length, 2);
+ });
+
+ test('httpgd late ownership joins an existing session viewer without replacing its panel', async () => {
+ const source = owner('late-owner', '123');
+ const value = manager();
+ await value.showHttpgdPlot('http://localhost:1234', source);
+ const shared = value.httpgdManager.viewers[0];
+ shared.show();
+ const panel = shared.webviewPanel;
+ await value.showHttpgdPlot('http://localhost:1235');
+ const unowned = value.httpgdManager.viewers[0];
+ unowned.show();
+ await value.showHttpgdPlot('http://localhost:1235', source);
+ assert.deepStrictEqual(value.httpgdManager.viewers, [shared]);
+ assert.strictEqual(shared.webviewPanel, panel);
+ assert.strictEqual(shared.connections.length, 2);
+ assert.strictEqual(unowned.isDisposed, true);
+ assert.strictEqual(unowned.webviewPanel, undefined);
+ });
+
+ test('httpgd command routing survives port reuse by a different session', async () => {
+ const value = manager();
+ const source = owner('original', '123');
+ await value.showHttpgdPlot('http://localhost:1234', source);
+ const first = value.httpgdManager.viewers[0];
+ first.show();
+ await value.showHttpgdPlot('http://localhost:1235', source);
+ const panel = first.webviewPanel;
+ await value.showHttpgdPlot('http://localhost:1234', owner('replacement', '456'));
+ const replacement = value.httpgdManager.viewers[0];
+ assert.notStrictEqual(replacement, first);
+ assert.strictEqual(first.webviewPanel, panel);
+ assert.strictEqual(first.connections.length, 1);
+ const originalCommand = sandbox.stub(first, 'handleCommand');
+ const replacementCommand = sandbox.stub(replacement, 'handleCommand');
+ await callbacks.get('r.plot.hidePlot')!(first.id, 'plot');
+ sinon.assert.calledOnceWithExactly(originalCommand, 'hidePlot', 'plot');
+ sinon.assert.notCalled(replacementCommand);
+ await callbacks.get('r.plot.hidePlot')!('localhost:1234', 'replacement-plot');
+ sinon.assert.calledOnceWithExactly(replacementCommand, 'hidePlot', 'replacement-plot');
+ });
+
+ test('httpgd reuses inactive geometry and applies its latest size once reactivated', async () => {
+ const value = manager();
+ const viewer = new RefreshViewer(
+ 'http://localhost:1234',
+ value.httpgdManager.viewerOptions,
+ );
+ value.httpgdManager.registerViewer(viewer);
+ const active = sandbox.stub(viewer.api, 'isActive').returns(false);
+ const render = sandbox.stub(viewer.api, 'getPlotText').resolves('');
+ await viewer.receivePlots(['a'], new Set(['a']));
+ render.resolves('');
+ await viewer.receivePlots(['a'], new Set(['a']));
+ assert.strictEqual(viewer.plots[0].data, '');
+ sinon.assert.calledTwice(render);
+
+ viewer.viewWidth = 900;
+ await viewer.receivePlots(['a']);
+ assert.strictEqual(viewer.plots[0].width, 900);
+ sinon.assert.calledTwice(render);
+
+ viewer.viewWidth = 1000;
+ viewer.viewHeight = 700;
+ viewer.zoom = 1.2;
+ await viewer.receivePlots(['a']);
+ sinon.assert.calledTwice(render);
+
+ // dev.set() changes activity without changing the drawing's update ID.
+ active.returns(true);
+ await viewer.receivePlots(['a'], new Set());
+ sinon.assert.calledThrice(render);
+ assert.deepStrictEqual(render.lastCall.args, [
+ { id: 'a', width: 1000, height: 700, zoom: 1.2, renderer: 'svgp' },
+ ]);
+ await viewer.receivePlots(['a'], new Set());
+ sinon.assert.calledThrice(render);
+ active.returns(false);
+ await viewer.receivePlots(['a']);
+ active.returns(true);
+ await viewer.receivePlots(['a'], new Set());
+ sinon.assert.calledThrice(render);
+ });
+
+ test('httpgd defers background plot resizing until selected on its active device', async () => {
+ const value = manager();
+ const viewer = new RefreshViewer(
+ 'http://localhost:1234',
+ value.httpgdManager.viewerOptions,
+ );
+ value.httpgdManager.registerViewer(viewer);
+ const active = sandbox.stub(viewer.api, 'isActive').returns(false);
+ sandbox.stub(viewer.api, 'getPlots').returns([{ id: 'a' }, { id: 'b' }]);
+ const render = sandbox.stub(viewer.api, 'getPlotText').resolves('');
+ await viewer.receivePlots(['a', 'b'], new Set(['a', 'b']));
+ viewer.viewWidth = 1000;
+ await viewer.focusPlot('a');
+ await viewer.focusPlot('b');
+ render.resetHistory();
+
+ active.returns(true);
+ await viewer.receivePlots(['a', 'b'], new Set());
+ sinon.assert.calledOnce(render);
+ assert.strictEqual(render.firstCall.args[0].id, 'b');
+ // Both cache entries already have the current viewport dimensions.
+ // Focusing the other plot must still replay its deferred geometry.
+ await viewer.focusPlot('a');
+ sinon.assert.calledTwice(render);
+ assert.strictEqual(render.lastCall.args[0].id, 'a');
+ await viewer.focusPlot('a');
+ await viewer.receivePlots(['a', 'b'], new Set());
+ sinon.assert.calledTwice(render);
+ });
+
+ test('httpgd commits healthy devices when a closed device has an uncached plot', async () => {
+ const value = manager();
+ const viewer = new RefreshViewer(
+ 'http://localhost:1234',
+ value.httpgdManager.viewerOptions,
+ );
+ value.httpgdManager.registerViewer(viewer);
+ sandbox.stub(viewer.api, 'isActive').callsFake((id) => id.startsWith('b'));
+ const render = sandbox.stub(viewer.api, 'getPlotText').resolves('');
+ const error = sandbox.stub(vscode.window, 'showErrorMessage');
+ await viewer.receivePlots(['a1', 'b1'], new Set(['a1', 'b1']));
+ const retained = viewer.plots[0];
+ render.withArgs(sinon.match({ id: 'a2' })).rejects(new Error('device closed'));
+ await viewer.receivePlots(['a1', 'b1', 'a2', 'b2'], new Set(['a2', 'b2']));
+ assert.deepStrictEqual(
+ viewer.plots.map((plot) => plot.id),
+ ['a1', 'b1', 'b2'],
+ );
+ assert.strictEqual(viewer.plots[0], retained);
+ assert.strictEqual(viewer.activePlot, 'b2');
+ sinon.assert.calledOnce(error);
+
+ // Another device's notifications must not keep retrying the closed one.
+ await viewer.receivePlots(['a1', 'b1', 'a2', 'b2', 'b3'], new Set(['b3']));
+ assert.strictEqual(viewer.activePlot, 'b3');
+ sinon.assert.calledOnce(render.withArgs(sinon.match({ id: 'a2' })));
+ sinon.assert.calledOnce(error);
+
+ // An explicit refresh can recover a temporarily unavailable device.
+ render.withArgs(sinon.match({ id: 'a2' })).resolves('');
+ await viewer.receivePlots(['a1', 'b1', 'a2', 'b2', 'b3'], new Set(), true);
+ assert.ok(viewer.plots.some((plot) => plot.id === 'a2'));
+ });
+
+ test('httpgd keeps failed content invalidated until its device becomes active again', async () => {
+ const value = manager();
+ const viewer = new RefreshViewer(
+ 'http://localhost:1234',
+ value.httpgdManager.viewerOptions,
+ );
+ value.httpgdManager.registerViewer(viewer);
+ const active = sandbox.stub(viewer.api, 'isActive').returns(false);
+ const render = sandbox.stub(viewer.api, 'getPlotText').resolves('');
+ sandbox.stub(vscode.window, 'showErrorMessage');
+ await viewer.receivePlots(['a'], new Set(['a']));
+ render.rejects(new Error('temporarily unavailable'));
+ await viewer.receivePlots(['a'], new Set(['a']));
+ assert.strictEqual(viewer.plots[0].data, '');
+ await viewer.receivePlots(['a'], new Set());
+ sinon.assert.calledTwice(render);
+
+ active.returns(true);
+ render.resolves('');
+ await viewer.receivePlots(['a'], new Set());
+ assert.strictEqual(viewer.plots[0].data, '');
+ sinon.assert.calledThrice(render);
+ await viewer.receivePlots(['a'], new Set());
+ sinon.assert.calledThrice(render);
+ });
+
+ test('httpgd coalesces notifications arriving during a slow render without losing plots', async () => {
+ const value = manager();
+ const viewer = new RefreshViewer(
+ 'http://localhost:1234',
+ value.httpgdManager.viewerOptions,
+ );
+ value.httpgdManager.registerViewer(viewer);
+ const gate = deferred();
+ const render = sandbox.stub(viewer.api, 'getPlotText').resolves('');
+ render.onFirstCall().returns(gate.promise);
+ const first = viewer.receivePlots(['1']);
+ await Promise.resolve();
+ const second = viewer.receivePlots(['1', '2']);
+ const third = viewer.receivePlots(['1', '2', '3']);
+ sinon.assert.calledOnce(render);
+ gate.resolve('');
+ await Promise.all([first, second, third]);
+ assert.deepStrictEqual(
+ viewer.plots.map((plot) => plot.id),
+ ['1', '2', '3'],
+ );
+ assert.strictEqual(viewer.activePlot, '3');
+ assert.strictEqual(render.getCalls().filter((call) => call.args[0].id === '2').length, 1);
+ assert.strictEqual(render.getCalls().filter((call) => call.args[0].id === '3').length, 1);
+ });
+
+ async function startHttpgdR(context: Mocha.Context) {
+ try {
+ const probe = await promisify(execFile)('Rscript', [
+ '--vanilla',
+ '-e',
+ 'cat(requireNamespace("httpgd", quietly=TRUE) && requireNamespace("jsonlite", quietly=TRUE))',
+ ]);
+ if (probe.stdout.trim() !== 'TRUE') {
+ throw new Error('Live httpgd tests require httpgd and jsonlite');
+ }
+ } catch (error) {
+ if (process.env.VSCR_REQUIRE_PLOT_TESTS === '1') {
+ throw error;
+ }
+ context.skip();
+ }
+ const r = spawn('R', [
+ '--vanilla',
+ '--slave',
+ process.platform === 'win32' ? '--ess' : '--interactive',
+ ]);
+ const exited = new Promise((resolve) => r.once('exit', () => resolve()));
+ let output = '';
+ let errors = '';
+ r.stdout.on('data', (data: Buffer) => {
+ output += data.toString();
+ });
+ r.stderr.on('data', (data: Buffer) => {
+ errors += data.toString();
+ });
+ let sequence = 0;
+ const evaluate = async (code: string): Promise => {
+ const marker = `HTTPGD_RESULT_${++sequence}:`;
+ r.stdin.write(
+ `tryCatch({value <- {${code}}; cat(${JSON.stringify(marker)}, jsonlite::toJSON(value, auto_unbox=TRUE), "\\n", sep="")}, error=function(e) cat(${JSON.stringify(marker)}, jsonlite::toJSON(list(error=conditionMessage(e)), auto_unbox=TRUE), "\\n", sep=""))\n`,
+ );
+ const line = await waitForValue(() => {
+ if (r.exitCode !== null) {
+ throw new Error(`R exited: ${errors}`);
+ }
+ const start = output.indexOf(marker);
+ const end = output.indexOf('\n', start);
+ return start >= 0 && end >= 0
+ ? output.slice(start + marker.length, end)
+ : undefined;
+ });
+ const result: unknown = JSON.parse(line);
+ assert.strictEqual(typeof result, 'string', line);
+ return result as string;
+ };
+ return {
+ r,
+ evaluate,
+ exited,
+ async dispose() {
+ if (r.exitCode === null && r.signalCode === null) {
+ r.kill();
+ }
+ await exited;
+ },
+ };
+ }
+
+ test('live httpgd dev.new shares navigation, resize, export, reload and exit cleanup', async function () {
+ this.timeout(30000);
+ connect.callThrough();
+ const process = await startHttpgdR(this);
+ const { r, evaluate, exited } = process;
+ const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'httpgd-session-'));
+ try {
+ const source = owner('live-httpgd', String(r.pid));
+ source.host = os.hostname();
+ focus(source);
+ sandbox.stub(session, 'resolvePlotSession').returns(source);
+ const first = manager();
+ const firstUrl = await evaluate(
+ 'options(device=function(...) httpgd::hgd(silent=TRUE)); plot(1:10, main="FIRST DEVICE"); first_device <- dev.cur(); httpgd::hgd_url()',
+ );
+ await first.showHttpgdPlot(firstUrl, source);
+ const viewer = first.httpgdManager.viewers[0];
+ await waitForValue(() => (viewer.plots.length === 1 ? true : undefined));
+ const panel = viewer.webviewPanel;
+ await evaluate('plot(1:100, main="SECOND SAME DEVICE"); "OK"');
+ await waitForValue(() => (viewer.plots.length === 2 ? true : undefined));
+ const toolbarUri = vscode.Uri.parse(
+ 'webview-panel:webview-panel/webview-RPlot-live-httpgd',
+ );
+ await callbacks.get('r.plot.prevPlot')!(toolbarUri, { groupId: 0 });
+ assert.strictEqual(viewer.activePlot, viewer.plots[0].id);
+ assert.ok(viewer.plots[0].data.includes('FIRST DEVICE'));
+ await callbacks.get('r.plot.nextPlot')!(toolbarUri, { groupId: 0 });
+ assert.strictEqual(viewer.activePlot, viewer.plots[1].id);
+ assert.ok(viewer.plots[1].data.includes('SECOND SAME DEVICE'));
+ await viewer.closePlot(viewer.plots[1].id);
+ await waitForValue(() => (viewer.plots.length === 1 ? true : undefined));
+ const secondUrl = await evaluate(
+ 'dev.new(); plot(1:100, main="SECOND DEVICE"); httpgd::hgd_url()',
+ );
+ await first.showHttpgdPlot(secondUrl, source);
+ await waitForValue(() => (viewer.plots.length === 2 ? true : undefined));
+ assert.strictEqual(first.httpgdManager.viewers.length, 1);
+ assert.strictEqual(viewer.webviewPanel, panel);
+ assert.ok(viewer.plots[0].data.includes('FIRST DEVICE'));
+ assert.ok(viewer.plots[1].data.includes('SECOND DEVICE'));
+ await viewer.prevPlot();
+ assert.strictEqual(viewer.activePlot, viewer.plots[0].id);
+ viewer.viewWidth = 920;
+ viewer.viewHeight = 680;
+ await viewer.focusPlot();
+ assert.strictEqual(viewer.plots[0].width, 920);
+ assert.ok(viewer.plots[0].data.includes('FIRST DEVICE'));
+ assert.ok(!viewer.plots[0].data.includes('width="920.00"'));
+ // Reactivation alone must apply the deferred size, without another
+ // resize event, new plot, or annotation to invalidate the drawing.
+ await evaluate('dev.set(first_device); "OK"');
+ await waitForValue(() =>
+ viewer.plots[0].data.includes('width="920.00"') ? true : undefined,
+ );
+ assert.ok(viewer.plots[0].data.includes('height="680.00"'));
+ assert.ok(viewer.plots[0].data.includes('FIRST DEVICE'));
+ const file = path.join(directory, 'first.svg');
+ await viewer.exportPlot(viewer.activePlot, 'svgp', file);
+ assert.ok((await fs.readFile(file, 'utf8')).includes('FIRST DEVICE'));
+ await evaluate('dev.set(first_device); plot(11:20, main="THIRD PLOT"); "OK"');
+ await waitForValue(() => (viewer.plots.length === 3 ? true : undefined));
+ assert.ok(viewer.plots[2].data.includes('THIRD PLOT'));
+ viewer.viewWidth = 960;
+ await viewer.focusPlot(viewer.plots[0].id);
+ assert.ok(viewer.plots[0].data.includes('width="960.00"'));
+ assert.ok(viewer.plots[0].data.includes('FIRST DEVICE'));
+ panel!.dispose();
+ const titles = (plots: HttpgdViewer['plots']) =>
+ plots.map((plot) => plot.data.match(/FIRST DEVICE|SECOND DEVICE|THIRD PLOT/)?.[0]);
+ const originalOrder = titles(viewer.plots);
+ await waitForValue(() => {
+ const key = state.get('r.plot.httpgdConnectionsKey') as string;
+ const saved = JSON.parse(secrets.get(key) ?? '[]') as typeof viewer.connections;
+ const order = saved.flatMap((connection) => connection.plotOrder ?? []);
+ return JSON.stringify(order) === JSON.stringify(viewer.api.plotOrder)
+ ? true
+ : undefined;
+ });
+ await first.dispose();
+ const restored = manager();
+ await callbacks.get('r.plot.showViewers')!();
+ const live = restored.httpgdManager.viewers[0];
+ await waitForValue(() => (live.plots.length === 3 ? true : undefined));
+ assert.deepStrictEqual(titles(live.plots), originalOrder);
+ assert.strictEqual(restored.httpgdManager.viewers.length, 1);
+ assert.strictEqual(live.connections.length, 2);
+ const second = live.plots.find((plot) => plot.data.includes('SECOND DEVICE'))!;
+ await live.closePlot(second.id);
+ await waitForValue(() => (live.api.getPlots().length === 2 ? true : undefined));
+ assert.strictEqual(live.plots.length, 2);
+ assert.ok(live.plots[0].data.includes('FIRST DEVICE'));
+ await evaluate('dev.off(first_device); "OK"');
+ live.viewWidth = 1010;
+ await live.focusPlot(live.plots[0].id);
+ assert.strictEqual(live.plots[0].width, 1010);
+ assert.ok(live.plots[0].data.includes('FIRST DEVICE'));
+ const retainedPanel = live.webviewPanel!;
+ const rendered = retainedPanel.webview.html;
+ const closed = sandbox.spy(retainedPanel, 'dispose');
+ await live.nextPlot(true);
+ r.kill();
+ await exited;
+ await waitForValue(() => (live.isDisposed ? true : undefined));
+ await restored.httpgdManager.saveConnections();
+ assert.strictEqual(secrets.size, 0);
+ sinon.assert.notCalled(closed);
+ assert.strictEqual(retainedPanel.webview.html, rendered);
+ assert.strictEqual(live.webviewPanel, undefined);
+ assert.strictEqual(live.plots.length, 0);
+ await callbacks.get('r.plot.firstPlot')!(live.id);
+ assert.strictEqual(live.activePlot, undefined, 'ended sessions have no navigation');
+ assert.strictEqual(live.plots.length, 0);
+ assert.strictEqual(live.api.getPlots().length, 0);
+ retainedPanel.dispose();
+ } finally {
+ await process.dispose();
+ await fs.rm(directory, { recursive: true, force: true });
+ }
+ });
+
+ test('live httpgd retains selection and navigation after every device closes', async function () {
+ this.timeout(30000);
+ connect.callThrough();
+ (vscode.window.createWebviewPanel as sinon.SinonStub).callsFake(
+ (...args: Parameters) => createRealWebviewPanel(...args),
+ );
+ const errors = sandbox.stub(vscode.window, 'showErrorMessage').resolves();
+ const process = await startHttpgdR(this);
+ await prepareEditorLayout();
+ const originalLayout = await executeRealCommand('vscode.getEditorLayout');
+ let viewer: HttpgdViewer | undefined;
+ const document = await vscode.workspace.openTextDocument({ language: 'plaintext' });
+ try {
+ await vscode.window.showTextDocument(document, { viewColumn: vscode.ViewColumn.One });
+ const layout = (width: number) =>
+ executeRealCommand('vscode.setEditorLayout', {
+ orientation: 0,
+ groups: [{ size: 1 - width }, { size: width }],
+ });
+ await layout(0.6);
+ const source = owner('live-httpgd-close', String(process.r.pid));
+ source.host = os.hostname();
+ const value = manager();
+ const first = await process.evaluate(
+ 'options(device=function(...) httpgd::hgd(silent=TRUE)); plot(1:5, main="FIRST DEVICE"); first_device <- dev.cur(); httpgd::hgd_url()',
+ );
+ await value.showHttpgdPlot(first, source);
+ viewer = value.httpgdManager.viewers[0];
+ await waitForValue(() => (viewer!.plots.length === 1 ? true : undefined));
+ viewer.show(false);
+ await waitForValue(() => (viewer!.plots[0].width !== 800 ? true : undefined));
+ const firstId = viewer.plots[0].id;
+ const second = await process.evaluate(
+ 'dev.new(); plot(5:1, main="SECOND DEVICE"); httpgd::hgd_url()',
+ );
+ await value.showHttpgdPlot(second, source);
+ await waitForValue(() => (viewer!.plots.length === 2 ? true : undefined));
+ assert.notStrictEqual(viewer.activePlot, firstId);
+ const secondId = viewer.activePlot;
+ const third = await process.evaluate(
+ 'dev.new(); plot(1:10, main="THIRD DEVICE"); httpgd::hgd_url()',
+ );
+ await value.showHttpgdPlot(third, source);
+ await waitForValue(() => (viewer!.plots.length === 3 ? true : undefined));
+ const thirdId = viewer.activePlot;
+ await process.evaluate('dev.off(first_device); "OK"');
+ assert.strictEqual(viewer.activePlot, thirdId);
+ await process.evaluate('dev.off(); "OK"');
+ assert.strictEqual(
+ viewer.activePlot,
+ thirdId,
+ 'closing a device preserves its rendered plot',
+ );
+ await process.evaluate('dev.off(); "OK"');
+ const render = sandbox.spy(viewer.api, 'getPlotText');
+ for (const width of [0.3, 0.5]) {
+ const before = viewer.viewWidth;
+ await layout(width);
+ await waitForValue(() => (viewer!.viewWidth !== before ? true : undefined));
+ await new Promise((resolve) => setTimeout(resolve, 200));
+ }
+ assert.ok(
+ render.callCount <= 1,
+ 'Only the first resize may discover the closed server',
+ );
+ sinon.assert.notCalled(errors);
+ assert.strictEqual(viewer.activePlot, thirdId);
+ await viewer.focusPlot(firstId);
+ assert.ok(
+ viewer.plots.find((plot) => plot.id === firstId)!.data.includes('FIRST DEVICE'),
+ );
+ await viewer.focusPlot(secondId);
+ assert.ok(
+ viewer.plots.find((plot) => plot.id === secondId)!.data.includes('SECOND DEVICE'),
+ );
+ assert.strictEqual(viewer.plots.length, 3);
+ } finally {
+ viewer?.webviewPanel?.dispose();
+ await process.dispose();
+ for (const group of vscode.window.tabGroups.all) {
+ for (const tab of group.tabs) {
+ if (
+ tab.input instanceof vscode.TabInputText &&
+ tab.input.uri.toString() === document.uri.toString()
+ ) {
+ await vscode.window.tabGroups.close(tab);
+ }
+ }
+ }
+ await executeRealCommand('vscode.setEditorLayout', originalLayout);
+ }
+ });
+
+ test('standard reconnect refreshes only its existing panel without revealing or reopening it', async () => {
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ const reattached = owner('a', '123');
+ focus(b);
+ sandbox
+ .stub(session, 'resolvePlotSession')
+ .callsFake((source) => (source.sessionId === a.sessionId ? reattached : b));
+ const request = sandbox
+ .stub(session, 'sessionRequest')
+ .resolves({ data: 'old', format: 'svg' });
+ const value = manager();
+ await value.showStandardPlot(a);
+ await value.showStandardPlot(b);
+ await panels[0].receive({ type: 'ready' });
+ request.resetHistory();
+ panels[0].post.resetHistory();
+ request.resolves({ data: 'drawn-while-disconnected', format: 'svg' });
+
+ await value.showStandardPlot(reattached, true);
+ sinon.assert.calledOnce(request);
+ assert.strictEqual(request.firstCall.args[1], reattached);
+ sinon.assert.calledWith(panels[0].post, {
+ type: 'update',
+ data: 'drawn-while-disconnected',
+ format: 'svg',
+ });
+ sinon.assert.notCalled((panels[0].panel as unknown as { reveal: sinon.SinonStub }).reveal);
+ sinon.assert.notCalled(panels[1].post);
+
+ panels[0].panel.dispose();
+ request.resetHistory();
+ await value.showStandardPlot(reattached, true);
+ await value.showStandardPlot(owner('never-opened', '789'), true);
+ sinon.assert.notCalled(request);
+ assert.strictEqual(panels.length, 2);
+ assert.strictEqual(value.viewers.length, 2);
+ });
+
+ test('standard restoration requests only the focused session', async () => {
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ focus(a);
+ sandbox.stub(session, 'resolvePlotSession').returns(a);
+ const request = sandbox
+ .stub(session, 'sessionRequest')
+ .resolves({ data: 'svg', format: 'svg' });
+ const first = manager();
+ await first.showStandardPlot(a);
+ await first.showStandardPlot(b);
+ for (const { panel } of panels) {
+ panel.dispose();
+ }
+ await first.dispose();
+ panels = [];
+ manager();
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ await panels[0].receive({ type: 'ready' });
+ sinon.assert.calledOnce(request);
+ assert.strictEqual(request.firstCall.args[1], a);
+ });
+
+ test('JGD frames update only their own viewer without redundant toolbar messages', async () => {
+ const value = manager();
+ const deliver = startJgd(value);
+ const history = value.jgdManager.history;
+ history.addPlot('a', frame('a'));
+ history.setSessionLabel('a', 'r-123-1');
+ deliver('a', { type: 'frame' });
+ await panels[0].receive({ type: 'ready' });
+ const post = panels[0].post;
+ post.resetHistory();
+ for (let index = 0; index < 100; index++) {
+ history.addPlot('b', frame('b'));
+ deliver('b', { type: 'frame' });
+ }
+ sinon.assert.notCalled(post);
+ assert.strictEqual(panels.length, 2);
+ history.setSessionLabel('b', 'r-456-1');
+ await panels[1].receive({ type: 'ready' });
+ assert.strictEqual(panels[0].panel.title, 'R Plot (JGD)');
+ assert.strictEqual(panels[1].panel.title, 'R Plot (JGD)');
+ assert.ok(!panels[0].panel.webview.html.includes('session-select'));
+ panels[1].post.resetHistory();
+
+ for (let index = 0; index < 100; index++) {
+ history.appendOps('a', { ...frame('a'), ops: [{ op: 'line', index }] });
+ deliver('a', { type: 'frame' });
+ }
+ assert.strictEqual(post.withArgs(sinon.match({ type: 'render' })).callCount, 100);
+ sinon.assert.notCalled(post.withArgs(sinon.match({ type: 'toolbar' })));
+ sinon.assert.notCalled(panels[1].post);
+ assert.strictEqual(history.currentPlot('a')?.ops.length, 100);
+ await panels[0].receive({ type: 'ready' });
+ sinon.assert.calledOnce(post.withArgs(sinon.match({ type: 'toolbar' })));
+ });
+
+ test('JGD tabs independently navigate, resize, measure text, remove plots and reopen', async () => {
+ const value = manager();
+ const metrics = sandbox.spy(value.jgdManager.server, 'setMeasureText');
+ const dimensions = sandbox.spy(value.jgdManager.server, 'setGetDimensions');
+ const deliver = startJgd(value);
+ const resize = sandbox.stub(value.jgdManager.server, 'handleResize');
+ const history = value.jgdManager.history;
+ const aOwner = owner('a', '123');
+ focus(aOwner);
+ sandbox.stub(session, 'resolvePlotSession').returns(aOwner);
+ for (const id of ['a', 'b']) {
+ history.addPlot(id, frame(id, `${id}1`));
+ history.addPlot(id, frame(id, `${id}2`));
+ history.setSessionSource(id, id === 'a' ? aOwner : owner('b', '456'));
+ deliver(id, { type: 'frame' });
+ await panels.at(-1)!.receive({ type: 'ready' });
+ }
+ const a = value.jgdManager.getViewer('a')!;
+ const b = value.jgdManager.getViewer('b')!;
+ assert.notStrictEqual(a.id, b.id);
+ Object.assign(panels[0].panel, { active: false });
+ assert.strictEqual(value.activeViewer, b);
+ Object.assign(panels[0].panel, { active: true });
+ Object.assign(panels[1].panel, { active: false });
+ await callbacks.get('r.plot.prevPlot')!(
+ vscode.Uri.parse('webview-panel:webview-panel/webview-jgd.plotPane-a'),
+ );
+ assert.strictEqual(history.currentIndex('a'), 1);
+ assert.strictEqual(history.currentIndex('b'), 2);
+ sinon.assert.calledWithExactly(resize, 800, 600, 'a');
+ await panels[0].receive({ type: 'resize', width: 700, height: 500 });
+ await panels[1].receive({ type: 'resize', width: 900, height: 650 });
+ sinon.assert.calledWithExactly(resize, 700, 500, 'a');
+ sinon.assert.calledWithExactly(resize, 900, 650, 'b');
+ const getDimensions = dimensions.firstCall.args[0];
+ assert.deepStrictEqual(getDimensions('a'), { width: 700, height: 500 });
+ assert.deepStrictEqual(getDimensions('b'), { width: 900, height: 650 });
+ const measure = metrics.firstCall.args[0];
+ panels[0].post.resetHistory();
+ panels[1].post.resetHistory();
+ const measured = measure(
+ { type: 'metrics_request', id: 7, kind: 'strWidth', str: 'x' },
+ 96,
+ 'a',
+ );
+ const request = panels[0].post.lastCall.args[0] as { id: number };
+ sinon.assert.notCalled(panels[1].post);
+ await panels[0].receive({
+ type: 'metrics_response',
+ id: request.id,
+ originalId: 7,
+ width: 42,
+ ascent: 10,
+ descent: 3,
+ });
+ assert.deepStrictEqual(await measured, {
+ type: 'metrics_response',
+ id: 7,
+ width: 42,
+ ascent: 10,
+ descent: 3,
+ });
+ await panels[0].receive({ type: 'deleteCurrent' });
+ assert.strictEqual(history.count('a'), 1);
+ assert.strictEqual(history.count('b'), 2);
+ await b.handleCommand('resetPlots');
+ assert.strictEqual(history.count('a'), 1);
+ assert.strictEqual(history.count('b'), 0);
+ panels[0].panel.dispose();
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 3, 'only the closed tab is recreated');
+ await panels[2].receive({ type: 'ready' });
+ sinon.assert.calledWith(
+ panels[2].post,
+ sinon.match({ type: 'render', plot: sinon.match({ sessionId: 'a' }) }),
+ );
+ });
+
+ test('JGD restores separate tabs with each session history position after reload', async () => {
+ const first = manager();
+ const history = first.jgdManager.history;
+ history.addPlot('a', frame('a', 'a1'));
+ history.addPlot('a', frame('a', 'a2'));
+ history.addPlot('b', frame('b', 'b1'));
+ history.addPlot('b', frame('b', 'b2'));
+ history.navigatePrevious('a');
+ const a = owner('a', '123');
+ const b = owner('b', '456');
+ history.setSessionSource('a', a);
+ history.setSessionSource('b', b);
+ const active = sandbox.stub(session, 'activeSession').value(a);
+ sandbox
+ .stub(session, 'resolvePlotSession')
+ .callsFake((source) => source as session.Session);
+ await first.dispose();
+ const restored = manager();
+ assert.strictEqual(panels.length, 0);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ active.value(b);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 2);
+ for (const [index, id, bg] of [
+ [0, 'a', 'a1'],
+ [1, 'b', 'b2'],
+ ] as const) {
+ await panels[index].receive({ type: 'ready' });
+ sinon.assert.calledWith(
+ panels[index].post,
+ sinon.match({
+ type: 'render',
+ plot: sinon.match({ sessionId: id, device: sinon.match({ bg }) }),
+ }),
+ );
+ assert.strictEqual(panels[index].panel.title, 'R Plot (JGD)');
+ }
+ await restored.jgdManager.getViewer('b')!.handleCommand('firstPlot');
+ assert.strictEqual(restored.jgdManager.history.currentIndex('a'), 1);
+ assert.strictEqual(restored.jgdManager.history.currentIndex('b'), 1);
+ });
+
+ test('standard restoration waits for the owning session instead of showing an archived image', async () => {
+ const first = manager();
+ const owner = {
+ sessionId: 'a',
+ host: 'host',
+ pid: '123',
+ rVer: '4.6.0',
+ processExited: false,
+ } as session.Session;
+ sandbox.stub(session, 'sessionRequest').resolves({ data: 'plot', format: 'svg' });
+ focus(owner);
+ const resolve = sandbox.stub(session, 'resolvePlotSession').returns(undefined);
+ const information = sandbox.stub(vscode.window, 'showInformationMessage').resolves();
+ await first.showStandardPlot(owner);
+ await panels[0].receive({ type: 'ready' });
+ await first.dispose();
+ panels = [];
+ manager();
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 0);
+ sinon.assert.calledOnce(information);
+ resolve.returns(owner);
+ await callbacks.get('r.plot.showViewers')!();
+ assert.strictEqual(panels.length, 1);
+ });
+
+ test('httpgd reconnects with its token and retains live rendering and removal after reload', async () => {
+ const source = owner('httpgd-owner', '14001');
+ focus(source);
+ sandbox.stub(session, 'resolvePlotSession').returns(source);
+ const first = manager();
+ await first.showHttpgdPlot('http://localhost:1234/live?token=secret', source);
+ RefreshViewer.prototype.seedPlots.call(first.httpgdManager.viewers[0], [
+ { id: '1', data: '', width: 400, height: 300, zoom: 1 },
+ ]);
+ await first.dispose();
+ assert.ok(!JSON.stringify([...state.values()]).includes('secret'));
+ assert.ok(!JSON.stringify([...secrets.values()]).includes('