@vectojs/core 1.32.6 → 1.32.7

package/dist/index.mjs

@@ -18,7 +18,7 @@ import {
   SVGEntity,
   VectoJSEvent,
   contentLineInHint
-} from "./chunk-RWN3ITBD.mjs";
+} from "./chunk-YTGGL4I4.mjs";
 
 // src/tree/Scene.ts
 import { SpringDriver, TweenDriver } from "@vectojs/animation";
@@ -1434,6 +1434,7 @@ function parseInlinePx(value) {
   return Number.isFinite(n) && n > 0 ? n : null;
 }
 var DEFAULT_CONTENT_SEMANTIC_BUDGET = 256;
+var WASM_UPLOAD_REJECT_LIMIT = 3;
 function projectionGridLineWindow(grid, projectionLines, band) {
   const count = grid.lines.length;
   const all = { start: 0, end: count, gated: false };
@@ -2204,6 +2205,14 @@ var Scene = class _Scene {
   _wasmWorld = null;
   _structureVersion = 0;
   _storeStructureVersion = -1;
+  /**
+   * Consecutive `uploadRuns` rejections. Reset by any success and by
+   * {@link setTransformBackend}; at {@link WASM_UPLOAD_REJECT_LIMIT} the backend
+   * mode flips to `'js'` permanently.
+   */
+  _wasmUploadRejections = 0;
+  /** Latch for the permanent-fallback warning, which fires from a per-frame path. */
+  hasWarnedWasmUploadFallback = false;
   // Cached list of ComputeParticleEntity instances in the tree, keyed by the
   // structure version it was gathered at. Rebuilt only on a topology change.
   _computeEntities = [];
@@ -2241,6 +2250,7 @@ var Scene = class _Scene {
   setTransformBackend(backend) {
     this._wasm = backend;
     this._transformBackend = backend ? "wasm" : "js";
+    this._wasmUploadRejections = 0;
   }
   /**
    * Asynchronously instantiate the WASM transform core and, on success, hot-swap
@@ -2872,8 +2882,19 @@ var Scene = class _Scene {
       }
       if (!backend.uploadRuns(built.store)) {
         this._transformReason = "rejected";
+        this._wasmUploadRejections++;
+        if (this._wasmUploadRejections >= WASM_UPLOAD_REJECT_LIMIT) {
+          this._transformBackend = "js";
+          if (!this.hasWarnedWasmUploadFallback) {
+            console.warn(
+              `[VectoJS] WASM transform backend disabled after ${this._wasmUploadRejections} consecutive run-table rejections (${built.store.runCount} runs for ${built.store.count} entities); the crate refused this topology. Falling back to JS transforms for this scene. Call scene.setTransformBackend(backend) to re-enable after reducing the tree.`
+            );
+            this.hasWarnedWasmUploadFallback = true;
+          }
+        }
         return null;
       }
+      this._wasmUploadRejections = 0;
       this._treeStore = built.store;
       this._slotEntity = slotEntity2;
       this._wasmInputs = backend.inputView();
@@ -3003,6 +3024,16 @@ var Scene = class _Scene {
    *  else the canvas). Stored so `destroy()` detaches from the same element. */
   pointerEventTarget = null;
   hasWarnedZeroSize = false;
+  /**
+   * Latch for {@link Scene.resize}'s invalid-dimension warning.
+   *
+   * Separate from `hasWarnedZeroSize`: that one fires for a tolerated zero-size
+   * scene at `start()`, this one for a rejected resize, and sharing the flag
+   * would let either suppress the other's first (and only) report. Latched
+   * because `resize()` is commonly driven from a `ResizeObserver`, which would
+   * otherwise warn on every frame of a drag.
+   */
+  hasWarnedInvalidResize = false;
   fontLoadHandler = null;
   // ── Dev-mode warning infrastructure ──────────────────────────────
   //
@@ -3804,9 +3835,11 @@ var Scene = class _Scene {
   /**
    * Begin the `requestAnimationFrame` render loop.
    *
-   * Idempotent — calling `start()` on an already-running scene is a no-op.
+   * Idempotent — calling `start()` on an already-running scene is a no-op, and so
+   * is calling it on a destroyed one.
    */
   start() {
+    if (this.destroyed) return;
     if (this.isRunning) return;
     if ((this.width === 0 || this.height === 0) && !this.hasWarnedZeroSize) {
       console.warn(
@@ -4975,9 +5008,27 @@ var Scene = class _Scene {
     if (el.dataset.vectoContentGrid !== signature) {
       const materializeStart = typeof performance !== "undefined" ? performance.now() : 0;
       this.clearContentGridState(node.id, el, false);
+      if (el.firstChild !== null) {
+        let scan = el.firstChild;
+        let strippedSelection = false;
+        while (scan !== null) {
+          const next = scan.nextSibling;
+          if (scan.nodeType === 3) {
+            if (!strippedSelection) {
+              strippedSelection = true;
+              this.releaseContentSelectionForRebuild(el);
+            }
+            scan.remove();
+          }
+          scan = next;
+        }
+      }
       const projectionLines = projection.lines ?? [];
       const selectionLine = this.contentGridSelectionLine(el);
       let rebuiltSelectionLine = false;
+      if (selectionLine !== null && (selectionLine < gridWindow.start || selectionLine >= gridWindow.end)) {
+        rebuiltSelectionLine = true;
+      }
       const existingLines = el.children;
       for (let lineIndex = gridWindow.start; lineIndex < gridWindow.end; lineIndex++) {
         const domIndex = lineIndex - gridWindow.start;
@@ -5074,9 +5125,6 @@ var Scene = class _Scene {
       }
       const windowLength = gridWindow.end - gridWindow.start;
       while (el.children.length > windowLength) {
-        if (selectionLine !== null && selectionLine >= gridWindow.end) {
-          rebuiltSelectionLine = true;
-        }
         el.lastElementChild?.remove();
       }
       if (rebuiltSelectionLine) this.releaseContentSelectionForRebuild(el);
@@ -5745,6 +5793,11 @@ var Scene = class _Scene {
       if (isMainRenderPath && !this.device && !this.webgpuDisabled && !this.initializingWebGPU && !this.deviceLost) {
         this.initializingWebGPU = true;
         this.initWebGPUContext(computeEntities).then((newDevice) => {
+          if (this.destroyed) {
+            newDevice.destroy();
+            this.initializingWebGPU = false;
+            return;
+          }
           this.device = newDevice;
           this.initializingWebGPU = false;
           const format = navigator.gpu ? navigator.gpu.getPreferredCanvasFormat() : "rgba8unorm";
@@ -6097,8 +6150,21 @@ var Scene = class _Scene {
   }
   /**
    * Manually resize the Scene's viewport.
+   *
+   * Rejects a negative or non-finite dimension, keeping the last known-good
+   * size. `0` is accepted: a zero-size scene is tolerated and warned about at
+   * {@link start} instead, and rejecting it here would contradict that.
    */
   resize(width, height) {
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0) {
+      if (!this.hasWarnedInvalidResize) {
+        console.warn(
+          `[VectoJS] Scene.resize() ignored invalid dimensions (width: ${width}, height: ${height}). Width and height must be finite and non-negative; the previous viewport size was kept.`
+        );
+        this.hasWarnedInvalidResize = true;
+      }
+      return;
+    }
     this.width = width;
     this.height = height;
     this.contentFontEpoch++;
@@ -6631,8 +6697,8 @@ function distSqToSegment(px, py, x1, y1, x2, y2) {
   return ex * ex + ey * ey;
 }
 var SplineEntity = class extends Entity {
-  doc;
-  lineWidth;
+  _doc;
+  _lineWidth;
   defaultColor;
   hitTolerance;
   cache;
@@ -6643,10 +6709,42 @@ var SplineEntity = class extends Entity {
   /** Logical (CSS-pixel) size of the baked bitmap — the blit destination size. */
   bakedWidth = 0;
   bakedHeight = 0;
-  /** Gradient strokes can't be baked to a solid-color bitmap; they render per-frame. */
+  /**
+   * Gradient strokes can't be baked to a solid-color bitmap; they render
+   * per-frame. Derived from `_doc`, so it is NOT readonly — assigning a new
+   * document has to recompute it (see the `doc` setter).
+   */
   containsGradient;
   /** Lazily-flattened polylines (one Float32Array of [x,y,...] per segment) for hit-testing. */
   polylines = null;
+  /**
+   * The spline document to render. Assigning a new document invalidates all
+   * caches (baked canvas, flattened polylines, bounds).
+   */
+  get doc() {
+    return this._doc;
+  }
+  set doc(value) {
+    if (this._doc === value) return;
+    this._doc = value;
+    this.invalidateCache();
+    this.bounds = this.computeBounds();
+    this.width = this.bounds.width;
+    this.height = this.bounds.height;
+    this.containsGradient = this.computeContainsGradient();
+  }
+  /**
+   * Stroke width in local units. Assigning a new value invalidates the baked
+   * canvas and hit-test polylines so visual and hit geometry stay consistent.
+   */
+  get lineWidth() {
+    return this._lineWidth;
+  }
+  set lineWidth(value) {
+    if (this._lineWidth === value) return;
+    this._lineWidth = value;
+    this.invalidateCache();
+  }
   /**
    * When `true`, the renderer draws a rounded-rect outline of the entity's
    * local bounds after painting the curves. Useful for drag feedback and
@@ -6655,8 +6753,8 @@ var SplineEntity = class extends Entity {
   showBounds = false;
   constructor(doc, opts = {}) {
     super();
-    this.doc = doc;
-    this.lineWidth = opts.lineWidth ?? 2;
+    this._doc = doc;
+    this._lineWidth = opts.lineWidth ?? 2;
     this.cache = opts.cache ?? true;
     this.defaultColor = opts.defaultColor ?? "#e2e8f0";
     this.hitMode = opts.hitTest ?? "curve";
@@ -6664,21 +6762,35 @@ var SplineEntity = class extends Entity {
     this.bounds = this.computeBounds();
     this.width = this.bounds.width;
     this.height = this.bounds.height;
-    const isGradient = (c) => c !== null && !Array.isArray(c);
-    this.containsGradient = (this.doc.equations?.some((eq) => isGradient(eq.color_rgb)) ?? false) || (this.doc.paths?.some((p) => isGradient(p.color_rgb)) ?? false);
+    this.containsGradient = this.computeContainsGradient();
     this.interactive = true;
   }
+  /**
+   * Whether any stroke in the current document is a gradient. Shared by the
+   * constructor and the `doc` setter so both stay in agreement — the flag picks
+   * the render path, so a stale value renders a gradient as a flat color.
+   */
+  computeContainsGradient() {
+    const isGradient = (c) => c !== null && !Array.isArray(c);
+    return (this._doc.equations?.some((eq) => isGradient(eq.color_rgb)) ?? false) || (this._doc.paths?.some((p) => isGradient(p.color_rgb)) ?? false);
+  }
+  /** Clear cached baked canvas and hit-test polylines. */
+  invalidateCache() {
+    this.baked = false;
+    this.offscreen = null;
+    this.polylines = null;
+  }
   computeBounds() {
-    if (this.doc.bounding_box) {
-      const [minX2, minY2, maxX2, maxY2] = this.doc.bounding_box;
+    if (this._doc.bounding_box) {
+      const [minX2, minY2, maxX2, maxY2] = this._doc.bounding_box;
       return { x: minX2, y: minY2, width: maxX2 - minX2, height: maxY2 - minY2 };
     }
     let minX = Infinity;
     let minY = Infinity;
     let maxX = -Infinity;
     let maxY = -Infinity;
-    if (this.doc.equations) {
-      for (const eq of this.doc.equations) {
+    if (this._doc.equations) {
+      for (const eq of this._doc.equations) {
         for (const seg of eq.data) {
           const b = polySegmentToBezier(seg);
           for (const [x, y] of [
@@ -6695,8 +6807,8 @@ var SplineEntity = class extends Entity {
         }
       }
     }
-    if (this.doc.paths) {
-      for (const path of this.doc.paths) {
+    if (this._doc.paths) {
+      for (const path of this._doc.paths) {
         for (const pt of path.data) {
           if (pt.x < minX) minX = pt.x;
           if (pt.x > maxX) maxX = pt.x;
@@ -6756,15 +6868,15 @@ var SplineEntity = class extends Entity {
   getPolylines() {
     if (this.polylines) return this.polylines;
     const out = [];
-    if (this.doc.equations) {
-      for (const eq of this.doc.equations) {
+    if (this._doc.equations) {
+      for (const eq of this._doc.equations) {
         for (const seg of eq.data) {
           out.push(flattenBezier(polySegmentToBezier(seg), HIT_SAMPLES));
         }
       }
     }
-    if (this.doc.paths) {
-      for (const path of this.doc.paths) {
+    if (this._doc.paths) {
+      for (const path of this._doc.paths) {
         const pts = new Float32Array(path.data.length * 2);
         for (let i = 0; i < path.data.length; i++) {
           pts[i * 2] = path.data[i].x;
@@ -6793,8 +6905,8 @@ var SplineEntity = class extends Entity {
     );
   }
   strokeEquations(r) {
-    if (this.doc.equations) {
-      for (const eq of this.doc.equations) {
+    if (this._doc.equations) {
+      for (const eq of this._doc.equations) {
         const stroke = this.resolveColor(eq.color_rgb, r);
         r.beginPath();
         for (const seg of eq.data) {
@@ -6805,8 +6917,8 @@ var SplineEntity = class extends Entity {
         r.stroke(stroke, this.lineWidth);
       }
     }
-    if (this.doc.paths) {
-      for (const path of this.doc.paths) {
+    if (this._doc.paths) {
+      for (const path of this._doc.paths) {
         const stroke = this.resolveColor(path.color_rgb, r);
         r.beginPath();
         if (path.data.length > 0) {
@@ -6845,8 +6957,8 @@ var SplineEntity = class extends Entity {
     ctx.lineWidth = this.lineWidth;
     ctx.lineCap = "round";
     ctx.lineJoin = "round";
-    if (this.doc.equations) {
-      for (const eq of this.doc.equations) {
+    if (this._doc.equations) {
+      for (const eq of this._doc.equations) {
         ctx.strokeStyle = eq.color_rgb === null ? this.defaultColor : Array.isArray(eq.color_rgb) ? rgbToCss(eq.color_rgb) : this.defaultColor;
         ctx.beginPath();
         for (const seg of eq.data) {
@@ -6857,8 +6969,8 @@ var SplineEntity = class extends Entity {
         ctx.stroke();
       }
     }
-    if (this.doc.paths) {
-      for (const path of this.doc.paths) {
+    if (this._doc.paths) {
+      for (const path of this._doc.paths) {
         ctx.strokeStyle = path.color_rgb === null ? this.defaultColor : Array.isArray(path.color_rgb) ? rgbToCss(path.color_rgb) : this.defaultColor;
         ctx.beginPath();
         if (path.data.length > 0) {
@@ -6920,7 +7032,14 @@ var Rect = class extends Entity {
     this.radius = opts.radius ?? 0;
   }
   getBounds() {
-    return { x: 0, y: 0, width: this.width, height: this.height };
+    const inflation = this.stroke !== null ? this.strokeWidth / 2 : 0;
+    const origin = inflation > 0 ? -inflation : 0;
+    return {
+      x: origin,
+      y: origin,
+      width: this.width + inflation * 2,
+      height: this.height + inflation * 2
+    };
   }
   /**
    * Solid-fill, square-cornered, unstroked rectangles opt into the GPU
@@ -6982,11 +7101,15 @@ var Circle = class extends Entity {
     this.a11yOffsetY = -this._radius;
   }
   getBounds() {
+    const r = this._radius;
+    const inflation = this.stroke !== null ? this.strokeWidth / 2 : 0;
+    const fullRadius = r + inflation;
+    const origin = fullRadius > 0 ? -fullRadius : 0;
     return {
-      x: -this._radius,
-      y: -this._radius,
-      width: this._radius * 2,
-      height: this._radius * 2
+      x: origin,
+      y: origin,
+      width: fullRadius * 2,
+      height: fullRadius * 2
     };
   }
   /**

package/dist/text.js

@@ -2,11 +2,11 @@
 
 
 
-var _chunkTRT2TRCWjs = require('./chunk-TRT2TRCW.js');
+var _chunkFQ2565ITjs = require('./chunk-FQ2565IT.js');
 
 // src/text/index.ts
 var _text = require('@vectojs/text'); _createStarExport(_text);
 
 
 
-exports.MSDFTextEntity = _chunkTRT2TRCWjs.MSDFTextEntity; exports.SVGEntity = _chunkTRT2TRCWjs.SVGEntity;
+exports.MSDFTextEntity = _chunkFQ2565ITjs.MSDFTextEntity; exports.SVGEntity = _chunkFQ2565ITjs.SVGEntity;

package/dist/text.mjs

@@ -1,7 +1,7 @@
 import {
   MSDFTextEntity,
   SVGEntity
-} from "./chunk-RWN3ITBD.mjs";
+} from "./chunk-YTGGL4I4.mjs";
 
 // src/text/index.ts
 export * from "@vectojs/text";

package/dist/tree/Entity.d.ts

@@ -481,6 +481,8 @@ export declare class VectoJSEvent<N = unknown> {
     get deltaX(): number | undefined;
     /** Native vertical wheel delta, if this wraps a `WheelEvent`. */
     get deltaY(): number | undefined;
+    /** Native wheel delta mode (0=pixels, 1=lines, 2=pages), if this wraps a `WheelEvent`. */
+    get deltaMode(): number | undefined;
     /** Native pointer X, if this wraps a pointer/mouse event. */
     get clientX(): number | undefined;
     /** Native pointer Y, if this wraps a pointer/mouse event. */

package/dist/tree/Scene.d.ts

@@ -799,6 +799,14 @@ export declare class Scene {
     private _wasmWorld;
     private _structureVersion;
     private _storeStructureVersion;
+    /**
+     * Consecutive `uploadRuns` rejections. Reset by any success and by
+     * {@link setTransformBackend}; at {@link WASM_UPLOAD_REJECT_LIMIT} the backend
+     * mode flips to `'js'` permanently.
+     */
+    private _wasmUploadRejections;
+    /** Latch for the permanent-fallback warning, which fires from a per-frame path. */
+    private hasWarnedWasmUploadFallback;
     private _computeEntities;
     private _computeEntitiesVersion;
     /** Invalidate the resident WASM store layout; the next wasm-mode frame rebuilds
@@ -1188,6 +1196,16 @@ export declare class Scene {
      *  else the canvas). Stored so `destroy()` detaches from the same element. */
     private pointerEventTarget;
     private hasWarnedZeroSize;
+    /**
+     * Latch for {@link Scene.resize}'s invalid-dimension warning.
+     *
+     * Separate from `hasWarnedZeroSize`: that one fires for a tolerated zero-size
+     * scene at `start()`, this one for a rejected resize, and sharing the flag
+     * would let either suppress the other's first (and only) report. Latched
+     * because `resize()` is commonly driven from a `ResizeObserver`, which would
+     * otherwise warn on every frame of a drag.
+     */
+    private hasWarnedInvalidResize;
     private fontLoadHandler;
     private static _devMode;
     /**
@@ -1376,7 +1394,8 @@ export declare class Scene {
     /**
      * Begin the `requestAnimationFrame` render loop.
      *
-     * Idempotent — calling `start()` on an already-running scene is a no-op.
+     * Idempotent — calling `start()` on an already-running scene is a no-op, and so
+     * is calling it on a destroyed one.
      */
     start(): void;
     /** Schedule the next frame, or no-op where `requestAnimationFrame` is absent (SSR). */
@@ -1737,6 +1756,10 @@ export declare class Scene {
     toSVG(): string;
     /**
      * Manually resize the Scene's viewport.
+     *
+     * Rejects a negative or non-finite dimension, keeping the last known-good
+     * size. `0` is accepted: a zero-size scene is tolerated and warned about at
+     * {@link start} instead, and rejecting it here would contradict that.
      */
     resize(width: number, height: number): void;
     /** Effective device pixel ratio, matching CanvasRenderer: real DPR clamped to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/core",
-  "version": "1.32.6",
+  "version": "1.32.7",
   "publishConfig": {
     "access": "public"
   },