@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/plot-mode/contribution-host.mjs

@@ -0,0 +1,297 @@
+import { Injector } from '@angular/core';
+import { PlotType } from '../contracts/plot-type';
+import { PLOT_MODE_CONTEXT, PLOT_MODE_SESSION, } from '../contracts/plot-type-contribution.contract';
+import { dialogToolContributions, } from '../contracts/toolbar-tool.contract';
+import { PlotModeController } from './plot-mode-controller';
+/** How many animation frames to wait for a tool dialog to attach its body's host. */
+const TOOL_DIALOG_ATTACH_FRAMES = 60;
+/**
+ * Hosts the library's two kinds of contributed sessions over the viewer:
+ *  - **plot modes** (`PLOT_TYPE_CONTRIBUTIONS`): a selector entry riding on a built-in
+ *    base type, with an optional side panel;
+ *  - **dialog tools** (`TOOLBAR_TOOLS`, `kind: 'dialog'`): a floating dialog over the
+ *    Image view, whose body the tool mounts once the dialog is in the document.
+ *
+ * Both run through a {@link PlotModeController} (one live session each, isolated from
+ * a failing contribution). A session is bound to the base view it drew over, so it
+ * ends before anything else draws ({@link endSessions}) and restarts once the next
+ * render has landed ({@link activate}).
+ */
+export class ContributionHost {
+    constructor(plotTypeContributions, toolContributions, viewer) {
+        this.viewer = viewer;
+        /** The live mode's panel; null while no contributed session is live. */
+        this.plotModePanel = null;
+        /** The open dialog tool's live dialog. */
+        this.toolDialog = null;
+        /** The dialog tool the user has open (its session may be between renders). */
+        this.openDialogToolId = null;
+        this.destroying = false;
+        /** The live dialog body's teardown, and a pending wait for its host to connect. */
+        this.toolDialogTeardown = null;
+        this.toolDialogFrame = null;
+        this.plotModes = new PlotModeController(plotTypeContributions, {
+            onActivated: (active) => this.showPlotModePanel(active),
+            onDeactivating: () => this.hidePlotModePanel(),
+            onFailed: (contribution) => this.fallBackFromPlotMode(contribution),
+        });
+        this.dialogTools = dialogToolContributions(toolContributions);
+        // A dialog tool's session is run by the plot-mode lifecycle, adapted: its "base
+        // type" is the Image view it draws over. Its body is NOT a controller panel: the
+        // controller would mount into a detached host, and a body must be able to measure
+        // itself. The dialog is rendered first and the body mounted once its host is in
+        // the document (showToolDialog).
+        this.toolDialogs = new PlotModeController(this.dialogTools.map((t) => ({
+            descriptor: { type: t.id, label: t.label, dimensions: '2d', baseType: PlotType.IMAGE },
+            activate: (ctx) => t.activate(ctx),
+        })), {
+            onActivated: (active) => this.showToolDialog(active),
+            onDeactivating: () => this.hideToolDialog(),
+            onFailed: (contribution) => this.dialogToolFailed(contribution.descriptor.type),
+        });
+    }
+    /** End both sessions: the view they drew over is about to go. An open dialog tool
+     *  stays open and restarts on the next {@link activate}. */
+    endSessions() {
+        this.plotModes.deactivate();
+        this.toolDialogs.deactivate();
+    }
+    /** A render landed: start the selected mode's session and the open dialog tool's. */
+    activate() {
+        this.activateSelectedPlotMode();
+        this.activateOpenDialogTool();
+    }
+    /** The viewer is being destroyed: end both sessions without touching its view. */
+    destroy() {
+        this.destroying = true;
+        this.endSessions();
+    }
+    /** The toolbar button: open the tool's dialog, or close it if it is open. */
+    toggleDialogTool(id) {
+        if (this.openDialogToolId === id) {
+            this.closeDialogTool();
+            return;
+        }
+        this.closeDialogTool();
+        if (!this.dialogTools.some((t) => t.id === id))
+            return;
+        this.openDialogToolId = id;
+        this.toolDialogs.clearCleanupFailures(); // an explicit open gets a fresh attempt
+        this.activateOpenDialogTool();
+    }
+    /** Close the open dialog tool: its body is torn down, then its session ends. */
+    closeDialogTool() {
+        this.openDialogToolId = null;
+        this.toolDialogs.deactivate();
+    }
+    /** Attach a `mount` panel's host element once the panel dialog renders its slot. */
+    attachPanelSlot(slot) {
+        const host = this.plotModePanel?.host;
+        if (slot && host && host.parentElement !== slot)
+            slot.appendChild(host);
+    }
+    /** Attach the open dialog tool's host element once its dialog renders its slot. */
+    attachToolDialogSlot(slot) {
+        const host = this.toolDialog?.host;
+        if (slot && host && host.parentElement !== slot)
+            slot.appendChild(host);
+    }
+    /**
+     * Start the selected contributed mode's session, once its base view has plotted.
+     * No-op for a built-in type, or when the base on screen is not the one the mode
+     * rides on. A backend that cannot provide a viewport for it (e.g. OSD fell back to
+     * Plotly) counts as a failed activation.
+     */
+    activateSelectedPlotMode() {
+        const contribution = this.plotModes.find(this.viewer.selectedId());
+        if (!contribution || this.viewer.renderedType() !== contribution.descriptor.baseType)
+            return;
+        const ctx = this.context();
+        if (!ctx) {
+            console.error(`[visualizer] plot-type contribution '${contribution.descriptor.type}': the backend ` +
+                'on screen provides no viewport to draw over — falling back.');
+            this.fallBackFromPlotMode(contribution);
+            return;
+        }
+        void this.plotModes.activate(contribution, ctx);
+    }
+    /** Start (or restart, after a re-render) the open dialog tool's session. */
+    activateOpenDialogTool() {
+        const id = this.openDialogToolId;
+        const contribution = id ? this.toolDialogs.find(id) : undefined;
+        if (!id || !contribution || this.viewer.renderedType() !== PlotType.IMAGE)
+            return;
+        if (this.toolDialogs.current?.contribution === contribution || this.toolDialogs.pending)
+            return;
+        const ctx = this.context();
+        if (!ctx) {
+            console.error(`[visualizer] dialog tool '${id}': the backend on screen provides no viewport to draw over.`);
+            this.dialogToolFailed(id);
+            return;
+        }
+        void this.toolDialogs.activate(contribution, ctx);
+    }
+    /** A session's context over the backend on screen, or null when it has no viewport. */
+    context() {
+        const visualizer = this.viewer.visualizer;
+        const viewport = visualizer.getPlotModeViewport?.() ?? null;
+        if (!viewport)
+            return null;
+        return { visualizer, viewport, imageInfo$: this.viewer.imageInfo$(), tools: this.viewer.tools };
+    }
+    /** Render the live mode's panel. Activation can resolve outside Angular (an OSD
+     *  callback, a contribution's own promise), hence the zone re-entry. */
+    showPlotModePanel(active) {
+        const panel = active.contribution.panel;
+        if (!panel)
+            return;
+        this.viewer.zone.run(() => {
+            if ('component' in panel && panel.component) {
+                this.plotModePanel = {
+                    title: panel.title,
+                    component: panel.component,
+                    injector: Injector.create({
+                        providers: [
+                            { provide: PLOT_MODE_CONTEXT, useValue: active.ctx },
+                            { provide: PLOT_MODE_SESSION, useValue: active.session },
+                        ],
+                        parent: this.viewer.injector,
+                    }),
+                    host: null,
+                };
+            }
+            else if (active.panelHost) {
+                this.plotModePanel = { title: panel.title, component: null, injector: null, host: active.panelHost };
+            }
+            else {
+                return;
+            }
+            // A component panel is created and first rendered right here; if that throws,
+            // the mode is not usable — end it and fall back rather than leave it selected.
+            const err = this.detectChangesSafely();
+            if (err !== null)
+                this.plotModes.failActive(err);
+        });
+    }
+    /** Drop the panel (destroying a component panel) before the session ends. */
+    hidePlotModePanel() {
+        if (!this.plotModePanel)
+            return;
+        this.plotModePanel = null;
+        this.detectChangesSafely();
+    }
+    /** A contributed mode could not start. Its base type is already on screen — the base
+     *  plotted first — so just select it: nothing needs to re-plot. */
+    fallBackFromPlotMode(contribution) {
+        if (this.destroying || this.viewer.selectedId() !== contribution.descriptor.type)
+            return;
+        this.viewer.zone.run(() => {
+            this.viewer.selectBase(contribution.descriptor.baseType);
+            this.viewer.notify({
+                severity: 'warn',
+                summary: `${contribution.descriptor.productionLabel ?? contribution.descriptor.label} is unavailable`,
+                detail: 'The plot mode could not start, so the plain image is shown instead. See the browser console for details.',
+            });
+            this.detectChangesSafely();
+        });
+    }
+    /**
+     * The dialog-tool session is live: render the dialog, then mount the tool's body
+     * once the host element is in the document, so `mount()` can measure it and start
+     * widgets that need a connected element.
+     */
+    showToolDialog(active) {
+        const tool = this.dialogTools.find((t) => t.id === active.contribution.descriptor.type);
+        if (!tool)
+            return;
+        const host = document.createElement('div');
+        host.className = 'tool-dialog-body';
+        this.viewer.zone.run(() => {
+            this.toolDialog = { title: tool.dialog?.title ?? tool.label, width: tool.dialog?.width ?? '22rem', host };
+            const err = this.detectChangesSafely();
+            if (err !== null) {
+                this.toolDialogs.failActive(err);
+                return;
+            }
+            this.mountToolDialogBody(tool, active, host, 0);
+        });
+    }
+    /**
+     * Mount `tool`'s body into `host` once it is connected (the dialog may attach it a
+     * frame later, when it moves itself to `<body>`). If it never connects within
+     * {@link TOOL_DIALOG_ATTACH_FRAMES} it is mounted anyway, with a warning, rather than
+     * leaving an empty dialog. A throwing `mount()` fails the session like a failed start.
+     */
+    mountToolDialogBody(tool, active, host, frames) {
+        this.toolDialogFrame = null;
+        // The session ended (or was replaced) while waiting: nothing to mount into.
+        if (this.toolDialogs.current !== active || this.toolDialog?.host !== host)
+            return;
+        if (!host.isConnected) {
+            if (frames < TOOL_DIALOG_ATTACH_FRAMES) {
+                this.toolDialogFrame = requestAnimationFrame(() => this.mountToolDialogBody(tool, active, host, frames + 1));
+                return;
+            }
+            console.warn(`[visualizer] dialog tool '${tool.id}': the dialog body never attached; mounting it detached.`);
+        }
+        try {
+            const teardown = tool.mount(host, active.ctx, active.session);
+            this.toolDialogTeardown = typeof teardown === 'function' ? teardown : null;
+        }
+        catch (err) {
+            console.error(`[visualizer] dialog tool '${tool.id}' mount() threw.`, err);
+            this.toolDialogs.failActive(err);
+        }
+    }
+    /** The dialog-tool session is about to end: tear the body down first, then drop the dialog. */
+    hideToolDialog() {
+        if (this.toolDialogFrame !== null)
+            cancelAnimationFrame(this.toolDialogFrame);
+        this.toolDialogFrame = null;
+        const teardown = this.toolDialogTeardown;
+        this.toolDialogTeardown = null;
+        if (teardown) {
+            try {
+                teardown();
+            }
+            catch (err) {
+                console.error('[visualizer] dialog tool body teardown threw.', err);
+            }
+        }
+        if (!this.toolDialog)
+            return;
+        this.toolDialog.host.remove();
+        this.toolDialog = null;
+        if (!this.destroying)
+            this.detectChangesSafely();
+    }
+    /** A dialog tool could not start: close it and say so. */
+    dialogToolFailed(id) {
+        if (this.destroying || this.openDialogToolId !== id)
+            return;
+        this.viewer.zone.run(() => {
+            this.openDialogToolId = null;
+            const tool = this.dialogTools.find((t) => t.id === id);
+            this.viewer.notify({
+                severity: 'warn',
+                summary: `${tool?.label ?? id} is unavailable`,
+                detail: 'The tool could not start. See the browser console for details.',
+            });
+            this.detectChangesSafely();
+        });
+    }
+    /** Run change detection; returns what it threw (logged), or null. */
+    detectChangesSafely() {
+        if (this.destroying)
+            return null;
+        try {
+            this.viewer.detectChanges();
+            return null;
+        }
+        catch (err) {
+            console.error('[visualizer] change detection failed while updating a contributed plot mode panel.', err);
+            return err ?? new Error('change detection failed');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contribution-host.js","sourceRoot":"","sources":["../../../../src/lib/plot-mode/contribution-host.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector, NgZone, Type } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Message } from 'primeng/api';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { PlotType, PlotTypeId } from '../contracts/plot-type';\nimport {\n  PLOT_MODE_CONTEXT,\n  PLOT_MODE_SESSION,\n  PlotModeContext,\n  PlotModeTools,\n  PlotTypeContribution,\n} from '../contracts/plot-type-contribution.contract';\nimport {\n  ToolDialogContext,\n  ToolbarContribution,\n  ToolbarDialogToolContribution,\n  dialogToolContributions,\n} from '../contracts/toolbar-tool.contract';\nimport { IVisualizer } from '../contracts/visualizer.contract';\nimport { ActivePlotMode, PlotModeController } from './plot-mode-controller';\n\n/** The live contributed mode's side panel, as the template renders it. */\nexport interface PlotModePanelView {\n  title: string;\n  /** An Angular component panel, with its own injector… */\n  component: Type<unknown> | null;\n  injector: Injector | null;\n  /** …or a plain host element a `mount` panel rendered into. */\n  host: HTMLElement | null;\n}\n\n/** The open dialog tool's dialog, as the template renders it. */\nexport interface ToolDialogView {\n  title: string;\n  width: string;\n  host: HTMLElement;\n}\n\n/** What the contributions need from the viewer that hosts them. */\nexport interface ContributionViewer {\n  readonly visualizer: IVisualizer;\n  readonly zone: NgZone;\n  /** The toolbar tools a contribution may arm (`PlotModeContext.tools`). */\n  readonly tools: PlotModeTools;\n  /** Parent of a component panel's injector. */\n  readonly injector?: Injector;\n  imageInfo$(): Observable<IImageInfo | null>;\n  /** The selector's id (a built-in type or a contributed mode). */\n  selectedId(): PlotTypeId;\n  /** The built-in type being rendered. */\n  renderedType(): PlotType;\n  /** A contributed mode could not start: select its base type, already on screen. */\n  selectBase(type: PlotType): void;\n  notify(message: Message): void;\n  detectChanges(): void;\n}\n\n/** How many animation frames to wait for a tool dialog to attach its body's host. */\nconst TOOL_DIALOG_ATTACH_FRAMES = 60;\n\n/**\n * Hosts the library's two kinds of contributed sessions over the viewer:\n *  - **plot modes** (`PLOT_TYPE_CONTRIBUTIONS`): a selector entry riding on a built-in\n *    base type, with an optional side panel;\n *  - **dialog tools** (`TOOLBAR_TOOLS`, `kind: 'dialog'`): a floating dialog over the\n *    Image view, whose body the tool mounts once the dialog is in the document.\n *\n * Both run through a {@link PlotModeController} (one live session each, isolated from\n * a failing contribution). A session is bound to the base view it drew over, so it\n * ends before anything else draws ({@link endSessions}) and restarts once the next\n * render has landed ({@link activate}).\n */\nexport class ContributionHost {\n  readonly plotModes: PlotModeController;\n  readonly toolDialogs: PlotModeController;\n  /** Dialog tools, sorted; their buttons show in the Image view only. */\n  readonly dialogTools: ToolbarDialogToolContribution[];\n  /** The live mode's panel; null while no contributed session is live. */\n  plotModePanel: PlotModePanelView | null = null;\n  /** The open dialog tool's live dialog. */\n  toolDialog: ToolDialogView | null = null;\n  /** The dialog tool the user has open (its session may be between renders). */\n  openDialogToolId: string | null = null;\n\n  private destroying = false;\n  /** The live dialog body's teardown, and a pending wait for its host to connect. */\n  private toolDialogTeardown: (() => void) | null = null;\n  private toolDialogFrame: number | null = null;\n\n  constructor(\n    plotTypeContributions: readonly PlotTypeContribution[] | null | undefined,\n    toolContributions: readonly ToolbarContribution[] | null | undefined,\n    private readonly viewer: ContributionViewer,\n  ) {\n    this.plotModes = new PlotModeController(plotTypeContributions, {\n      onActivated: (active) => this.showPlotModePanel(active),\n      onDeactivating: () => this.hidePlotModePanel(),\n      onFailed: (contribution) => this.fallBackFromPlotMode(contribution),\n    });\n    this.dialogTools = dialogToolContributions(toolContributions);\n    // A dialog tool's session is run by the plot-mode lifecycle, adapted: its \"base\n    // type\" is the Image view it draws over. Its body is NOT a controller panel: the\n    // controller would mount into a detached host, and a body must be able to measure\n    // itself. The dialog is rendered first and the body mounted once its host is in\n    // the document (showToolDialog).\n    this.toolDialogs = new PlotModeController(\n      this.dialogTools.map((t): PlotTypeContribution => ({\n        descriptor: { type: t.id, label: t.label, dimensions: '2d', baseType: PlotType.IMAGE },\n        activate: (ctx) => t.activate(ctx as ToolDialogContext),\n      })),\n      {\n        onActivated: (active) => this.showToolDialog(active),\n        onDeactivating: () => this.hideToolDialog(),\n        onFailed: (contribution) => this.dialogToolFailed(contribution.descriptor.type),\n      },\n    );\n  }\n\n  /** End both sessions: the view they drew over is about to go. An open dialog tool\n   *  stays open and restarts on the next {@link activate}. */\n  endSessions(): void {\n    this.plotModes.deactivate();\n    this.toolDialogs.deactivate();\n  }\n\n  /** A render landed: start the selected mode's session and the open dialog tool's. */\n  activate(): void {\n    this.activateSelectedPlotMode();\n    this.activateOpenDialogTool();\n  }\n\n  /** The viewer is being destroyed: end both sessions without touching its view. */\n  destroy(): void {\n    this.destroying = true;\n    this.endSessions();\n  }\n\n  /** The toolbar button: open the tool's dialog, or close it if it is open. */\n  toggleDialogTool(id: string): void {\n    if (this.openDialogToolId === id) {\n      this.closeDialogTool();\n      return;\n    }\n    this.closeDialogTool();\n    if (!this.dialogTools.some((t) => t.id === id)) return;\n    this.openDialogToolId = id;\n    this.toolDialogs.clearCleanupFailures(); // an explicit open gets a fresh attempt\n    this.activateOpenDialogTool();\n  }\n\n  /** Close the open dialog tool: its body is torn down, then its session ends. */\n  closeDialogTool(): void {\n    this.openDialogToolId = null;\n    this.toolDialogs.deactivate();\n  }\n\n  /** Attach a `mount` panel's host element once the panel dialog renders its slot. */\n  attachPanelSlot(slot: HTMLElement | undefined): void {\n    const host = this.plotModePanel?.host;\n    if (slot && host && host.parentElement !== slot) slot.appendChild(host);\n  }\n\n  /** Attach the open dialog tool's host element once its dialog renders its slot. */\n  attachToolDialogSlot(slot: HTMLElement | undefined): void {\n    const host = this.toolDialog?.host;\n    if (slot && host && host.parentElement !== slot) slot.appendChild(host);\n  }\n\n  /**\n   * Start the selected contributed mode's session, once its base view has plotted.\n   * No-op for a built-in type, or when the base on screen is not the one the mode\n   * rides on. A backend that cannot provide a viewport for it (e.g. OSD fell back to\n   * Plotly) counts as a failed activation.\n   */\n  private activateSelectedPlotMode(): void {\n    const contribution = this.plotModes.find(this.viewer.selectedId());\n    if (!contribution || this.viewer.renderedType() !== contribution.descriptor.baseType) return;\n    const ctx = this.context();\n    if (!ctx) {\n      console.error(\n        `[visualizer] plot-type contribution '${contribution.descriptor.type}': the backend ` +\n          'on screen provides no viewport to draw over — falling back.',\n      );\n      this.fallBackFromPlotMode(contribution);\n      return;\n    }\n    void this.plotModes.activate(contribution, ctx);\n  }\n\n  /** Start (or restart, after a re-render) the open dialog tool's session. */\n  private activateOpenDialogTool(): void {\n    const id = this.openDialogToolId;\n    const contribution = id ? this.toolDialogs.find(id) : undefined;\n    if (!id || !contribution || this.viewer.renderedType() !== PlotType.IMAGE) return;\n    if (this.toolDialogs.current?.contribution === contribution || this.toolDialogs.pending) return;\n    const ctx = this.context();\n    if (!ctx) {\n      console.error(`[visualizer] dialog tool '${id}': the backend on screen provides no viewport to draw over.`);\n      this.dialogToolFailed(id);\n      return;\n    }\n    void this.toolDialogs.activate(contribution, ctx);\n  }\n\n  /** A session's context over the backend on screen, or null when it has no viewport. */\n  private context(): PlotModeContext | null {\n    const visualizer = this.viewer.visualizer;\n    const viewport = visualizer.getPlotModeViewport?.() ?? null;\n    if (!viewport) return null;\n    return { visualizer, viewport, imageInfo$: this.viewer.imageInfo$(), tools: this.viewer.tools };\n  }\n\n  /** Render the live mode's panel. Activation can resolve outside Angular (an OSD\n   *  callback, a contribution's own promise), hence the zone re-entry. */\n  private showPlotModePanel(active: ActivePlotMode): void {\n    const panel = active.contribution.panel;\n    if (!panel) return;\n    this.viewer.zone.run(() => {\n      if ('component' in panel && panel.component) {\n        this.plotModePanel = {\n          title: panel.title,\n          component: panel.component,\n          injector: Injector.create({\n            providers: [\n              { provide: PLOT_MODE_CONTEXT, useValue: active.ctx },\n              { provide: PLOT_MODE_SESSION, useValue: active.session },\n            ],\n            parent: this.viewer.injector,\n          }),\n          host: null,\n        };\n      } else if (active.panelHost) {\n        this.plotModePanel = { title: panel.title, component: null, injector: null, host: active.panelHost };\n      } else {\n        return;\n      }\n      // A component panel is created and first rendered right here; if that throws,\n      // the mode is not usable — end it and fall back rather than leave it selected.\n      const err = this.detectChangesSafely();\n      if (err !== null) this.plotModes.failActive(err);\n    });\n  }\n\n  /** Drop the panel (destroying a component panel) before the session ends. */\n  private hidePlotModePanel(): void {\n    if (!this.plotModePanel) return;\n    this.plotModePanel = null;\n    this.detectChangesSafely();\n  }\n\n  /** A contributed mode could not start. Its base type is already on screen — the base\n   *  plotted first — so just select it: nothing needs to re-plot. */\n  private fallBackFromPlotMode(contribution: PlotTypeContribution): void {\n    if (this.destroying || this.viewer.selectedId() !== contribution.descriptor.type) return;\n    this.viewer.zone.run(() => {\n      this.viewer.selectBase(contribution.descriptor.baseType);\n      this.viewer.notify({\n        severity: 'warn',\n        summary: `${contribution.descriptor.productionLabel ?? contribution.descriptor.label} is unavailable`,\n        detail:\n          'The plot mode could not start, so the plain image is shown instead. See the browser console for details.',\n      });\n      this.detectChangesSafely();\n    });\n  }\n\n  /**\n   * The dialog-tool session is live: render the dialog, then mount the tool's body\n   * once the host element is in the document, so `mount()` can measure it and start\n   * widgets that need a connected element.\n   */\n  private showToolDialog(active: ActivePlotMode): void {\n    const tool = this.dialogTools.find((t) => t.id === active.contribution.descriptor.type);\n    if (!tool) return;\n    const host = document.createElement('div');\n    host.className = 'tool-dialog-body';\n    this.viewer.zone.run(() => {\n      this.toolDialog = { title: tool.dialog?.title ?? tool.label, width: tool.dialog?.width ?? '22rem', host };\n      const err = this.detectChangesSafely();\n      if (err !== null) {\n        this.toolDialogs.failActive(err);\n        return;\n      }\n      this.mountToolDialogBody(tool, active, host, 0);\n    });\n  }\n\n  /**\n   * Mount `tool`'s body into `host` once it is connected (the dialog may attach it a\n   * frame later, when it moves itself to `<body>`). If it never connects within\n   * {@link TOOL_DIALOG_ATTACH_FRAMES} it is mounted anyway, with a warning, rather than\n   * leaving an empty dialog. A throwing `mount()` fails the session like a failed start.\n   */\n  private mountToolDialogBody(\n    tool: ToolbarDialogToolContribution,\n    active: ActivePlotMode,\n    host: HTMLElement,\n    frames: number,\n  ): void {\n    this.toolDialogFrame = null;\n    // The session ended (or was replaced) while waiting: nothing to mount into.\n    if (this.toolDialogs.current !== active || this.toolDialog?.host !== host) return;\n    if (!host.isConnected) {\n      if (frames < TOOL_DIALOG_ATTACH_FRAMES) {\n        this.toolDialogFrame = requestAnimationFrame(() =>\n          this.mountToolDialogBody(tool, active, host, frames + 1),\n        );\n        return;\n      }\n      console.warn(`[visualizer] dialog tool '${tool.id}': the dialog body never attached; mounting it detached.`);\n    }\n    try {\n      const teardown = tool.mount(host, active.ctx as ToolDialogContext, active.session);\n      this.toolDialogTeardown = typeof teardown === 'function' ? teardown : null;\n    } catch (err) {\n      console.error(`[visualizer] dialog tool '${tool.id}' mount() threw.`, err);\n      this.toolDialogs.failActive(err);\n    }\n  }\n\n  /** The dialog-tool session is about to end: tear the body down first, then drop the dialog. */\n  private hideToolDialog(): void {\n    if (this.toolDialogFrame !== null) cancelAnimationFrame(this.toolDialogFrame);\n    this.toolDialogFrame = null;\n    const teardown = this.toolDialogTeardown;\n    this.toolDialogTeardown = null;\n    if (teardown) {\n      try {\n        teardown();\n      } catch (err) {\n        console.error('[visualizer] dialog tool body teardown threw.', err);\n      }\n    }\n    if (!this.toolDialog) return;\n    this.toolDialog.host.remove();\n    this.toolDialog = null;\n    if (!this.destroying) this.detectChangesSafely();\n  }\n\n  /** A dialog tool could not start: close it and say so. */\n  private dialogToolFailed(id: string): void {\n    if (this.destroying || this.openDialogToolId !== id) return;\n    this.viewer.zone.run(() => {\n      this.openDialogToolId = null;\n      const tool = this.dialogTools.find((t) => t.id === id);\n      this.viewer.notify({\n        severity: 'warn',\n        summary: `${tool?.label ?? id} is unavailable`,\n        detail: 'The tool could not start. See the browser console for details.',\n      });\n      this.detectChangesSafely();\n    });\n  }\n\n  /** Run change detection; returns what it threw (logged), or null. */\n  private detectChangesSafely(): unknown | null {\n    if (this.destroying) return null;\n    try {\n      this.viewer.detectChanges();\n      return null;\n    } catch (err) {\n      console.error('[visualizer] change detection failed while updating a contributed plot mode panel.', err);\n      return err ?? new Error('change detection failed');\n    }\n  }\n}\n"]}

package/esm2022/lib/plot-mode/plot-mode-controller.mjs

@@ -33,8 +33,8 @@ export function normalizeContributions(raw, log = console) {
             continue;
         }
         if (!SUPPORTED_CONTRIBUTION_BASE_TYPES.includes(d.baseType)) {
-            log.warn(`${TAG} '${id}' ignored: baseType '${String(d.baseType)}' is not supported `
-                + `(supported: ${SUPPORTED_CONTRIBUTION_BASE_TYPES.join(', ')}).`);
+            log.warn(`${TAG} '${id}' ignored: baseType '${String(d.baseType)}' is not supported ` +
+                `(supported: ${SUPPORTED_CONTRIBUTION_BASE_TYPES.join(', ')}).`);
             continue;
         }
         seen.add(id);
@@ -121,7 +121,10 @@ export class PlotModeController {
                     return resolve();
                 }
                 if (isThenable(result)) {
-                    result.then((session) => { this.start(contribution, ctx, session, gen); resolve(); }, (err) => {
+                    result.then((session) => {
+                        this.start(contribution, ctx, session, gen);
+                        resolve();
+                    }, (err) => {
                         if (gen === this.generation)
                             this.fail(contribution, err);
                         resolve();
@@ -223,8 +226,8 @@ export class PlotModeController {
     }
     fail(contribution, err) {
         this.pendingId = null;
-        this.log.error(`${TAG} '${contribution.descriptor.type}' failed to activate — `
-            + `falling back to '${contribution.descriptor.baseType}'.`, err);
+        this.log.error(`${TAG} '${contribution.descriptor.type}' failed to activate — ` +
+            `falling back to '${contribution.descriptor.baseType}'.`, err);
         try {
             this.hooks.onFailed(contribution, err);
         }
@@ -326,4 +329,4 @@ export class PlotModeController {
 function isThenable(v) {
     return !!v && typeof v.then === 'function';
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-mode-controller.js","sourceRoot":"","sources":["../../../../src/lib/plot-mode/plot-mode-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlotType, PlotTypeId, isBuiltinPlotType } from '../contracts/plot-type';\nimport {\n  ContributedPlotTypeDescriptor,\n  PlotModeContext,\n  PlotModeSession,\n  PlotTypeContribution,\n} from '../contracts/plot-type-contribution.contract';\n\n/**\n * Lifecycle of the contributed plot modes ({@link PlotTypeContribution}) for one\n * visualizer instance. Package-internal: the visualizer component owns one and\n * drives it from its render pipeline.\n *\n * Owns three things the component should not have to reason about:\n *  - which contributions are usable (validated and de-duplicated once);\n *  - the single live session, so `deactivate()` runs exactly once per session\n *    however many exits race each other (type change, image change, destroy,\n *    a superseded async activation);\n *  - isolation: nothing a contribution throws or rejects escapes this class.\n *    A failure is logged and reported through `onFailed`, and the component\n *    falls back to the mode's base type.\n */\n\n/** The live activation of a contributed mode, as the component renders it. */\nexport interface ActivePlotMode {\n  readonly contribution: PlotTypeContribution;\n  readonly ctx: PlotModeContext;\n  readonly session: PlotModeSession;\n  /** Host element handed to a `mount` panel, or null for a component / no panel. */\n  readonly panelHost: HTMLElement | null;\n}\n\nexport interface PlotModeControllerHooks {\n  /** A session is live (and a `mount` panel, if any, has been mounted). */\n  onActivated(active: ActivePlotMode): void;\n  /** The live session is about to end. Called BEFORE any teardown, so a\n   *  component panel can be destroyed while its session is still valid. */\n  onDeactivating(active: ActivePlotMode): void;\n  /** Activation failed (threw, rejected, never got a ready viewport, or its\n   *  panel failed to mount). The component falls back to the base type. */\n  onFailed(contribution: PlotTypeContribution, error: unknown): void;\n}\n\n/** Minimal logger, injectable for tests. */\nexport interface PlotModeLogger {\n  warn(...args: unknown[]): void;\n  error(...args: unknown[]): void;\n}\n\n/** Base types a contributed mode can ride on in this version. */\nexport const SUPPORTED_CONTRIBUTION_BASE_TYPES: readonly PlotType[] = [PlotType.IMAGE];\n\n/** How many animation frames to wait for the viewport before giving up. */\nconst MAX_READY_FRAMES = 180;\n\nconst TAG = '[visualizer] plot-type contribution';\n\n/**\n * Validate what arrived on `PLOT_TYPE_CONTRIBUTIONS`. A malformed or clashing\n * contribution is dropped with a warning rather than breaking the selector:\n *  - a nested array (`useValue: [a, b], multi: true`) is flattened one level;\n *  - `type` must be a non-empty string that is not a built-in `PlotType` value;\n *  - the first contribution with a given `type` wins;\n *  - `baseType` must be one of {@link SUPPORTED_CONTRIBUTION_BASE_TYPES};\n *  - `activate` must be a function.\n */\nexport function normalizeContributions(\n  raw: readonly unknown[] | null | undefined,\n  log: PlotModeLogger = console,\n): PlotTypeContribution[] {\n  const out: PlotTypeContribution[] = [];\n  const seen = new Set<string>();\n  const flat = (raw ?? []).flatMap((c) => (Array.isArray(c) ? c : [c]));\n  for (const c of flat as PlotTypeContribution[]) {\n    const d = c?.descriptor as ContributedPlotTypeDescriptor | undefined;\n    const id = d?.type;\n    if (!d || typeof id !== 'string' || !id || typeof c.activate !== 'function') {\n      log.warn(`${TAG} ignored: it needs a descriptor with a string \\`type\\` and an \\`activate\\` function.`, c);\n      continue;\n    }\n    if (isBuiltinPlotType(id)) {\n      log.warn(`${TAG} '${id}' ignored: the id clashes with a built-in plot type.`);\n      continue;\n    }\n    if (seen.has(id)) {\n      log.warn(`${TAG} '${id}' ignored: another contribution already uses that id.`);\n      continue;\n    }\n    if (!SUPPORTED_CONTRIBUTION_BASE_TYPES.includes(d.baseType)) {\n      log.warn(`${TAG} '${id}' ignored: baseType '${String(d.baseType)}' is not supported `\n        + `(supported: ${SUPPORTED_CONTRIBUTION_BASE_TYPES.join(', ')}).`);\n      continue;\n    }\n    seen.add(id);\n    out.push(c);\n  }\n  return out;\n}\n\nexport class PlotModeController {\n  readonly contributions: readonly PlotTypeContribution[];\n  private readonly byId: ReadonlyMap<string, PlotTypeContribution>;\n\n  private active: ActivePlotMode | null = null;\n  private teardown: (() => void) | null = null;\n  /** Bumped by every activate/deactivate, so a pending async activation can\n   *  tell it has been superseded. */\n  private generation = 0;\n  private readyFrame: number | null = null;\n  /** Contributions whose last cleanup (panel teardown / `deactivate()`) threw or\n   *  rejected. Their next automatic re-activation (base re-render, image switch)\n   *  falls back to the base type instead; an explicit selection clears the mark. */\n  private readonly failedCleanup = new Map<string, unknown>();\n  private readyCb: ((ready: boolean) => void) | null = null;\n\n  constructor(\n    raw: readonly unknown[] | null | undefined,\n    private readonly hooks: PlotModeControllerHooks,\n    private readonly log: PlotModeLogger = console,\n  ) {\n    this.contributions = normalizeContributions(raw, log);\n    this.byId = new Map(this.contributions.map((c) => [c.descriptor.type, c]));\n  }\n\n  /** Descriptors of the usable contributions, in registration order. */\n  descriptors(): ContributedPlotTypeDescriptor[] {\n    return this.contributions.map((c) => c.descriptor);\n  }\n\n  /** The contribution for a selector id, if it is a contributed mode. */\n  find(id: PlotTypeId | null | undefined): PlotTypeContribution | undefined {\n    return typeof id === 'string' ? this.byId.get(id) : undefined;\n  }\n\n  /**\n   * The built-in type that renders `id`: a built-in type is itself, a\n   * contributed id is its `baseType`, and an id that is neither (a stale\n   * contributed id whose provider is gone) resolves to `PlotType.IMAGE`, the\n   * default view.\n   */\n  baseTypeOf(id: PlotTypeId | null | undefined): PlotType {\n    if (isBuiltinPlotType(id)) return id;\n    return this.find(id)?.descriptor.baseType ?? PlotType.IMAGE;\n  }\n\n  /** The live session, if any. */\n  get current(): ActivePlotMode | null {\n    return this.active;\n  }\n\n  /** Whether an activation is waiting on the contribution or the viewport. */\n  get pending(): boolean {\n    return this.pendingId !== null;\n  }\n  private pendingId: string | null = null;\n\n  /**\n   * Start a session for `contribution`. Ends any live one first. Resolves when\n   * the attempt has finished (successfully or not); it never rejects.\n   */\n  activate(contribution: PlotTypeContribution, ctx: PlotModeContext): Promise<void> {\n    this.deactivate();\n    const id = contribution.descriptor.type;\n    if (this.failedCleanup.has(id)) {\n      // Its previous session did not end cleanly; do not stack a new one on top.\n      const err = this.failedCleanup.get(id);\n      this.failedCleanup.delete(id);\n      this.fail(contribution, err);\n      return Promise.resolve();\n    }\n    const gen = ++this.generation;\n    this.pendingId = id;\n    return new Promise<void>((resolve) => {\n      this.whenReady(ctx, gen, (ready) => {\n        if (gen !== this.generation) return resolve();\n        if (!ready) {\n          this.fail(contribution, new Error('the viewport never became ready'));\n          return resolve();\n        }\n        let result: PlotModeSession | Promise<PlotModeSession>;\n        try {\n          result = contribution.activate(ctx);\n        } catch (err) {\n          this.fail(contribution, err);\n          return resolve();\n        }\n        if (isThenable(result)) {\n          result.then(\n            (session) => { this.start(contribution, ctx, session, gen); resolve(); },\n            (err) => {\n              if (gen === this.generation) this.fail(contribution, err);\n              resolve();\n            },\n          );\n        } else {\n          this.start(contribution, ctx, result, gen);\n          resolve();\n        }\n      });\n    });\n  }\n\n  /**\n   * End the live session, if any: the component panel is dropped (via\n   * `onDeactivating`), a `mount` panel's teardown runs, then\n   * `session.deactivate()`, then the mount host is removed. Each step is\n   * isolated. A pending activation is cancelled; if it resolves later its\n   * session is deactivated on arrival. Idempotent.\n   */\n  deactivate(): void {\n    this.generation++;\n    this.pendingId = null;\n    this.cancelReadyWait();\n    const a = this.active;\n    if (!a) return;\n    this.active = null;\n    const teardown = this.teardown;\n    this.teardown = null;\n    const id = a.contribution.descriptor.type;\n    this.guard(`'${id}' panel removal`, () => this.hooks.onDeactivating(a));\n    if (teardown) this.cleanup(a.contribution, 'panel teardown', teardown);\n    this.cleanup(a.contribution, 'deactivate()', () => a.session.deactivate());\n    a.panelHost?.remove();\n  }\n\n  /**\n   * Forget recorded cleanup failures. The host calls this when the USER picks a\n   * plot type: an explicit choice gets a fresh attempt, only automatic\n   * re-activations fall back.\n   */\n  clearCleanupFailures(): void {\n    this.failedCleanup.clear();\n  }\n\n  // ── internals ──────────────────────────────────────────────────────────\n\n  private start(contribution: PlotTypeContribution, ctx: PlotModeContext,\n                session: PlotModeSession, gen: number): void {\n    const id = contribution.descriptor.type;\n    if (!session || typeof session.deactivate !== 'function') {\n      if (gen === this.generation) {\n        this.fail(contribution, new Error('activate() did not return a PlotModeSession'));\n      }\n      return;\n    }\n    if (gen !== this.generation) {\n      // Superseded while activate() was in flight — the user already left. The\n      // session still gets its single deactivate(), just late.\n      this.guardLogged(`'${id}' deactivate() of a superseded session`, () => session.deactivate());\n      return;\n    }\n    this.pendingId = null;\n    const panel = contribution.panel;\n    let panelHost: HTMLElement | null = null;\n    let teardown: (() => void) | null = null;\n    if (panel && 'mount' in panel && typeof panel.mount === 'function') {\n      panelHost = document.createElement('div');\n      panelHost.className = 'plot-mode-panel-host';\n      try {\n        const t = panel.mount(panelHost, ctx, session);\n        teardown = typeof t === 'function' ? t : null;\n      } catch (err) {\n        panelHost.remove();\n        this.guardLogged(`'${id}' deactivate()`, () => session.deactivate());\n        this.fail(contribution, err);\n        return;\n      }\n    }\n    this.active = { contribution, ctx, session, panelHost };\n    this.teardown = teardown;\n    try {\n      this.hooks.onActivated(this.active);\n    } catch (err) {\n      // The host could not show it (e.g. its panel failed to render): not a usable mode.\n      this.failActive(err);\n    }\n  }\n\n  /**\n   * The host could not make the live mode usable (its panel threw while being\n   * created or first rendered): end the session once, then fall back to its base.\n   * No-op when nothing is live.\n   */\n  failActive(err: unknown): void {\n    const a = this.active;\n    if (!a) return;\n    this.deactivate();\n    this.fail(a.contribution, err);\n  }\n\n  private fail(contribution: PlotTypeContribution, err: unknown): void {\n    this.pendingId = null;\n    this.log.error(`${TAG} '${contribution.descriptor.type}' failed to activate — `\n      + `falling back to '${contribution.descriptor.baseType}'.`, err);\n    try {\n      this.hooks.onFailed(contribution, err);\n    } catch (hookErr) {\n      this.log.error(`${TAG} fallback failed.`, hookErr);\n    }\n  }\n\n  private guard(what: string, fn: () => void): void {\n    try {\n      fn();\n    } catch (err) {\n      this.log.error(`${TAG} ${what} threw.`, err);\n    }\n  }\n\n  /** Like `guard`, for a contribution callback typed `void` that may still return a\n   *  promise: a rejection is logged instead of escaping as an unhandled rejection. */\n  private guardLogged(what: string, fn: () => unknown): void {\n    try {\n      const r = fn();\n      if (isThenable(r)) r.then(undefined, (err) => this.log.error(`${TAG} ${what} rejected.`, err));\n    } catch (err) {\n      this.log.error(`${TAG} ${what} threw.`, err);\n    }\n  }\n\n  /** Run a live session's cleanup; a throw OR a rejection goes to `cleanupFailed`. */\n  private cleanup(contribution: PlotTypeContribution, what: string, fn: () => unknown): void {\n    try {\n      const r = fn();\n      if (isThenable(r)) r.then(undefined, (err) => this.cleanupFailed(contribution, what, err));\n    } catch (err) {\n      this.cleanupFailed(contribution, what, err);\n    }\n  }\n\n  /**\n   * A contribution's cleanup failed. If that same contribution is live or starting\n   * again (a base re-render / image switch re-activated it — or, for an async\n   * rejection, already has), end it and fall back to its base type. Otherwise the\n   * user has moved on: remember it, so the next automatic re-activation falls back.\n   */\n  private cleanupFailed(contribution: PlotTypeContribution, what: string, err: unknown): void {\n    const id = contribution.descriptor.type;\n    this.log.error(`${TAG} '${id}' ${what} failed.`, err);\n    const again = this.active?.contribution === contribution || this.pendingId === id;\n    if (again) {\n      this.deactivate();\n      this.fail(contribution, err);\n    } else {\n      this.failedCleanup.set(id, err);\n    }\n  }\n\n  /** Call `cb(true)` once the viewport reports ready (now, or on a later\n   *  animation frame), or `cb(false)` after {@link MAX_READY_FRAMES}. */\n  private whenReady(ctx: PlotModeContext, gen: number, cb: (ready: boolean) => void): void {\n    const isReady = () => {\n      try { return ctx.viewport.isReady(); } catch { return false; }\n    };\n    if (isReady()) return cb(true);\n    let frames = 0;\n    const settle = (ready: boolean) => {\n      this.readyFrame = null;\n      this.readyCb = null;\n      cb(ready);\n    };\n    const tick = () => {\n      this.readyFrame = null;\n      if (gen !== this.generation) return settle(false);\n      if (isReady()) return settle(true);\n      if (++frames >= MAX_READY_FRAMES) return settle(false);\n      this.readyFrame = requestAnimationFrame(tick);\n    };\n    this.readyCb = settle;\n    this.readyFrame = requestAnimationFrame(tick);\n  }\n\n  /** Stop waiting for the viewport; the waiting activation resolves as superseded. */\n  private cancelReadyWait(): void {\n    if (this.readyFrame !== null) cancelAnimationFrame(this.readyFrame);\n    this.readyFrame = null;\n    const cb = this.readyCb;\n    this.readyCb = null;\n    cb?.(false);\n  }\n}\n\nfunction isThenable<T>(v: T | Promise<T> | unknown): v is Promise<T> {\n  return !!v && typeof (v as Promise<T>).then === 'function';\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-mode-controller.js","sourceRoot":"","sources":["../../../../src/lib/plot-mode/plot-mode-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlotType, PlotTypeId, isBuiltinPlotType } from '../contracts/plot-type';\nimport {\n  ContributedPlotTypeDescriptor,\n  PlotModeContext,\n  PlotModeSession,\n  PlotTypeContribution,\n} from '../contracts/plot-type-contribution.contract';\n\n/**\n * Lifecycle of the contributed plot modes ({@link PlotTypeContribution}) for one\n * visualizer instance. Package-internal: the visualizer component owns one and\n * drives it from its render pipeline.\n *\n * Owns three things the component should not have to reason about:\n *  - which contributions are usable (validated and de-duplicated once);\n *  - the single live session, so `deactivate()` runs exactly once per session\n *    however many exits race each other (type change, image change, destroy,\n *    a superseded async activation);\n *  - isolation: nothing a contribution throws or rejects escapes this class.\n *    A failure is logged and reported through `onFailed`, and the component\n *    falls back to the mode's base type.\n */\n\n/** The live activation of a contributed mode, as the component renders it. */\nexport interface ActivePlotMode {\n  readonly contribution: PlotTypeContribution;\n  readonly ctx: PlotModeContext;\n  readonly session: PlotModeSession;\n  /** Host element handed to a `mount` panel, or null for a component / no panel. */\n  readonly panelHost: HTMLElement | null;\n}\n\nexport interface PlotModeControllerHooks {\n  /** A session is live (and a `mount` panel, if any, has been mounted). */\n  onActivated(active: ActivePlotMode): void;\n  /** The live session is about to end. Called BEFORE any teardown, so a\n   *  component panel can be destroyed while its session is still valid. */\n  onDeactivating(active: ActivePlotMode): void;\n  /** Activation failed (threw, rejected, never got a ready viewport, or its\n   *  panel failed to mount). The component falls back to the base type. */\n  onFailed(contribution: PlotTypeContribution, error: unknown): void;\n}\n\n/** Minimal logger, injectable for tests. */\nexport interface PlotModeLogger {\n  warn(...args: unknown[]): void;\n  error(...args: unknown[]): void;\n}\n\n/** Base types a contributed mode can ride on in this version. */\nexport const SUPPORTED_CONTRIBUTION_BASE_TYPES: readonly PlotType[] = [PlotType.IMAGE];\n\n/** How many animation frames to wait for the viewport before giving up. */\nconst MAX_READY_FRAMES = 180;\n\nconst TAG = '[visualizer] plot-type contribution';\n\n/**\n * Validate what arrived on `PLOT_TYPE_CONTRIBUTIONS`. A malformed or clashing\n * contribution is dropped with a warning rather than breaking the selector:\n *  - a nested array (`useValue: [a, b], multi: true`) is flattened one level;\n *  - `type` must be a non-empty string that is not a built-in `PlotType` value;\n *  - the first contribution with a given `type` wins;\n *  - `baseType` must be one of {@link SUPPORTED_CONTRIBUTION_BASE_TYPES};\n *  - `activate` must be a function.\n */\nexport function normalizeContributions(\n  raw: readonly unknown[] | null | undefined,\n  log: PlotModeLogger = console,\n): PlotTypeContribution[] {\n  const out: PlotTypeContribution[] = [];\n  const seen = new Set<string>();\n  const flat = (raw ?? []).flatMap((c) => (Array.isArray(c) ? c : [c]));\n  for (const c of flat as PlotTypeContribution[]) {\n    const d = c?.descriptor as ContributedPlotTypeDescriptor | undefined;\n    const id = d?.type;\n    if (!d || typeof id !== 'string' || !id || typeof c.activate !== 'function') {\n      log.warn(`${TAG} ignored: it needs a descriptor with a string \\`type\\` and an \\`activate\\` function.`, c);\n      continue;\n    }\n    if (isBuiltinPlotType(id)) {\n      log.warn(`${TAG} '${id}' ignored: the id clashes with a built-in plot type.`);\n      continue;\n    }\n    if (seen.has(id)) {\n      log.warn(`${TAG} '${id}' ignored: another contribution already uses that id.`);\n      continue;\n    }\n    if (!SUPPORTED_CONTRIBUTION_BASE_TYPES.includes(d.baseType)) {\n      log.warn(\n        `${TAG} '${id}' ignored: baseType '${String(d.baseType)}' is not supported ` +\n          `(supported: ${SUPPORTED_CONTRIBUTION_BASE_TYPES.join(', ')}).`,\n      );\n      continue;\n    }\n    seen.add(id);\n    out.push(c);\n  }\n  return out;\n}\n\nexport class PlotModeController {\n  readonly contributions: readonly PlotTypeContribution[];\n  private readonly byId: ReadonlyMap<string, PlotTypeContribution>;\n\n  private active: ActivePlotMode | null = null;\n  private teardown: (() => void) | null = null;\n  /** Bumped by every activate/deactivate, so a pending async activation can\n   *  tell it has been superseded. */\n  private generation = 0;\n  private readyFrame: number | null = null;\n  /** Contributions whose last cleanup (panel teardown / `deactivate()`) threw or\n   *  rejected. Their next automatic re-activation (base re-render, image switch)\n   *  falls back to the base type instead; an explicit selection clears the mark. */\n  private readonly failedCleanup = new Map<string, unknown>();\n  private readyCb: ((ready: boolean) => void) | null = null;\n\n  constructor(\n    raw: readonly unknown[] | null | undefined,\n    private readonly hooks: PlotModeControllerHooks,\n    private readonly log: PlotModeLogger = console,\n  ) {\n    this.contributions = normalizeContributions(raw, log);\n    this.byId = new Map(this.contributions.map((c) => [c.descriptor.type, c]));\n  }\n\n  /** Descriptors of the usable contributions, in registration order. */\n  descriptors(): ContributedPlotTypeDescriptor[] {\n    return this.contributions.map((c) => c.descriptor);\n  }\n\n  /** The contribution for a selector id, if it is a contributed mode. */\n  find(id: PlotTypeId | null | undefined): PlotTypeContribution | undefined {\n    return typeof id === 'string' ? this.byId.get(id) : undefined;\n  }\n\n  /**\n   * The built-in type that renders `id`: a built-in type is itself, a\n   * contributed id is its `baseType`, and an id that is neither (a stale\n   * contributed id whose provider is gone) resolves to `PlotType.IMAGE`, the\n   * default view.\n   */\n  baseTypeOf(id: PlotTypeId | null | undefined): PlotType {\n    if (isBuiltinPlotType(id)) return id;\n    return this.find(id)?.descriptor.baseType ?? PlotType.IMAGE;\n  }\n\n  /** The live session, if any. */\n  get current(): ActivePlotMode | null {\n    return this.active;\n  }\n\n  /** Whether an activation is waiting on the contribution or the viewport. */\n  get pending(): boolean {\n    return this.pendingId !== null;\n  }\n  private pendingId: string | null = null;\n\n  /**\n   * Start a session for `contribution`. Ends any live one first. Resolves when\n   * the attempt has finished (successfully or not); it never rejects.\n   */\n  activate(contribution: PlotTypeContribution, ctx: PlotModeContext): Promise<void> {\n    this.deactivate();\n    const id = contribution.descriptor.type;\n    if (this.failedCleanup.has(id)) {\n      // Its previous session did not end cleanly; do not stack a new one on top.\n      const err = this.failedCleanup.get(id);\n      this.failedCleanup.delete(id);\n      this.fail(contribution, err);\n      return Promise.resolve();\n    }\n    const gen = ++this.generation;\n    this.pendingId = id;\n    return new Promise<void>((resolve) => {\n      this.whenReady(ctx, gen, (ready) => {\n        if (gen !== this.generation) return resolve();\n        if (!ready) {\n          this.fail(contribution, new Error('the viewport never became ready'));\n          return resolve();\n        }\n        let result: PlotModeSession | Promise<PlotModeSession>;\n        try {\n          result = contribution.activate(ctx);\n        } catch (err) {\n          this.fail(contribution, err);\n          return resolve();\n        }\n        if (isThenable(result)) {\n          result.then(\n            (session) => {\n              this.start(contribution, ctx, session, gen);\n              resolve();\n            },\n            (err) => {\n              if (gen === this.generation) this.fail(contribution, err);\n              resolve();\n            },\n          );\n        } else {\n          this.start(contribution, ctx, result, gen);\n          resolve();\n        }\n      });\n    });\n  }\n\n  /**\n   * End the live session, if any: the component panel is dropped (via\n   * `onDeactivating`), a `mount` panel's teardown runs, then\n   * `session.deactivate()`, then the mount host is removed. Each step is\n   * isolated. A pending activation is cancelled; if it resolves later its\n   * session is deactivated on arrival. Idempotent.\n   */\n  deactivate(): void {\n    this.generation++;\n    this.pendingId = null;\n    this.cancelReadyWait();\n    const a = this.active;\n    if (!a) return;\n    this.active = null;\n    const teardown = this.teardown;\n    this.teardown = null;\n    const id = a.contribution.descriptor.type;\n    this.guard(`'${id}' panel removal`, () => this.hooks.onDeactivating(a));\n    if (teardown) this.cleanup(a.contribution, 'panel teardown', teardown);\n    this.cleanup(a.contribution, 'deactivate()', () => a.session.deactivate());\n    a.panelHost?.remove();\n  }\n\n  /**\n   * Forget recorded cleanup failures. The host calls this when the USER picks a\n   * plot type: an explicit choice gets a fresh attempt, only automatic\n   * re-activations fall back.\n   */\n  clearCleanupFailures(): void {\n    this.failedCleanup.clear();\n  }\n\n  // ── internals ──────────────────────────────────────────────────────────\n\n  private start(\n    contribution: PlotTypeContribution,\n    ctx: PlotModeContext,\n    session: PlotModeSession,\n    gen: number,\n  ): void {\n    const id = contribution.descriptor.type;\n    if (!session || typeof session.deactivate !== 'function') {\n      if (gen === this.generation) {\n        this.fail(contribution, new Error('activate() did not return a PlotModeSession'));\n      }\n      return;\n    }\n    if (gen !== this.generation) {\n      // Superseded while activate() was in flight — the user already left. The\n      // session still gets its single deactivate(), just late.\n      this.guardLogged(`'${id}' deactivate() of a superseded session`, () => session.deactivate());\n      return;\n    }\n    this.pendingId = null;\n    const panel = contribution.panel;\n    let panelHost: HTMLElement | null = null;\n    let teardown: (() => void) | null = null;\n    if (panel && 'mount' in panel && typeof panel.mount === 'function') {\n      panelHost = document.createElement('div');\n      panelHost.className = 'plot-mode-panel-host';\n      try {\n        const t = panel.mount(panelHost, ctx, session);\n        teardown = typeof t === 'function' ? t : null;\n      } catch (err) {\n        panelHost.remove();\n        this.guardLogged(`'${id}' deactivate()`, () => session.deactivate());\n        this.fail(contribution, err);\n        return;\n      }\n    }\n    this.active = { contribution, ctx, session, panelHost };\n    this.teardown = teardown;\n    try {\n      this.hooks.onActivated(this.active);\n    } catch (err) {\n      // The host could not show it (e.g. its panel failed to render): not a usable mode.\n      this.failActive(err);\n    }\n  }\n\n  /**\n   * The host could not make the live mode usable (its panel threw while being\n   * created or first rendered): end the session once, then fall back to its base.\n   * No-op when nothing is live.\n   */\n  failActive(err: unknown): void {\n    const a = this.active;\n    if (!a) return;\n    this.deactivate();\n    this.fail(a.contribution, err);\n  }\n\n  private fail(contribution: PlotTypeContribution, err: unknown): void {\n    this.pendingId = null;\n    this.log.error(\n      `${TAG} '${contribution.descriptor.type}' failed to activate — ` +\n        `falling back to '${contribution.descriptor.baseType}'.`,\n      err,\n    );\n    try {\n      this.hooks.onFailed(contribution, err);\n    } catch (hookErr) {\n      this.log.error(`${TAG} fallback failed.`, hookErr);\n    }\n  }\n\n  private guard(what: string, fn: () => void): void {\n    try {\n      fn();\n    } catch (err) {\n      this.log.error(`${TAG} ${what} threw.`, err);\n    }\n  }\n\n  /** Like `guard`, for a contribution callback typed `void` that may still return a\n   *  promise: a rejection is logged instead of escaping as an unhandled rejection. */\n  private guardLogged(what: string, fn: () => unknown): void {\n    try {\n      const r = fn();\n      if (isThenable(r)) r.then(undefined, (err) => this.log.error(`${TAG} ${what} rejected.`, err));\n    } catch (err) {\n      this.log.error(`${TAG} ${what} threw.`, err);\n    }\n  }\n\n  /** Run a live session's cleanup; a throw OR a rejection goes to `cleanupFailed`. */\n  private cleanup(contribution: PlotTypeContribution, what: string, fn: () => unknown): void {\n    try {\n      const r = fn();\n      if (isThenable(r)) r.then(undefined, (err) => this.cleanupFailed(contribution, what, err));\n    } catch (err) {\n      this.cleanupFailed(contribution, what, err);\n    }\n  }\n\n  /**\n   * A contribution's cleanup failed. If that same contribution is live or starting\n   * again (a base re-render / image switch re-activated it — or, for an async\n   * rejection, already has), end it and fall back to its base type. Otherwise the\n   * user has moved on: remember it, so the next automatic re-activation falls back.\n   */\n  private cleanupFailed(contribution: PlotTypeContribution, what: string, err: unknown): void {\n    const id = contribution.descriptor.type;\n    this.log.error(`${TAG} '${id}' ${what} failed.`, err);\n    const again = this.active?.contribution === contribution || this.pendingId === id;\n    if (again) {\n      this.deactivate();\n      this.fail(contribution, err);\n    } else {\n      this.failedCleanup.set(id, err);\n    }\n  }\n\n  /** Call `cb(true)` once the viewport reports ready (now, or on a later\n   *  animation frame), or `cb(false)` after {@link MAX_READY_FRAMES}. */\n  private whenReady(ctx: PlotModeContext, gen: number, cb: (ready: boolean) => void): void {\n    const isReady = () => {\n      try {\n        return ctx.viewport.isReady();\n      } catch {\n        return false;\n      }\n    };\n    if (isReady()) return cb(true);\n    let frames = 0;\n    const settle = (ready: boolean) => {\n      this.readyFrame = null;\n      this.readyCb = null;\n      cb(ready);\n    };\n    const tick = () => {\n      this.readyFrame = null;\n      if (gen !== this.generation) return settle(false);\n      if (isReady()) return settle(true);\n      if (++frames >= MAX_READY_FRAMES) return settle(false);\n      this.readyFrame = requestAnimationFrame(tick);\n    };\n    this.readyCb = settle;\n    this.readyFrame = requestAnimationFrame(tick);\n  }\n\n  /** Stop waiting for the viewport; the waiting activation resolves as superseded. */\n  private cancelReadyWait(): void {\n    if (this.readyFrame !== null) cancelAnimationFrame(this.readyFrame);\n    this.readyFrame = null;\n    const cb = this.readyCb;\n    this.readyCb = null;\n    cb?.(false);\n  }\n}\n\nfunction isThenable<T>(v: T | Promise<T> | unknown): v is Promise<T> {\n  return !!v && typeof (v as Promise<T>).then === 'function';\n}\n"]}