@vectojs/core 1.35.0 → 1.35.2

package/dist/index.mjs

@@ -11,14 +11,14 @@ import {
   parseColorToRGBA,
   sanitizeUrl,
   setRendererDevMode
-} from "./chunk-IFSFHYF7.mjs";
+} from "./chunk-25PS5K7R.mjs";
 import {
   Entity,
   MSDFTextEntity,
   SVGEntity,
   VectoJSEvent,
   contentLineInHint
-} from "./chunk-TV4ARAC5.mjs";
+} from "./chunk-CHDJEHML.mjs";
 
 // src/tree/ComputeParticleEntity.ts
 var PARTICLE_STRIDE_FLOATS = 8;
@@ -316,6 +316,7 @@ var ComputeParticleEntity = class extends Entity {
   stepWithBackend(backend, dt, mouseX, mouseY, width, height) {
     const count = this.maxParticles;
     backend.ensure(count);
+    backend.revalidateViews();
     backend.gather(this.particleData, count, true);
     const pending = backend.step(count, {
       dt,
@@ -1325,6 +1326,7 @@ var DriverTicker = class {
     tP.length = tweenCount;
     tD.length = tweenCount;
     backend.ensure(springCount, tweenCount);
+    backend.revalidateViews();
     if (springCount > 0) {
       const sv = backend.springView();
       for (let i = 0; i < springCount; i++) {
@@ -1593,6 +1595,7 @@ var HitTester = class {
       gathered = gatherHitAABBs(this.root, frame);
     }
     backend.ensure(gathered.count, width, height, 64);
+    backend.revalidateViews();
     const view = backend.inputView();
     view.minx.set(gathered.minx.subarray(0, gathered.count));
     view.miny.set(gathered.miny.subarray(0, gathered.count));
@@ -2123,10 +2126,15 @@ var ContentProjectionManager = class {
     }
     if (this.phases.enabled) this.phases.record("calibScan", performance.now() - scanStart);
     if (measurements.length === 0) {
-      el.dataset.vectoGridCalibration = calibrationKey;
-      el.dataset.vectoGridReady = "true";
       el.dataset.vectoGridCalibrationSamples = "0";
       delete el.dataset.vectoGridCalibrationPending;
+      const readyFrame = requestAnimationFrame(() => {
+        this.calibrationFrameHandles.delete(entityId);
+        if (!el.isConnected) return;
+        el.dataset.vectoGridCalibration = calibrationKey;
+        el.dataset.vectoGridReady = "true";
+      });
+      this.calibrationFrameHandles.set(entityId, readyFrame);
       return;
     }
     const appendStart = this.phases.enabled ? performance.now() : 0;
@@ -2369,8 +2377,15 @@ var WASM_STATUS = {
   /** A kernel ran before `init`. */
   UNINITIALIZED: 2,
   /** A sibling run addressed a slot or parent outside the store. */
-  BAD_RUN: 3
+  BAD_RUN: 3,
+  /** A requested capacity's size arithmetic overflowed; the previous store
+   *  was left untouched. */
+  OVERFLOW: 4
 };
+function viewsStale(cap, probe, memory) {
+  if (cap === 0) return false;
+  return probe.byteLength === 0 || probe.buffer !== memory.buffer;
+}
 var PAD2 = 8;
 var WasmTransformBackend = class {
   available = true;
@@ -2560,9 +2575,15 @@ var WasmTransformBackend = class {
   }
   ensure(count, runCount) {
     if (count + PAD2 <= this.cap && runCount <= this.runCap) return;
-    this.cap = count + PAD2;
-    this.runCap = Math.max(runCount, count, 1);
-    this.ex.init(count, this.runCap);
+    const cap = count + PAD2;
+    const runCap = Math.max(runCount, count, 1);
+    const status = this.ex.init(count, runCap);
+    if (status !== WASM_STATUS.OK) {
+      this.lastStatus = status;
+      return;
+    }
+    this.cap = cap;
+    this.runCap = runCap;
     this.refreshViews();
   }
   /** Rebuild typed-array views after an init() (which may have grown, and thus
@@ -2630,11 +2651,26 @@ var AnimBackend = class {
    */
   ensure(springCount, tweenCount) {
     if (springCount + PAD3 <= this.springCap && tweenCount + PAD3 <= this.tweenCap) return;
-    this.springCap = springCount + PAD3;
-    this.tweenCap = tweenCount + PAD3;
-    this.ex.anim_init(this.springCap, this.tweenCap);
+    const springCap = springCount + PAD3;
+    const tweenCap = tweenCount + PAD3;
+    const status = this.ex.anim_init(springCap, tweenCap);
+    if (status !== WASM_STATUS.OK) {
+      this.lastStatus = status;
+      return;
+    }
+    this.springCap = springCap;
+    this.tweenCap = tweenCap;
     this.refreshViews();
   }
+  /**
+   * Re-create the typed-array views if another backend's allocation grew the
+   * shared linear memory and detached them (see {@link viewsStale}). Call after
+   * {@link ensure} and before writing into {@link springView}/{@link tweenView}.
+   */
+  revalidateViews() {
+    if (this.springCap === 0) return;
+    if (viewsStale(this.springCap, this.sv.val, this.ex.memory)) this.refreshViews();
+  }
   /**
    * Advance `count` springs (from index 0) by `dtMs` milliseconds, in place.
    * Returns `true` when the kernel ran. `false` means it rejected the call
@@ -2728,15 +2764,26 @@ var HitTestBackend = class {
     this.gridH = gh;
     this.cellSize = cellSize;
   }
+  /**
+   * Re-create the typed-array views if another backend's allocation grew the
+   * shared linear memory and detached them (see {@link viewsStale}). Call after
+   * {@link ensure} and before writing into {@link inputView}.
+   */
+  revalidateViews() {
+    if (this.entityCap === 0) return;
+    if (viewsStale(this.entityCap, this.vminx, this.ex.memory)) this.refreshViews();
+  }
   /**
    * Run the kernel's bucketing over whatever is currently resident in
    * {@link inputView} (write the AABBs there, and call {@link ensure} first).
-   * Returns `false` if the build overflowed its item budget — the caller must
-   * not trust {@link candidatesAt} results for this build and should fall back
-   * to the JS walk instead (never return a wrong hit).
+   * Returns `false` if the build was rejected (no `hit_init` yet) or overflowed
+   * its item budget — the caller must not trust {@link candidatesAt} results
+   * for this build and should fall back to the JS walk instead (never return a
+   * wrong hit).
    */
   runBuild(count, vw, vh, cellSize) {
-    this.ex.hit_build(count, vw, vh, cellSize);
+    const status = this.ex.hit_build(count, vw, vh, cellSize);
+    if (status !== WASM_STATUS.OK) return false;
     return this.ex.hit_overflow() === 0;
   }
   /**
@@ -2762,10 +2809,16 @@ var HitTestBackend = class {
     if (count + PAD4 <= this.entityCap && cellCount <= this.cellCap && itemCount <= this.itemCap) {
       return;
     }
-    this.entityCap = count + PAD4;
-    this.cellCap = Math.max(cellCount, 1);
-    this.itemCap = Math.max(itemCount, count, 1);
-    this.ex.hit_init(count, this.cellCap, this.itemCap);
+    const entityCap = count + PAD4;
+    const cellCap = Math.max(cellCount, 1);
+    const itemCap = Math.max(itemCount, count, 1);
+    const status = this.ex.hit_init(count, cellCap, itemCap);
+    if (status !== WASM_STATUS.OK) {
+      return;
+    }
+    this.entityCap = entityCap;
+    this.cellCap = cellCap;
+    this.itemCap = itemCap;
     this.refreshViews();
   }
   /** Rebuild typed-array views after a growing `hit_init` (which detaches the
@@ -2804,10 +2857,24 @@ var ParticleBackend = class {
    */
   ensure(count) {
     if (count + PAD5 <= this.cap) return;
-    this.cap = count + PAD5;
-    this.ex.particle_init(this.cap);
+    const cap = count + PAD5;
+    const status = this.ex.particle_init(cap);
+    if (status !== WASM_STATUS.OK) {
+      this.lastStatus = status;
+      return;
+    }
+    this.cap = cap;
     this.refreshViews();
   }
+  /**
+   * Re-create the typed-array views if another backend's allocation grew the
+   * shared linear memory and detached them (see {@link viewsStale}). Call after
+   * {@link ensure} and before {@link gather}/{@link scatter}.
+   */
+  revalidateViews() {
+    if (this.cap === 0) return;
+    if (viewsStale(this.cap, this.view.px, this.ex.memory)) this.refreshViews();
+  }
   /**
    * Advance `count` particles one step in place. Returns `true` when at least
    * one live particle is still moving or off-origin beyond epsilon (the fused
@@ -3074,9 +3141,17 @@ var WasmBackendFacade = class {
    * main render walk onto it; passing `null` reverts to the JS path.
    */
   setTransform(backend) {
+    const backendChanged = backend !== this._transform && this._transform !== null;
     this._transform = backend;
     this._mode = backend ? "wasm" : "js";
     this._uploadRejections = 0;
+    if (backendChanged) {
+      this._treeStore = null;
+      this._storeStructureVersion = -1;
+      this._inputs = null;
+      this._world = null;
+      this._aabbsFresh = false;
+    }
   }
   // ── The shared runtime ──────────────────────────────────────────────────────
   /**
@@ -3244,6 +3319,7 @@ var WasmBackendFacade = class {
       }
       if (!backend.uploadRuns(built.store)) {
         this.transformReason = "rejected";
+        this._aabbsFresh = false;
         this._uploadRejections++;
         if (this._uploadRejections >= WASM_UPLOAD_REJECT_LIMIT) {
           this._mode = "js";
@@ -3283,6 +3359,7 @@ var WasmBackendFacade = class {
     }
     if (backend.runKernel("simd") !== WASM_STATUS.OK) {
       this.transformReason = "rejected";
+      this._aabbsFresh = false;
       return null;
     }
     this._aabbsFresh = false;
@@ -4468,23 +4545,23 @@ var Scene = class _Scene {
   }
   /**
    * Drop `entity` and its whole subtree from the batched-driver candidate set.
-   * Called by {@link remove}/{@link hideOverlay} on detach: without this a
-   * removed-but-still-animating entity stays pinned in the Set (a leak) and its
-   * drivers keep ticking every frame even though it is off-tree. If it is later
-   * re-added, {@link registerActiveDriverSubtree} re-registers any node that
-   * still has live drivers, so the motion resumes.
+   * Called by `Entity.remove` on detach (which `remove`/`hideOverlay` route
+   * through): without this a removed-but-still-animating entity stays pinned in
+   * the Set (a leak) and its drivers keep ticking every frame even though it is
+   * off-tree. If it is later re-added, {@link _registerActiveDriverSubtree}
+   * re-registers any node that still has live drivers, so the motion resumes.
    */
-  unregisterActiveDriverSubtree(entity) {
+  _unregisterActiveDriverSubtree(entity) {
     this._driverTicker.unregisterSubtree(entity);
   }
   /**
    * Re-register every node in `entity`'s subtree that still has live property
-   * drivers. Called by {@link add}/{@link showOverlay} so re-attaching a subtree
-   * that was removed mid-animation resumes its batched drivers (they were
-   * dropped from the candidate set on removal, but the driver state still lives
-   * on each entity).
+   * drivers. Called by `Entity._addOne` so re-attaching a subtree that was
+   * removed mid-animation resumes its batched drivers (they were dropped from
+   * the candidate set on removal, but the driver state still lives on each
+   * entity).
    */
-  registerActiveDriverSubtree(entity) {
+  _registerActiveDriverSubtree(entity) {
     this._driverTicker.registerSubtree(entity);
   }
   // --- domain: render-scheduler — batched driver tick (extraction 6), reads the anim backend ---
@@ -5021,7 +5098,6 @@ var Scene = class _Scene {
    */
   add(entity) {
     this.root.add(entity);
-    this.registerActiveDriverSubtree(entity);
     return this;
   }
   // --- domain: a11y-projection — subtree pruning, focus preservation on removal ---
@@ -5100,7 +5176,6 @@ var Scene = class _Scene {
   remove(entity) {
     this.root.remove(entity);
     this.removeA11yRecursively(entity);
-    this.unregisterActiveDriverSubtree(entity);
     return this;
   }
   /**
@@ -5132,7 +5207,6 @@ var Scene = class _Scene {
    */
   showOverlay(overlay) {
     this.overlayRoot.add(overlay);
-    this.registerActiveDriverSubtree(overlay);
     this.markDirty();
   }
   /**
@@ -5141,7 +5215,6 @@ var Scene = class _Scene {
   hideOverlay(overlay) {
     this.overlayRoot.remove(overlay);
     this.removeA11yRecursively(overlay);
-    this.unregisterActiveDriverSubtree(overlay);
     this.markDirty();
   }
   destroyEntitySubtree(entity) {
@@ -5385,8 +5458,9 @@ var Scene = class _Scene {
    * workload rendered ~1.0 frames per content change. To measure anything about
    * scheduling, use {@link start} and let `requestAnimationFrame` drive.
    *
-   * @param dt Seconds to advance. Not clamped by `MAX_FRAME_DT` — the caller
-   *   chooses the step, since determinism is the point.
+   * @param dt Milliseconds to advance (same unit as the rAF timestamps `loop`
+   *   feeds `render`). Not clamped by `MAX_FRAME_DT` — the caller chooses the
+   *   step, since determinism is the point.
    */
   step(dt) {
     const time = this.lastTime + dt;
@@ -6329,26 +6403,43 @@ var Scene = class _Scene {
               if (mctx) {
                 mctx.font = lineFont;
                 const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
-                const segments = [...segmenter.segment(line.text)];
-                let runningX = 0;
-                for (let segIdx = 0; segIdx < segments.length; segIdx++) {
-                  const { segment, index: index2 } = segments[segIdx];
-                  const nextIndex = segIdx + 1 < segments.length ? segments[segIdx + 1].index : line.text.length;
-                  const canvasX = mctx.measureText(line.text.slice(0, index2)).width;
-                  const canvasWidth = mctx.measureText(line.text.slice(0, nextIndex)).width - canvasX;
-                  const carrierEl = document.createElement("span");
-                  carrierEl.textContent = segment;
-                  carrierEl.style.position = "relative";
-                  carrierEl.style.display = "inline-block";
-                  carrierEl.style.left = `${canvasX - runningX}px`;
-                  carrierEl.style.width = `${canvasWidth}px`;
-                  carrierEl.style.boxSizing = "border-box";
-                  carrierEl.style.lineHeight = `${lineHeight2}px`;
-                  carrierEl.style.whiteSpace = "pre";
-                  carrierEl.style.verticalAlign = "top";
-                  carrierEl.style.unicodeBidi = "isolate";
-                  lineElement.appendChild(carrierEl);
-                  runningX += canvasWidth;
+                if (line.shapedPaint) {
+                  const segments = [...segmenter.segment(line.text)];
+                  let runningX = 0;
+                  for (let segIdx = 0; segIdx < segments.length; segIdx++) {
+                    const { segment, index: index2 } = segments[segIdx];
+                    const nextIndex = segIdx + 1 < segments.length ? segments[segIdx + 1].index : line.text.length;
+                    const canvasX = mctx.measureText(line.text.slice(0, index2)).width;
+                    const canvasWidth = mctx.measureText(line.text.slice(0, nextIndex)).width - canvasX;
+                    const carrierEl = document.createElement("span");
+                    carrierEl.textContent = segment;
+                    carrierEl.style.position = "relative";
+                    carrierEl.style.display = "inline-block";
+                    carrierEl.style.left = `${canvasX - runningX}px`;
+                    carrierEl.style.width = `${canvasWidth}px`;
+                    carrierEl.style.boxSizing = "border-box";
+                    carrierEl.style.lineHeight = `${lineHeight2}px`;
+                    carrierEl.style.whiteSpace = "pre";
+                    carrierEl.style.verticalAlign = "top";
+                    carrierEl.style.unicodeBidi = "isolate";
+                    lineElement.appendChild(carrierEl);
+                    runningX += canvasWidth;
+                  }
+                } else {
+                  for (const { segment } of segmenter.segment(line.text)) {
+                    const canvasWidth = mctx.measureText(segment).width;
+                    const carrierEl = document.createElement("span");
+                    carrierEl.textContent = segment;
+                    carrierEl.style.position = "relative";
+                    carrierEl.style.display = "inline-block";
+                    carrierEl.style.width = `${canvasWidth}px`;
+                    carrierEl.style.boxSizing = "border-box";
+                    carrierEl.style.lineHeight = `${lineHeight2}px`;
+                    carrierEl.style.whiteSpace = "pre";
+                    carrierEl.style.verticalAlign = "top";
+                    carrierEl.style.unicodeBidi = "isolate";
+                    lineElement.appendChild(carrierEl);
+                  }
                 }
               } else {
                 lineElement.textContent = line.text;
@@ -6684,7 +6775,7 @@ var Scene = class _Scene {
     const hasInteractive = this.frameHadInteractive;
     const wantsContentSync = this.contentProjectionEnabled;
     const shouldSyncInterval = this.a11ySyncInterval <= 0 || time - this.lastA11ySync >= this.a11ySyncInterval;
-    if ((hasInteractive || this.a11yElements.size > 0 || wantsContentSync) && (shouldSyncInterval || this.a11yPendingSyncAfterAnimation)) {
+    if ((hasInteractive || this.a11yElements.size > 0 || wantsContentSync) && (shouldSyncInterval || !hasActiveAnimation && this.a11yPendingSyncAfterAnimation)) {
       this.lastA11ySync = time;
       if (hasInteractive || wantsContentSync) {
         const userTiming = this.phases.userTiming ? beginVectoUserTiming(VECTO_USER_TIMING.scene.a11ySync) : null;
@@ -7544,7 +7635,7 @@ var GridTextEntity = class extends Entity {
   updateGrid(ascii) {
     this.grid = ascii;
     this.rows = ascii.length;
-    this.cols = ascii[0]?.length || 0;
+    this.cols = ascii.reduce((widest, row) => Math.max(widest, row?.length ?? 0), 0);
   }
   isPointInside(_globalX, _globalY) {
     return false;
@@ -7632,6 +7723,12 @@ var SplineEntity = class extends Entity {
   /** Logical (CSS-pixel) size of the baked bitmap — the blit destination size. */
   bakedWidth = 0;
   bakedHeight = 0;
+  /**
+   * Device-pixel ratio the bitmap was rasterized at. Tracked so a DPR change
+   * (browser zoom, a monitor move, a renderer whose clamp changed) re-bakes
+   * instead of blitting a bitmap at the wrong device density forever.
+   */
+  bakedDPR = 0;
   /**
    * 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
@@ -7855,14 +7952,14 @@ var SplineEntity = class extends Entity {
     }
   }
   /** Bake all equations into an OffscreenCanvas once (when available). */
-  bake() {
+  bake(dpr) {
     this.baked = true;
     const pad = this.lineWidth + 2;
     const w = Math.max(1, Math.ceil(this.bounds.width) + pad * 2);
     const h = Math.max(1, Math.ceil(this.bounds.height) + pad * 2);
     this.bakedWidth = w;
     this.bakedHeight = h;
-    const dpr = typeof window !== "undefined" && typeof window.devicePixelRatio === "number" ? window.devicePixelRatio || 1 : 1;
+    this.bakedDPR = dpr;
     let canvas;
     if (typeof OffscreenCanvas !== "undefined") {
       canvas = new OffscreenCanvas(w * dpr, h * dpr);
@@ -7910,7 +8007,8 @@ var SplineEntity = class extends Entity {
   render(r) {
     let rendered = false;
     if (this.cache && !this.containsGradient) {
-      if (!this.baked) this.bake();
+      const dpr = typeof r.pixelRatio === "number" && r.pixelRatio > 0 ? r.pixelRatio : typeof window !== "undefined" && typeof window.devicePixelRatio === "number" ? window.devicePixelRatio || 1 : 1;
+      if (!this.baked || this.bakedDPR !== dpr) this.bake(dpr);
       if (this.offscreen) {
         const pad = this.lineWidth + 2;
         r.drawImage(

package/dist/renderer/WebGLPointRenderer.d.ts

@@ -49,9 +49,9 @@ export interface PointRenderer {
      *
      * Batching here is by primitive type — one draw per active type — so draw calls
      * and batches are the same number, and both are bounded at five plus one per
-     * mid-frame MSDF atlas switch. That switch is the only variable term and the
-     * only thing worth watching: it forces a commit of glyphs batched against the
-     * previous font.
+     * mid-frame atlas switch (MSDF or sprite). Those switches are the only
+     * variable term and the only thing worth watching: each forces a commit of
+     * glyphs/sprites batched against the previous atlas.
      */
     stats?(): WebGLDrawStats;
     /** Add one circle in world (CSS-pixel) coordinates; `alpha` multiplies the color's. */

package/dist/renderer/colorParse.d.ts

@@ -8,8 +8,8 @@ export type RGBA = [number, number, number, number];
  * Fast paths handle `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa` and `rgb()`/`rgba()`;
  * other forms (named colors, `hsl()`, …) resolve via a cached 1×1 canvas when a
  * DOM is available. Results are cached per input string and shared by identity,
- * so callers must treat the returned array as read-only. Unparseable input with
- * no DOM yields opaque black `[0, 0, 0, 1]`.
+ * so callers must treat the returned array as read-only. Unparseable input
+ * yields opaque black `[0, 0, 0, 1]` regardless of DOM availability.
  *
  * @param css - A CSS color string, e.g. `'#38bdf8'` or `'rgba(0,0,0,.5)'`.
  * @returns The cached `[r, g, b, a]` tuple in `[0, 1]`.

package/dist/renderer/url.d.ts

@@ -16,8 +16,10 @@
  * 2. Trims leading whitespace (browsers do this before scheme resolution).
  * 3. If the URL is relative (no scheme, or starts with `#`, `?`, `/`, `./`),
  *    returns it verbatim — relative navigation is never script-injectable.
- * 4. If the URL parses with a scheme NOT in {@link SAFE_SCHEMES}, returns `'#'`
- *    to keep the link non-empty but inert.
+ * 4. If the URL parses with a scheme NOT in {@link SAFE_SCHEMES} — after HTML
+ *    character references are decoded, so an entity-encoded payload cannot
+ *    smuggle a scheme past the check — returns `'#'` to keep the link non-empty
+ *    but inert.
  * 5. Otherwise returns the trimmed input unchanged (no canonicalization).
  *
  * The function never throws; malformed input falls back to `'#'`.

package/dist/renderer.js

@@ -10,7 +10,7 @@
 
 
 
-var _chunkM73XB4ZKjs = require('./chunk-M73XB4ZK.js');
+var _chunkMO24PVGTjs = require('./chunk-MO24PVGT.js');
 
 
 
@@ -22,4 +22,4 @@ var _chunkM73XB4ZKjs = require('./chunk-M73XB4ZK.js');
 
 
 
-exports.CanvasRenderer = _chunkM73XB4ZKjs.CanvasRenderer; exports.GlyphRasterAtlas = _chunkM73XB4ZKjs.GlyphRasterAtlas; exports.SVGRenderer = _chunkM73XB4ZKjs.SVGRenderer; exports.TextRasterCache = _chunkM73XB4ZKjs.TextRasterCache; exports.WebGPUParticleSystemManager = _chunkM73XB4ZKjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkM73XB4ZKjs.createWebGLPointRenderer; exports.installRendererDevTraps = _chunkM73XB4ZKjs.installRendererDevTraps; exports.isRendererDevMode = _chunkM73XB4ZKjs.isRendererDevMode; exports.parseColorToRGBA = _chunkM73XB4ZKjs.parseColorToRGBA; exports.setRendererDevMode = _chunkM73XB4ZKjs.setRendererDevMode;
+exports.CanvasRenderer = _chunkMO24PVGTjs.CanvasRenderer; exports.GlyphRasterAtlas = _chunkMO24PVGTjs.GlyphRasterAtlas; exports.SVGRenderer = _chunkMO24PVGTjs.SVGRenderer; exports.TextRasterCache = _chunkMO24PVGTjs.TextRasterCache; exports.WebGPUParticleSystemManager = _chunkMO24PVGTjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkMO24PVGTjs.createWebGLPointRenderer; exports.installRendererDevTraps = _chunkMO24PVGTjs.installRendererDevTraps; exports.isRendererDevMode = _chunkMO24PVGTjs.isRendererDevMode; exports.parseColorToRGBA = _chunkMO24PVGTjs.parseColorToRGBA; exports.setRendererDevMode = _chunkMO24PVGTjs.setRendererDevMode;

package/dist/renderer.mjs

@@ -9,7 +9,7 @@ import {
   isRendererDevMode,
   parseColorToRGBA,
   setRendererDevMode
-} from "./chunk-IFSFHYF7.mjs";
+} from "./chunk-25PS5K7R.mjs";
 export {
   CanvasRenderer,
   GlyphRasterAtlas,

package/dist/text.js

@@ -2,11 +2,11 @@
 
 
 
-var _chunkXXU56ZNAjs = require('./chunk-XXU56ZNA.js');
+var _chunkXHPUCU5Pjs = require('./chunk-XHPUCU5P.js');
 
 // src/text/index.ts
 var _text = require('@vectojs/text'); _createStarExport(_text);
 
 
 
-exports.MSDFTextEntity = _chunkXXU56ZNAjs.MSDFTextEntity; exports.SVGEntity = _chunkXXU56ZNAjs.SVGEntity;
+exports.MSDFTextEntity = _chunkXHPUCU5Pjs.MSDFTextEntity; exports.SVGEntity = _chunkXHPUCU5Pjs.SVGEntity;

package/dist/text.mjs

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

package/dist/tree/Entity.d.ts

@@ -116,6 +116,21 @@ export interface ContentProjectionLine {
      * hit-mapping when DOM order != visual order (PR #146 revert).
      */
     perGraphemeCarriers?: boolean;
+    /**
+     * The canvas painted this line's ink as ONE shaped `fillText(line.text)`, so
+     * the ink includes the browser's kerning and ligatures. Per-grapheme
+     * carriers must then be measured as shaped PREFIX DIFFERENCES of the whole
+     * line — isolated grapheme advances would omit exactly the kerning/ligature
+     * contraction the paint applied, widening the DOM line past the ink.
+     *
+     * Leave unset for per-glyph painters (glyphs placed at summed isolated
+     * advances, e.g. RichText and TextEntity): there the ink is unkerned, and
+     * shaped prefixes would drift the carriers ahead of it by the accumulated
+     * kerning delta instead.
+     *
+     * Only meaningful alongside {@link perGraphemeCarriers}.
+     */
+    shapedPaint?: boolean;
 }
 /**
  * Advice from the {@link Scene} about which part of an entity is worth

package/dist/tree/Scene.d.ts

@@ -936,21 +936,21 @@ export declare class Scene {
     _registerActiveDriverEntity(entity: Entity): void;
     /**
      * Drop `entity` and its whole subtree from the batched-driver candidate set.
-     * Called by {@link remove}/{@link hideOverlay} on detach: without this a
-     * removed-but-still-animating entity stays pinned in the Set (a leak) and its
-     * drivers keep ticking every frame even though it is off-tree. If it is later
-     * re-added, {@link registerActiveDriverSubtree} re-registers any node that
-     * still has live drivers, so the motion resumes.
+     * Called by `Entity.remove` on detach (which `remove`/`hideOverlay` route
+     * through): without this a removed-but-still-animating entity stays pinned in
+     * the Set (a leak) and its drivers keep ticking every frame even though it is
+     * off-tree. If it is later re-added, {@link _registerActiveDriverSubtree}
+     * re-registers any node that still has live drivers, so the motion resumes.
      */
-    private unregisterActiveDriverSubtree;
+    _unregisterActiveDriverSubtree(entity: Entity): void;
     /**
      * Re-register every node in `entity`'s subtree that still has live property
-     * drivers. Called by {@link add}/{@link showOverlay} so re-attaching a subtree
-     * that was removed mid-animation resumes its batched drivers (they were
-     * dropped from the candidate set on removal, but the driver state still lives
-     * on each entity).
+     * drivers. Called by `Entity._addOne` so re-attaching a subtree that was
+     * removed mid-animation resumes its batched drivers (they were dropped from
+     * the candidate set on removal, but the driver state still lives on each
+     * entity).
      */
-    private registerActiveDriverSubtree;
+    _registerActiveDriverSubtree(entity: Entity): void;
     /**
      * Advance every registered entity's active drivers for this frame, batching
      * whichever are batchable (`SpringDriver`; `TweenDriver` with a named
@@ -1247,8 +1247,9 @@ export declare class Scene {
      * workload rendered ~1.0 frames per content change. To measure anything about
      * scheduling, use {@link start} and let `requestAnimationFrame` drive.
      *
-     * @param dt Seconds to advance. Not clamped by `MAX_FRAME_DT` — the caller
-     *   chooses the step, since determinism is the point.
+     * @param dt Milliseconds to advance (same unit as the rAF timestamps `loop`
+     *   feeds `render`). Not clamped by `MAX_FRAME_DT` — the caller chooses the
+     *   step, since determinism is the point.
      */
     step(dt: number): void;
     /**

package/dist/wasm/anim-backend.d.ts

@@ -7,9 +7,13 @@
  * (see `Scene._tickBatchedDrivers`), simply keeps using it.
  *
  * The kernel (`crates/vectojs-core-rs/src/anim.rs`) is bit-identical to
- * `SpringPhysics.update` for springs; tweens match to ~1e-9 (not bit-exact — a
- * `Math.pow`-vs-`powi` ULP difference recorded as a spike finding), which is why
- * a WASM-batched tween needs a `retarget`-style resync, not raw byte reuse.
+ * `SpringPhysics.update` for springs, and to the JS tweens too since the
+ * explicit-multiplication rewrite: `easing.ts` and the kernel's `ease()` both
+ * express integer powers as explicit multiplication (no `Math.pow`/`powi`,
+ * neither of which is correctly rounded), so the earlier ~1e-12 ULP gap is
+ * closed. Batched state still needs re-seeding per frame — `elapsed` is
+ * kernel-side state, so every gather re-writes it from the driver rather than
+ * letting the kernel's copy drift.
  *
  * Unlike the transform/hit-test stores, this backend holds no cross-frame
  * residency: every qualifying frame re-gathers ALL currently-active batchable
@@ -56,6 +60,12 @@ export declare class AnimBackend {
      * writing first and sizing after would write into a stale buffer.
      */
     ensure(springCount: number, tweenCount: number): void;
+    /**
+     * Re-create the typed-array views if another backend's allocation grew the
+     * shared linear memory and detached them (see {@link viewsStale}). Call after
+     * {@link ensure} and before writing into {@link springView}/{@link tweenView}.
+     */
+    revalidateViews(): void;
     /**
      * Advance `count` springs (from index 0) by `dtMs` milliseconds, in place.
      * Returns `true` when the kernel ran. `false` means it rejected the call

package/dist/wasm/backend.d.ts

@@ -27,7 +27,20 @@ export declare const WASM_STATUS: {
     readonly UNINITIALIZED: 2;
     /** A sibling run addressed a slot or parent outside the store. */
     readonly BAD_RUN: 3;
+    /** A requested capacity's size arithmetic overflowed; the previous store
+     *  was left untouched. */
+    readonly OVERFLOW: 4;
 };
+/**
+ * True when a backend's resident typed-array views must be rebuilt: the shared
+ * `WebAssembly.Memory` buffer they were constructed over has been detached
+ * (reads as `byteLength === 0`) or replaced. Every backend of a Scene shares one
+ * instance and therefore one linear memory, so ANY backend's `*_init` can grow
+ * it and detach the views of every other backend. The transform backend keeps
+ * this check inline in {@link WasmTransformBackend.revalidateViews}; the anim/
+ * hit/particle backends reuse this helper.
+ */
+export declare function viewsStale(cap: number, probe: ArrayBufferView, memory: WebAssembly.Memory): boolean;
 /** Which kernel to run. `simd` is the default; `scalar` exists for A/B and for
  *  the (theoretical) case of a build without simd128. Both are f64 and
  *  bit-identical to {@link composeJS}. */