@perspective-dev/viewer-charts 4.5.2 → 5.0.0

package/src/ts/worker/dispatch.ts

@@ -40,9 +40,12 @@ export function dispatch(r: WorkerRenderer, msg: ControlMsg): void {
         case "redraw":
             r.redraw();
             break;
+        case "deselect":
+            r.chartImpl.deselect?.();
+            break;
         case "resize":
             r.resize(msg.cssWidth, msg.cssHeight, msg.dpr);
-            r.redraw();
+            r.redrawAck(msg.msgId);
             break;
         case "clear":
             r.clear();

package/src/ts/worker/renderer.worker.ts

@@ -295,16 +295,23 @@ export class WorkerRenderer {
             try {
                 await viewToColumnDataMap(
                     this.view,
-                    async (cols) => {
+                    async (cols, deliveredRows) => {
                         if (this._renderGen !== myGen) {
                             throw new StaleGenerationError();
                         }
 
+                        // `totalRows` came from a SEPARATE `num_rows()`
+                        // round-trip; a fast-updating table with deletions
+                        // can shrink the view before the Arrow fetch, which
+                        // clamps its window silently. Iterating to the stale
+                        // count reads typed arrays out-of-bounds (`undefined`
+                        // values no validity bitmap covers) — clamp to what
+                        // was actually delivered.
                         await this.chartImpl.uploadAndRender(
                             this.glManager,
                             cols,
                             0,
-                            totalRows,
+                            Math.min(totalRows, deliveredRows),
                         );
                     },
                     { end_row: totalRows, float32: msg.options.float32 },
@@ -327,6 +334,24 @@ export class WorkerRenderer {
         this.chartImpl.requestRender(this.glManager);
     }
 
+    /**
+     * `redraw`, acked to the host AFTER the frame's present completes —
+     * the reply backing the viewer's presize contract (`ResizeAckMsg`):
+     * `plugin.resize()` must not resolve until the resized frame is
+     * actually on screen. A resize landing mid-present defers its
+     * canvas mutation (`deferIfDraining`), but the redraw's own frame
+     * applies pending dimensions in `beginFrame`, so the present this
+     * awaits IS at the new size. Always acks — a failed present or a
+     * torn-down chart resolves the host's await rather than stranding
+     * it (completion, not success, is the contract).
+     */
+    redrawAck(msgId: number): void {
+        this.chartImpl
+            .requestRender(this.glManager)
+            .catch(() => {})
+            .finally(() => this.post({ kind: "resizeAck", msgId }));
+    }
+
     resize(cssWidth: number, cssHeight: number, dpr: number): void {
         // `glManager.resize` would set `canvas.width = N`, which the
         // spec mandates clears the drawing buffer immediately. In
@@ -572,7 +597,11 @@ export class WorkerRenderer {
         // chart left the shared canvas at its own size) would render at
         // the wrong dimensions.
         this.glManager.beginFrame();
-        this.chartImpl._fullRender(this.glManager);
+        // `renderFrameSync` (not `_fullRender`) so the gridline + chrome
+        // 2D canvases are actually painted here — the scheduler normally
+        // defers those to a post-fence flush, but the snapshot path
+        // bypasses the scheduler and composites the 2D layers below.
+        this.chartImpl.renderFrameSync(this.glManager);
         const gl = this.glManager.gl;
         const glCanvas = gl.canvas as OffscreenCanvas;
         const w = glCanvas.width;