@jax-data-science/sci-image-visualizer 0.4.0 → 0.6.0

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

@@ -0,0 +1,329 @@
+import { PlotType, isBuiltinPlotType } from '../contracts/plot-type';
+/** Base types a contributed mode can ride on in this version. */
+export const SUPPORTED_CONTRIBUTION_BASE_TYPES = [PlotType.IMAGE];
+/** How many animation frames to wait for the viewport before giving up. */
+const MAX_READY_FRAMES = 180;
+const TAG = '[visualizer] plot-type contribution';
+/**
+ * Validate what arrived on `PLOT_TYPE_CONTRIBUTIONS`. A malformed or clashing
+ * contribution is dropped with a warning rather than breaking the selector:
+ *  - a nested array (`useValue: [a, b], multi: true`) is flattened one level;
+ *  - `type` must be a non-empty string that is not a built-in `PlotType` value;
+ *  - the first contribution with a given `type` wins;
+ *  - `baseType` must be one of {@link SUPPORTED_CONTRIBUTION_BASE_TYPES};
+ *  - `activate` must be a function.
+ */
+export function normalizeContributions(raw, log = console) {
+    const out = [];
+    const seen = new Set();
+    const flat = (raw ?? []).flatMap((c) => (Array.isArray(c) ? c : [c]));
+    for (const c of flat) {
+        const d = c?.descriptor;
+        const id = d?.type;
+        if (!d || typeof id !== 'string' || !id || typeof c.activate !== 'function') {
+            log.warn(`${TAG} ignored: it needs a descriptor with a string \`type\` and an \`activate\` function.`, c);
+            continue;
+        }
+        if (isBuiltinPlotType(id)) {
+            log.warn(`${TAG} '${id}' ignored: the id clashes with a built-in plot type.`);
+            continue;
+        }
+        if (seen.has(id)) {
+            log.warn(`${TAG} '${id}' ignored: another contribution already uses that id.`);
+            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(', ')}).`);
+            continue;
+        }
+        seen.add(id);
+        out.push(c);
+    }
+    return out;
+}
+export class PlotModeController {
+    constructor(raw, hooks, log = console) {
+        this.hooks = hooks;
+        this.log = log;
+        this.active = null;
+        this.teardown = null;
+        /** Bumped by every activate/deactivate, so a pending async activation can
+         *  tell it has been superseded. */
+        this.generation = 0;
+        this.readyFrame = null;
+        /** Contributions whose last cleanup (panel teardown / `deactivate()`) threw or
+         *  rejected. Their next automatic re-activation (base re-render, image switch)
+         *  falls back to the base type instead; an explicit selection clears the mark. */
+        this.failedCleanup = new Map();
+        this.readyCb = null;
+        this.pendingId = null;
+        this.contributions = normalizeContributions(raw, log);
+        this.byId = new Map(this.contributions.map((c) => [c.descriptor.type, c]));
+    }
+    /** Descriptors of the usable contributions, in registration order. */
+    descriptors() {
+        return this.contributions.map((c) => c.descriptor);
+    }
+    /** The contribution for a selector id, if it is a contributed mode. */
+    find(id) {
+        return typeof id === 'string' ? this.byId.get(id) : undefined;
+    }
+    /**
+     * The built-in type that renders `id`: a built-in type is itself, a
+     * contributed id is its `baseType`, and an id that is neither (a stale
+     * contributed id whose provider is gone) resolves to `PlotType.IMAGE`, the
+     * default view.
+     */
+    baseTypeOf(id) {
+        if (isBuiltinPlotType(id))
+            return id;
+        return this.find(id)?.descriptor.baseType ?? PlotType.IMAGE;
+    }
+    /** The live session, if any. */
+    get current() {
+        return this.active;
+    }
+    /** Whether an activation is waiting on the contribution or the viewport. */
+    get pending() {
+        return this.pendingId !== null;
+    }
+    /**
+     * Start a session for `contribution`. Ends any live one first. Resolves when
+     * the attempt has finished (successfully or not); it never rejects.
+     */
+    activate(contribution, ctx) {
+        this.deactivate();
+        const id = contribution.descriptor.type;
+        if (this.failedCleanup.has(id)) {
+            // Its previous session did not end cleanly; do not stack a new one on top.
+            const err = this.failedCleanup.get(id);
+            this.failedCleanup.delete(id);
+            this.fail(contribution, err);
+            return Promise.resolve();
+        }
+        const gen = ++this.generation;
+        this.pendingId = id;
+        return new Promise((resolve) => {
+            this.whenReady(ctx, gen, (ready) => {
+                if (gen !== this.generation)
+                    return resolve();
+                if (!ready) {
+                    this.fail(contribution, new Error('the viewport never became ready'));
+                    return resolve();
+                }
+                let result;
+                try {
+                    result = contribution.activate(ctx);
+                }
+                catch (err) {
+                    this.fail(contribution, err);
+                    return resolve();
+                }
+                if (isThenable(result)) {
+                    result.then((session) => { this.start(contribution, ctx, session, gen); resolve(); }, (err) => {
+                        if (gen === this.generation)
+                            this.fail(contribution, err);
+                        resolve();
+                    });
+                }
+                else {
+                    this.start(contribution, ctx, result, gen);
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * End the live session, if any: the component panel is dropped (via
+     * `onDeactivating`), a `mount` panel's teardown runs, then
+     * `session.deactivate()`, then the mount host is removed. Each step is
+     * isolated. A pending activation is cancelled; if it resolves later its
+     * session is deactivated on arrival. Idempotent.
+     */
+    deactivate() {
+        this.generation++;
+        this.pendingId = null;
+        this.cancelReadyWait();
+        const a = this.active;
+        if (!a)
+            return;
+        this.active = null;
+        const teardown = this.teardown;
+        this.teardown = null;
+        const id = a.contribution.descriptor.type;
+        this.guard(`'${id}' panel removal`, () => this.hooks.onDeactivating(a));
+        if (teardown)
+            this.cleanup(a.contribution, 'panel teardown', teardown);
+        this.cleanup(a.contribution, 'deactivate()', () => a.session.deactivate());
+        a.panelHost?.remove();
+    }
+    /**
+     * Forget recorded cleanup failures. The host calls this when the USER picks a
+     * plot type: an explicit choice gets a fresh attempt, only automatic
+     * re-activations fall back.
+     */
+    clearCleanupFailures() {
+        this.failedCleanup.clear();
+    }
+    // ── internals ──────────────────────────────────────────────────────────
+    start(contribution, ctx, session, gen) {
+        const id = contribution.descriptor.type;
+        if (!session || typeof session.deactivate !== 'function') {
+            if (gen === this.generation) {
+                this.fail(contribution, new Error('activate() did not return a PlotModeSession'));
+            }
+            return;
+        }
+        if (gen !== this.generation) {
+            // Superseded while activate() was in flight — the user already left. The
+            // session still gets its single deactivate(), just late.
+            this.guardLogged(`'${id}' deactivate() of a superseded session`, () => session.deactivate());
+            return;
+        }
+        this.pendingId = null;
+        const panel = contribution.panel;
+        let panelHost = null;
+        let teardown = null;
+        if (panel && 'mount' in panel && typeof panel.mount === 'function') {
+            panelHost = document.createElement('div');
+            panelHost.className = 'plot-mode-panel-host';
+            try {
+                const t = panel.mount(panelHost, ctx, session);
+                teardown = typeof t === 'function' ? t : null;
+            }
+            catch (err) {
+                panelHost.remove();
+                this.guardLogged(`'${id}' deactivate()`, () => session.deactivate());
+                this.fail(contribution, err);
+                return;
+            }
+        }
+        this.active = { contribution, ctx, session, panelHost };
+        this.teardown = teardown;
+        try {
+            this.hooks.onActivated(this.active);
+        }
+        catch (err) {
+            // The host could not show it (e.g. its panel failed to render): not a usable mode.
+            this.failActive(err);
+        }
+    }
+    /**
+     * The host could not make the live mode usable (its panel threw while being
+     * created or first rendered): end the session once, then fall back to its base.
+     * No-op when nothing is live.
+     */
+    failActive(err) {
+        const a = this.active;
+        if (!a)
+            return;
+        this.deactivate();
+        this.fail(a.contribution, err);
+    }
+    fail(contribution, err) {
+        this.pendingId = null;
+        this.log.error(`${TAG} '${contribution.descriptor.type}' failed to activate — `
+            + `falling back to '${contribution.descriptor.baseType}'.`, err);
+        try {
+            this.hooks.onFailed(contribution, err);
+        }
+        catch (hookErr) {
+            this.log.error(`${TAG} fallback failed.`, hookErr);
+        }
+    }
+    guard(what, fn) {
+        try {
+            fn();
+        }
+        catch (err) {
+            this.log.error(`${TAG} ${what} threw.`, err);
+        }
+    }
+    /** Like `guard`, for a contribution callback typed `void` that may still return a
+     *  promise: a rejection is logged instead of escaping as an unhandled rejection. */
+    guardLogged(what, fn) {
+        try {
+            const r = fn();
+            if (isThenable(r))
+                r.then(undefined, (err) => this.log.error(`${TAG} ${what} rejected.`, err));
+        }
+        catch (err) {
+            this.log.error(`${TAG} ${what} threw.`, err);
+        }
+    }
+    /** Run a live session's cleanup; a throw OR a rejection goes to `cleanupFailed`. */
+    cleanup(contribution, what, fn) {
+        try {
+            const r = fn();
+            if (isThenable(r))
+                r.then(undefined, (err) => this.cleanupFailed(contribution, what, err));
+        }
+        catch (err) {
+            this.cleanupFailed(contribution, what, err);
+        }
+    }
+    /**
+     * A contribution's cleanup failed. If that same contribution is live or starting
+     * again (a base re-render / image switch re-activated it — or, for an async
+     * rejection, already has), end it and fall back to its base type. Otherwise the
+     * user has moved on: remember it, so the next automatic re-activation falls back.
+     */
+    cleanupFailed(contribution, what, err) {
+        const id = contribution.descriptor.type;
+        this.log.error(`${TAG} '${id}' ${what} failed.`, err);
+        const again = this.active?.contribution === contribution || this.pendingId === id;
+        if (again) {
+            this.deactivate();
+            this.fail(contribution, err);
+        }
+        else {
+            this.failedCleanup.set(id, err);
+        }
+    }
+    /** Call `cb(true)` once the viewport reports ready (now, or on a later
+     *  animation frame), or `cb(false)` after {@link MAX_READY_FRAMES}. */
+    whenReady(ctx, gen, cb) {
+        const isReady = () => {
+            try {
+                return ctx.viewport.isReady();
+            }
+            catch {
+                return false;
+            }
+        };
+        if (isReady())
+            return cb(true);
+        let frames = 0;
+        const settle = (ready) => {
+            this.readyFrame = null;
+            this.readyCb = null;
+            cb(ready);
+        };
+        const tick = () => {
+            this.readyFrame = null;
+            if (gen !== this.generation)
+                return settle(false);
+            if (isReady())
+                return settle(true);
+            if (++frames >= MAX_READY_FRAMES)
+                return settle(false);
+            this.readyFrame = requestAnimationFrame(tick);
+        };
+        this.readyCb = settle;
+        this.readyFrame = requestAnimationFrame(tick);
+    }
+    /** Stop waiting for the viewport; the waiting activation resolves as superseded. */
+    cancelReadyWait() {
+        if (this.readyFrame !== null)
+            cancelAnimationFrame(this.readyFrame);
+        this.readyFrame = null;
+        const cb = this.readyCb;
+        this.readyCb = null;
+        cb?.(false);
+    }
+}
+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"]}