@perspective-dev/viewer-charts 4.5.1 → 5.0.0

package/src/ts/plugin/plugin.ts

@@ -125,6 +125,22 @@ const GLOBAL_STYLES = (() => {
     return [sheet];
 })();
 
+/**
+ * Process-global GL presentation strategy, shared by *every* chart-type
+ * plugin in this renderer. Seeded from the build-time {@link RENDER_BLIT_MODE}
+ * and overridable at runtime via
+ * {@link HTMLPerspectiveViewerWebGLPluginElement.setBlitMode}.
+ *
+ * Module scope (not per-instance) on purpose: blit-vs-direct is a
+ * whole-renderer decision — in `"blit"` mode the worker shares a pool of
+ * GL contexts across all charts ([webgl/context-pool.ts]), so a page
+ * can't sensibly mix strategies per chart. Every per-chart-type subclass
+ * registered in [index.ts] reads this one value when it builds its
+ * renderer, so setting it once (before the first chart renders) applies
+ * to all of them.
+ */
+let BLIT_MODE: "direct" | "blit" = RENDER_BLIT_MODE;
+
 export class HTMLPerspectiveViewerWebGLPluginElement
     extends HTMLElement
     implements IPerspectiveViewerPlugin
@@ -138,8 +154,6 @@ export class HTMLPerspectiveViewerWebGLPluginElement
     private _renderer: RendererTransport | null = null;
     private _rendererPromise: Promise<RendererTransport> | null = null;
     private _rawEventForwarder: RawEventForwarder | null = null;
-    private _generation = 0;
-    private _renderBlitMode: "direct" | "blit" = RENDER_BLIT_MODE;
     private _resetClickAbort: AbortController | null = null;
 
     /**
@@ -257,13 +271,40 @@ export class HTMLPerspectiveViewerWebGLPluginElement
             return this._rendererPromise;
         }
 
-        this._rendererPromise = this._buildRenderer(view).then((r) => {
-            this._renderer = r;
-            this._setupInteraction(r);
-            return r;
-        });
+        // `_buildRenderer` is async — it awaits `getClient`, `getTable`,
+        // and a full worker handshake — so a `disconnectedCallback`
+        // (toggle / chart-type switch) frequently lands *before* this
+        // `.then` runs. At that point `this._renderer` is still null,
+        // so `delete()`'s `if (this._renderer)` teardown is skipped and
+        // the freshly-built transport (and its WebGL context) would be
+        // assigned to a detached element and leak — one context per
+        // raced toggle, until the browser evicts the oldest.
+        //
+        // `delete()` sets `_rendererPromise = null`, so promise identity
+        // is the dispose signal: if `this._rendererPromise` no longer
+        // points at *this* build when it resolves, the element was
+        // deleted (or a reconnect started a newer build) and we destroy
+        // the orphan instead of adopting it. Promise identity is the
+        // right token: a rapid draw→update must NOT tear down the
+        // single in-flight build it shares via this memoized promise.
+        const p: Promise<RendererTransport> = this._buildRenderer(view).then(
+            (r) => {
+                if (this._rendererPromise !== p) {
+                    r.destroy();
+                    throw new Error("renderer disposed during init");
+                }
+
+                this._renderer = r;
+                this._setupInteraction(r);
+                return r;
+            },
+        );
 
-        return this._rendererPromise;
+        // Swallow the dispose rejection so it doesn't surface as an
+        // unhandled rejection; `_drawImpl` catches it and bails.
+        p.catch(() => {});
+        this._rendererPromise = p;
+        return p;
     }
 
     /**
@@ -310,11 +351,16 @@ export class HTMLPerspectiveViewerWebGLPluginElement
 
     private async _buildRenderer(view: View): Promise<RendererTransport> {
         const viewer = this.parentElement as HTMLPerspectiveViewerElement;
-        const client = await viewer.getClient();
+        // This chart's own panel (its `slot`). Used to scope the client/table
+        // to THIS panel rather than the host's active/seed panel (the bare
+        // getClient()/getTable() resolve element-wide in a multi-panel viewer),
+        // and to tag the dispatched interaction events with their source panel.
+        const panel = this.getAttribute("slot") ?? undefined;
+        const client = await viewer.getClient({ panel });
         const viewer_class = customElements.get("perspective-viewer");
         const clientWasm = viewer_class.get_wasm_module();
         const clientWorkerURL = viewer_class.get_worker_url();
-        const table = await viewer?.getTable?.();
+        const table = await viewer?.getTable?.({ panel });
         const tableName: string | undefined = table
             ? await table.get_name()
             : undefined;
@@ -327,6 +373,7 @@ export class HTMLPerspectiveViewerWebGLPluginElement
             client,
             view,
             tableName,
+            panel,
             clientWorkerURL,
             clientWasm,
             chartTag: this._chartType.tag,
@@ -350,15 +397,28 @@ export class HTMLPerspectiveViewerWebGLPluginElement
             },
             pluginConfig: this._pluginConfig,
             defaultChartType: this._chartType.default_chart_type,
-            renderBlitMode: this._renderBlitMode,
+            renderBlitMode: BLIT_MODE,
         });
 
         return transport;
     }
 
-    setBlitMode(mode: "direct" | "blit") {
-        console.assert(this._initialized, "Already initialized");
-        this._renderBlitMode = mode;
+    /**
+     * Select the GL presentation strategy for *all* chart-type plugins
+     * in this renderer. Static + process-global: the value is shared by
+     * every per-chart-type subclass, so it must be set once before the
+     * charts that should use it build their renderers (a renderer reads
+     * {@link BLIT_MODE} at construction in `_buildRenderer`; charts
+     * already built keep their mode until torn down and rebuilt).
+     *
+     * - `"direct"` — each chart owns a GL context 1:1 with its visible
+     *   canvas (lowest latency; bounded by the browser's ~16-context
+     *   cap).
+     * - `"blit"` — charts render off-screen and share a pool of GL
+     *   contexts ([webgl/context-pool.ts]), so a page can exceed the cap.
+     */
+    static setBlitMode(mode: "direct" | "blit") {
+        BLIT_MODE = mode;
     }
 
     get_static_config(): PluginStaticConfig {
@@ -497,22 +557,36 @@ export class HTMLPerspectiveViewerWebGLPluginElement
         return this._drawImpl(view);
     }
 
+    /**
+     * Shared body of `draw` / `update`. No re-entrancy guard: the host
+     * serializes every rendering call (`draw`, `update`, `render`,
+     * `resize`) and `delete` on its per-renderer draw lock, so this
+     * method never overlaps itself or a teardown. The one exception —
+     * an external DOM disconnect `delete()`ing the element mid-draw —
+     * is absorbed by `RendererTransport`, whose post-`destroy()`
+     * requests settle immediately instead of pending forever.
+     */
     private async _drawImpl(view: View): Promise<void> {
-        const gen = ++this._generation;
-        const renderer = await this._ensureRenderer(view);
-        if (this._generation !== gen) {
+        let renderer: RendererTransport;
+        try {
+            renderer = await this._ensureRenderer(view);
+        } catch {
+            // Renderer was disposed mid-init (element disconnected
+            // during the async build) — nothing to draw.
             return;
         }
 
         renderer.setView(view);
         renderer.setBufferMaxCapacity(this._chartType.max_cells);
+        const panel = this.getAttribute("slot") ?? undefined;
         const viewer = this
             .parentElement as HTMLPerspectiveViewerElement | null;
-        const viewerConfig = (await viewer?.getViewConfig?.()) ?? {};
-        if (this._generation !== gen) {
+
+        if (viewer === null) {
             return;
         }
 
+        const viewerConfig = await viewer.getViewConfig({ panel });
         await renderer.loadAndRender({
             viewerConfig: {
                 group_by: viewerConfig?.group_by ?? [],
@@ -524,17 +598,78 @@ export class HTMLPerspectiveViewerWebGLPluginElement
     }
 
     async clear(): Promise<void> {
-        this._generation++;
         this._renderer?.clear();
     }
 
     async resize(): Promise<void> {
-        this._renderer?.resize();
+        // Hidden (an unslotted tab-stack panel, a `display: none` host):
+        // the 0×0 rect a hidden element reports would resize the worker
+        // canvas to zero — CLEARING the retained frame, so the next
+        // activation repaints from blank (the two-stage tab-switch
+        // artifact). Skip instead and keep the last frame for an instant,
+        // single-blit reveal — mirroring the datagrid's guard. The host's
+        // activation nudge is also a `resize()`, so a hidden panel's nudge
+        // is free by the same check.
+        if (!this.isConnected || this.offsetParent == null) {
+            return;
+        }
+
+        // AWAITED to the resized frame's PRESENT (the worker's
+        // `resizeAck`) — the host's presize protocol style-overrides
+        // this element to its target box and holds the layout commit on
+        // this promise, so resolving at message-post would commit the
+        // settings-pane layout against the old-dimensions bitmap (the
+        // aspect-ratio warp the datagrid's synchronous resize never
+        // shows).
+        await this._renderer?.resize();
+    }
+
+    /**
+     * OPTIONAL host presize protocol: render at the TARGET element box
+     * `(width, height)` — the box the host's pending layout commit will
+     * produce — holding the resulting frame offscreen, so nothing on
+     * screen changes during the round-trip. Resolves, once the resized
+     * frame is staged, to a present closure; the host calls it in the
+     * same task as the layout commit, landing geometry and pixels in
+     * one paint. Plugins without this method get the host's held
+     * style-override presize path instead.
+     */
+    async presize(width: number, height: number): Promise<(() => void) | void> {
+        if (
+            !this.isConnected ||
+            this.offsetParent == null ||
+            !this._renderer ||
+            !this._glCanvas
+        ) {
+            return;
+        }
+
+        // Target GL-canvas box = its current box shifted by the element's
+        // box delta — the chrome between the element edge and the canvas
+        // is constant across a resize.
+        const hostRect = this.getBoundingClientRect();
+        const glRect = this._glCanvas.getBoundingClientRect();
+        return await this._renderer.presize(
+            Math.max(0, glRect.width + (width - hostRect.width)),
+            Math.max(0, glRect.height + (height - hostRect.height)),
+        );
     }
 
     restyle() {
         this._renderer?.invalidateTheme();
-        return 5;
+    }
+
+    /**
+     * Clear any active selection state (pinned tooltip) WITHOUT emitting
+     * selection events — the host calls this when a global filter
+     * contributed by this panel's selection is removed from the global
+     * filter bar, so the pin can't outlive the filter it produced. The
+     * transport's `_lastInsertConfig` (remove-set memory) is deliberately
+     * RETAINED so a subsequent selection still replaces any leftover
+     * clauses rather than accumulating.
+     */
+    async deselect(): Promise<void> {
+        this._renderer?.deselect();
     }
 
     async render(view: View): Promise<Blob> {
@@ -563,7 +698,6 @@ export class HTMLPerspectiveViewerWebGLPluginElement
     }
 
     delete() {
-        this._generation++;
         if (this._rawEventForwarder) {
             this._rawEventForwarder.detach();
             this._rawEventForwarder = null;

package/src/ts/render/scheduler.ts

@@ -16,8 +16,8 @@ import type { WebGLContextManager } from "../webgl/context-manager";
  * Module-level render scheduler. The single entry point for driving a
  * chart frame. Every render-triggering caller — upload chunks, zoom /
  * pan, resize, theme invalidation, host-driven redraws — calls
- * `requestRender(glManager, fullRender)` and awaits the returned
- * promise.
+ * `requestRender(glManager, fullRender, render2D)` and awaits the
+ * returned promise.
  *
  * ## Guarantees
  *
@@ -51,9 +51,12 @@ import type { WebGLContextManager } from "../webgl/context-manager";
  *     begins, letting per-context GPU work overlap.
  *
  *   - **Phase 2 (parallel):** `Promise.all(snapshot.map(present))`
- *     where `present` does `await awaitGpuFence(); endFrame();
- *     resolve waiters`. Each entry's waiters resolve as soon as its
- *     own present completes — independent of other entries.
+ *     where `present` does `await awaitGpuFence(); render2D();
+ *     endFrame(); resolve waiters`. The `render2D()` step draws the 2D
+ *     layers (gridlines + chrome) only after the GPU fence, so the 2D
+ *     placeholder canvases don't present a frame ahead of the GL frame
+ *     on resize. Each entry's waiters resolve as soon as its own
+ *     present completes — independent of other entries.
  *
  * ## Failure modes
  *
@@ -78,6 +81,15 @@ import type { WebGLContextManager } from "../webgl/context-manager";
 interface Entry {
     glManager: WebGLContextManager;
     fullRender: () => void;
+    /**
+     * The chart's 2D-canvas draws (gridlines + chrome), split out of
+     * `fullRender` so they run *after* `awaitGpuFence` — see
+     * {@link present}. Deferring the 2D work past the GPU fence keeps
+     * the 2D placeholder canvases from pushing a resized frame to the
+     * compositor a frame ahead of the GL present (the GL/2D "distortion"
+     * on resize). Populated as captured closures during `fullRender`.
+     */
+    render2D: () => void;
     waiters: PromiseWithResolvers<void>[];
 }
 
@@ -105,25 +117,30 @@ const inFlight = new Set<WebGLContextManager>();
 const deferred = new Map<WebGLContextManager, (() => void)[]>();
 
 /**
- * Request a coalesced render of `glManager` whose body is
- * `fullRender`. Returns a promise that resolves when this entry's
- * Phase 2 (`awaitGpuFence` + `endFrame`) completes.
+ * Request a coalesced render of `glManager`. `fullRender` submits the
+ * GL commands (Phase 1, synchronous); `render2D` draws the 2D layers
+ * (gridlines + chrome) and runs in Phase 2 *after* `awaitGpuFence`, so
+ * the 2D canvases don't present ahead of the GL frame. Returns a
+ * promise that resolves when this entry's Phase 2 (`awaitGpuFence` +
+ * `render2D` + `endFrame`) completes.
  *
  * If a request is already pending for the same glManager, the new
- * call's `fullRender` closure replaces the prior one (latest call
- * wins; closures read chart state lazily so this is functionally a
- * no-op, but keeps the closure fresh) and the returned promise
- * resolves alongside the existing waiters.
+ * call's `fullRender` / `render2D` closures replace the prior ones
+ * (latest call wins; closures read chart state lazily so this is
+ * functionally a no-op, but keeps the closures fresh) and the returned
+ * promise resolves alongside the existing waiters.
  */
 export function requestRender(
     glManager: WebGLContextManager,
     fullRender: () => void,
+    render2D: () => void,
 ): Promise<void> {
     let entry = pending.get(glManager);
     if (entry) {
         entry.fullRender = fullRender;
+        entry.render2D = render2D;
     } else {
-        entry = { glManager, fullRender, waiters: [] };
+        entry = { glManager, fullRender, render2D, waiters: [] };
         pending.set(glManager, entry);
     }
 
@@ -177,6 +194,41 @@ export function deferIfDraining(
     ops.push(op);
 }
 
+/**
+ * Drop every scheduler reference to `glManager` — called from
+ * `WebGLContextManager`'s owning renderer at teardown, *before*
+ * `glManager.destroy()` loses the GL context.
+ *
+ * Without this, a frame queued for the next RAF (an `Entry` in
+ * `pending`) or a `deferIfDraining` op still parked in `deferred`
+ * would survive the destroy and, on the next `drain()`, drive
+ * `fullRender` / `present` against a context-lost manager. In blit
+ * mode that surfaces as `endFrame`'s `transferToImageBitmap` throwing
+ * "Cannot transfer to ImageBitmap because WebGL context is lost" —
+ * logged as "scheduler: present failed". In direct mode it's a wasted
+ * paint against a dead context.
+ *
+ * Outstanding waiters for a destroyed manager are resolved (not
+ * rejected): the caller asked to tear the chart down, so its awaited
+ * `draw()` should observe a clean no-op rather than an error it would
+ * have to suppress. An in-flight `present()` (manager in `inFlight`)
+ * is left to unwind on its own — its `finally` clause will not find a
+ * `deferred` entry to flush, and the manager is already gone from
+ * `pending`, so it cannot re-enqueue.
+ */
+export function unregister(glManager: WebGLContextManager): void {
+    const entry = pending.get(glManager);
+    if (entry) {
+        pending.delete(glManager);
+        for (const w of entry.waiters) {
+            w.resolve();
+        }
+    }
+
+    deferred.delete(glManager);
+    inFlight.delete(glManager);
+}
+
 /**
  * Test-only: clear pending state. Production callers must not use
  * this — outstanding waiters are silently dropped.
@@ -230,31 +282,39 @@ export function _resetForTest(): void {
 async function drain(): Promise<void> {
     const snapshot = Array.from(pending.values());
     pending.clear();
-    const ready: Entry[] = [];
+
+    // Group ready entries by the GL context behind each manager. Under
+    // pooled blit mode many managers share one context (one drawing
+    // buffer): their renders MUST serialize — interleaving two charts'
+    // paints into one canvas would corrupt the bitmap the first ships.
+    // In the default 1:1 mode every manager has its own backend, so
+    // every group has exactly one entry and all groups run in parallel,
+    // exactly as before pooling.
+    const groups = new Map<number, Entry[]>();
     for (const entry of snapshot) {
-        try {
-            // Apply any dimension change recorded by
-            // `glManager.requestResize` *before* the paint, in the
-            // same un-yielded synchronous Phase 1 loop. This pairs
-            // the canvas-clearing `canvas.width = N` assignment
-            // with the immediately-following `_fullRender`, so the
-            // browser's compositor only ever observes the canvas
-            // post-paint. In direct/in-process modes the visible
-            // canvas IS the GL canvas, and a clear-without-matching-
-            // paint in the previous task would otherwise present an
-            // empty frame to the user.
-            entry.glManager.applyPendingResize();
-            entry.fullRender();
-            ready.push(entry);
-        } catch (err) {
-            console.error("scheduler: fullRender threw", err);
+        // The browser force-loses the oldest context when a page
+        // exceeds its per-agent WebGL context cap (~16). A frame queued
+        // before that eviction would paint + present against a dead
+        // context; skip it and settle its waiters cleanly rather than
+        // letting `endFrame`'s `transferToImageBitmap` throw.
+        if (entry.glManager.isContextLost()) {
             for (const w of entry.waiters) {
-                w.reject(err);
+                w.resolve();
             }
+
+            continue;
+        }
+
+        const key = entry.glManager.backendId;
+        const group = groups.get(key);
+        if (group) {
+            group.push(entry);
+        } else {
+            groups.set(key, [entry]);
         }
     }
 
-    await Promise.all(ready.map(present));
+    await Promise.all(Array.from(groups.values()).map(presentGroup));
 
     // Now (and only now) clear rafId. If new requests landed during
     // this drain, schedule the next RAF.
@@ -264,18 +324,62 @@ async function drain(): Promise<void> {
     }
 }
 
+/**
+ * Render every entry sharing one GL context, sequentially: each chart
+ * gets the shared drawing buffer to itself for a full
+ * `beginFrame` → `fullRender` → `awaitGpuFence` → `endFrame` (present)
+ * cycle before the next chart touches it. Groups for *different*
+ * contexts run concurrently (via `Promise.all` in `drain`), so K pooled
+ * contexts give K-way parallelism and the 1:1 default keeps full
+ * cross-chart overlap.
+ *
+ * The synchronous prefix of each group (`beginFrame` + `fullRender`)
+ * runs before its first `awaitGpuFence` yields, so when groups run
+ * concurrently all first-chart draws are still submitted before any
+ * fence wait — preserving the GPU overlap the old two-phase drain had.
+ */
+async function presentGroup(entries: Entry[]): Promise<void> {
+    for (const entry of entries) {
+        await present(entry);
+    }
+}
+
 async function present(entry: Entry): Promise<void> {
-    // Mark this glManager as in-flight *synchronously*, before the
-    // first await. `Promise.all(ready.map(present))` calls each
-    // `present` synchronously to collect its returned promise, so
-    // every entry's glManager is registered in `inFlight` before
-    // any fence-wait yields and before any sibling message handler
-    // can run. Mutations posted by sibling handlers (resize, clear)
-    // route through `deferIfDraining` and queue into `deferred`
-    // until the `finally` block flushes them.
+    // Mark this glManager as in-flight *synchronously*, before the first
+    // await, so sibling message handlers' canvas mutations (resize,
+    // clear) route through `deferIfDraining` into `deferred` until the
+    // `finally` flushes them.
     inFlight.add(entry.glManager);
+    try {
+        // Apply the dimension change and (in pooled mode) reset shared
+        // GL state in the same un-yielded step as the paint that fills
+        // the buffer. Pairing the canvas-clearing `canvas.width = N`
+        // with `_fullRender` keeps the compositor from ever observing a
+        // cleared-but-unpainted canvas (visible flicker in direct/in-
+        // process modes, where the visible canvas IS the GL canvas).
+        entry.glManager.beginFrame();
+        entry.fullRender();
+    } catch (err) {
+        console.error("scheduler: fullRender threw", err);
+        for (const w of entry.waiters) {
+            w.reject(err);
+        }
+
+        flushDeferred(entry.glManager);
+        return;
+    }
+
     try {
         await entry.glManager.awaitGpuFence();
+        // Draw the 2D layers (gridlines + chrome) only now that the GL
+        // frame's GPU work has completed. Issuing the 2D-canvas commands
+        // here — rather than inline in `fullRender` (Phase 1) — keeps the
+        // 2D placeholder canvases from pushing their resized frame to the
+        // compositor during the fence-wait yields, a frame ahead of the
+        // GL present. That early push is the visible GL/2D misalignment
+        // on resize. Failures fall through to the same present-failed
+        // path as the fence.
+        entry.render2D();
         entry.glManager.endFrame();
         for (const w of entry.waiters) {
             w.resolve();
@@ -296,21 +400,26 @@ async function present(entry: Entry): Promise<void> {
             w.reject(err);
         }
     } finally {
-        // Bitmap shipped (or error reported). Re-open the canvas to
-        // mutations and flush any deferred ops in arrival order.
-        // Deferred ops may call `requestRender`; the resulting
-        // entry queues into `pending` and the drain's tail check
-        // picks it up for the next RAF.
-        inFlight.delete(entry.glManager);
-        const ops = deferred.get(entry.glManager);
-        if (ops) {
-            deferred.delete(entry.glManager);
-            for (const op of ops) {
-                try {
-                    op();
-                } catch (err) {
-                    console.error("scheduler: deferred op threw", err);
-                }
+        flushDeferred(entry.glManager);
+    }
+}
+
+/**
+ * Re-open a glManager's canvas to mutations and flush any ops deferred
+ * during its present, in arrival order. Deferred ops may call
+ * `requestRender`; the resulting entry queues into `pending` and the
+ * drain's tail check picks it up for the next RAF.
+ */
+function flushDeferred(glManager: WebGLContextManager): void {
+    inFlight.delete(glManager);
+    const ops = deferred.get(glManager);
+    if (ops) {
+        deferred.delete(glManager);
+        for (const op of ops) {
+            try {
+                op();
+            } catch (err) {
+                console.error("scheduler: deferred op threw", err);
             }
         }
     }

package/src/ts/transport/protocol.ts

@@ -31,6 +31,7 @@ export type ControlMsg =
     | SetBufferMaxCapacityMsg
     | LoadAndRenderMsg
     | RedrawMsg
+    | DeselectMsg
     | ResizeMsg
     | ClearMsg
     | InvalidateThemeMsg
@@ -53,6 +54,7 @@ export type WorkerMsg =
     | UserClickMsg
     | UserSelectMsg
     | LoadAndRenderAckMsg
+    | ResizeAckMsg
     | FrameBitmapMsg
     | ErrorMsg;
 
@@ -300,13 +302,44 @@ export interface RedrawMsg {
     kind: "redraw";
 }
 
+/**
+ * Host → worker: silently clear the chart's selection state (pinned
+ * tooltip) — no `userSelect` reply, so the host filter-bar removal that
+ * triggered it can't echo back into the host's filter set. The worker's
+ * `TooltipController.dismiss()` posts `dismissTooltip` to tear down the
+ * host-side pinned artifact.
+ */
+export interface DeselectMsg {
+    kind: "deselect";
+}
+
+/**
+ * Host → worker: resize the chart to a new CSS box. Replied with
+ * {@link ResizeAckMsg} AFTER the resized frame PRESENTS — the host's
+ * `plugin.resize()` promise is the viewer's presize contract ("the
+ * plugin has repainted at the target box when this resolves"), so an
+ * ack at message-receipt would let the settings-pane layout commit
+ * against the old-dimensions bitmap (the aspect-ratio warp).
+ */
 export interface ResizeMsg {
     kind: "resize";
+    msgId: number;
     cssWidth: number;
     cssHeight: number;
     dpr: number;
 }
 
+/**
+ * Worker → host reply to a `ResizeMsg`, posted after the resized
+ * frame's present completes. Always sent — present failures and
+ * torn-down charts included — so the host's awaited promise resolves
+ * deterministically.
+ */
+export interface ResizeAckMsg {
+    kind: "resizeAck";
+    msgId: number;
+}
+
 export interface ClearMsg {
     kind: "clear";
 }