@vectojs/core 1.16.3 → 1.17.1

package/dist/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;const __vecto_cjs_url=require("url").pathToFileURL(__filename).href;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11;const __vecto_cjs_url=require("url").pathToFileURL(__filename).href;
 
 
 
@@ -469,7 +469,158 @@ function buildTreeStore(root) {
   return { store, indexOf };
 }
 
+// src/wasm/hit-store.ts
+function gatherHitAABBs(root, currentFrame) {
+  const slotEntity = [];
+  const boundless = [];
+  const minxs = [];
+  const minys = [];
+  const maxxs = [];
+  const maxys = [];
+  const scratch = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+  const visit = (node) => {
+    const index = slotEntity.length;
+    slotEntity.push(node);
+    const bounds = node.getBounds();
+    if (bounds === null) {
+      boundless.push({ entity: node, index });
+      minxs.push(0);
+      minys.push(0);
+      maxxs.push(0);
+      maxys.push(0);
+    } else {
+      if (!node._readWorldCache(currentFrame, scratch)) {
+        const t = node.getWorldTransform();
+        scratch.a = t.a;
+        scratch.b = t.b;
+        scratch.c = t.c;
+        scratch.d = t.d;
+        scratch.e = t.e;
+        scratch.f = t.f;
+      }
+      const { a, b, c, d, e, f } = scratch;
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (let i = 0; i < 4; i++) {
+        const lx = i & 1 ? bounds.x + bounds.width : bounds.x;
+        const ly = i & 2 ? bounds.y + bounds.height : bounds.y;
+        const wx = a * lx + c * ly + e;
+        const wy = b * lx + d * ly + f;
+        if (wx < minX) minX = wx;
+        if (wx > maxX) maxX = wx;
+        if (wy < minY) minY = wy;
+        if (wy > maxY) maxY = wy;
+      }
+      minxs.push(minX);
+      minys.push(minY);
+      maxxs.push(maxX);
+      maxys.push(maxY);
+    }
+    const kids = node.children;
+    for (let i = 0; i < kids.length; i++) visit(kids[i]);
+  };
+  visit(root);
+  return {
+    count: slotEntity.length,
+    slotEntity,
+    boundless,
+    minx: Float64Array.from(minxs),
+    miny: Float64Array.from(minys),
+    maxx: Float64Array.from(maxxs),
+    maxy: Float64Array.from(maxys)
+  };
+}
+
+// src/wasm/hit-store-fused.ts
+function gatherHitAABBsFromStore(root, aabbs, storeSlotEntity, out) {
+  const slotEntity = out.slotEntity;
+  const boundless = out.boundless;
+  slotEntity.length = 0;
+  boundless.length = 0;
+  let count = 0;
+  let capacity = out.minx.length;
+  let minx = out.minx;
+  let miny = out.miny;
+  let maxx = out.maxx;
+  let maxy = out.maxy;
+  const grow = (needed) => {
+    if (needed <= capacity) return;
+    let next = capacity || 256;
+    while (next < needed) next *= 2;
+    const nminx = new Float64Array(next);
+    const nminy = new Float64Array(next);
+    const nmaxx = new Float64Array(next);
+    const nmaxy = new Float64Array(next);
+    nminx.set(minx);
+    nminy.set(miny);
+    nmaxx.set(maxx);
+    nmaxy.set(maxy);
+    minx = nminx;
+    miny = nminy;
+    maxx = nmaxx;
+    maxy = nmaxy;
+    capacity = next;
+  };
+  let bailed = false;
+  const visit = (node) => {
+    if (bailed) return;
+    const index = count;
+    slotEntity.push(node);
+    count++;
+    grow(count);
+    if (node.getBounds() === null) {
+      boundless.push({ entity: node, index });
+      minx[index] = 0;
+      miny[index] = 0;
+      maxx[index] = 0;
+      maxy[index] = 0;
+    } else {
+      const slot = node._storeSlot;
+      if (slot < 0 || slot >= aabbs.aminx.length || storeSlotEntity[slot] !== node) {
+        bailed = true;
+        return;
+      }
+      minx[index] = aabbs.aminx[slot];
+      miny[index] = aabbs.aminy[slot];
+      maxx[index] = aabbs.amaxx[slot];
+      maxy[index] = aabbs.amaxy[slot];
+    }
+    const children = node.children;
+    for (let i = 0; i < children.length; i++) visit(children[i]);
+  };
+  visit(root);
+  if (bailed) return null;
+  out.count = count;
+  out.minx = minx;
+  out.miny = miny;
+  out.maxx = maxx;
+  out.maxy = maxy;
+  return out;
+}
+function createHitGatherBuffer() {
+  return {
+    count: 0,
+    slotEntity: [],
+    boundless: [],
+    minx: new Float64Array(256),
+    miny: new Float64Array(256),
+    maxx: new Float64Array(256),
+    maxy: new Float64Array(256)
+  };
+}
+
 // src/wasm/backend.ts
+var WASM_STATUS = {
+  OK: 0,
+  /** A count exceeded what `init` allocated. */
+  CAPACITY: 1,
+  /** A kernel ran before `init`. */
+  UNINITIALIZED: 2,
+  /** A sibling run addressed a slot or parent outside the store. */
+  BAD_RUN: 3
+};
 var PAD2 = 8;
 var WasmTransformBackend = (_class2 = class {
   __init8() {this.available = true}
@@ -502,7 +653,7 @@ var WasmTransformBackend = (_class2 = class {
   
   
   
-  constructor(instance) {;_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);
+  constructor(instance) {;_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);
     this.ex = instance.exports;
   }
   /** Compose world matrices for `store` in WASM, writing back into its
@@ -521,9 +672,13 @@ var WasmTransformBackend = (_class2 = class {
     this.vrp.set(store.runParent.subarray(0, rc));
     this.vrs.set(store.runStart.subarray(0, rc));
     this.vrl.set(store.runLen.subarray(0, rc));
-    this.ex.set_run_count(rc);
-    if (kernel === "scalar") this.ex.compose_scalar();
-    else this.ex.compose_simd();
+    if (this.ex.set_run_count(rc) !== WASM_STATUS.OK) {
+      this.lastStatus = WASM_STATUS.CAPACITY;
+      return;
+    }
+    const status = kernel === "scalar" ? this.ex.compose_scalar() : this.ex.compose_simd();
+    this.lastStatus = status;
+    if (status !== WASM_STATUS.OK) return;
     store.wa.set(this.vwa.subarray(0, n));
     store.wb.set(this.vwb.subarray(0, n));
     store.wc.set(this.vwc.subarray(0, n));
@@ -543,8 +698,9 @@ var WasmTransformBackend = (_class2 = class {
    * {@link uploadRuns} after a topology change.
    */
   runKernel(kernel = "simd") {
-    if (kernel === "scalar") this.ex.compose_scalar();
-    else this.ex.compose_simd();
+    const status = kernel === "scalar" ? this.ex.compose_scalar() : this.ex.compose_simd();
+    this.lastStatus = status;
+    return status;
   }
   /** Upload only the run table + count (topology), leaving per-entity inputs to
    *  the resident views. Call when the tree structure changes, not per frame. */
@@ -554,8 +710,13 @@ var WasmTransformBackend = (_class2 = class {
     this.vrp.set(store.runParent.subarray(0, rc));
     this.vrs.set(store.runStart.subarray(0, rc));
     this.vrl.set(store.runLen.subarray(0, rc));
-    this.ex.set_run_count(rc);
+    this.lastStatus = this.ex.set_run_count(rc);
   }
+  /**
+   * Status of the most recent kernel or run-table call. `WASM_STATUS.OK` unless
+   * the crate rejected its arguments, in which case that call was a no-op.
+   */
+  __init11() {this.lastStatus = WASM_STATUS.OK}
   /** The resident wasm input views (`x,y,sx,sy,cos,sin,opacity`), valid until
    *  the next capacity growth. Writing here is what makes uploads unnecessary. */
   inputView() {
@@ -623,6 +784,22 @@ var WasmTransformBackend = (_class2 = class {
       amaxy: this.vamaxy
     };
   }
+  /**
+   * Re-create the typed-array views if the memory buffer they were built over has
+   * been detached.
+   *
+   * Necessary because all backends of a Scene now share one instance, and
+   * therefore one linear memory: another backend's allocation (notably
+   * `hit_init`, which allocates its own grid arrays) can grow the memory and
+   * detach every view built over the old buffer. A detached `Float64Array` reads
+   * as length 0 and silently returns `undefined` for every index, so without this
+   * the transform store appears empty rather than failing loudly.
+   */
+  revalidateViews() {
+    if (this.cap === 0) return;
+    if (this.vwa.length === this.cap && this.vwa.buffer === this.ex.memory.buffer) return;
+    this.refreshViews();
+  }
   ensure(count, runCount) {
     if (count + PAD2 <= this.cap && runCount <= this.runCap) return;
     this.cap = count + PAD2;
@@ -665,106 +842,81 @@ var WasmTransformBackend = (_class2 = class {
     this.vrl = i32(this.ex.p_run_len());
   }
 }, _class2);
-async function instantiateAsync(bytes) {
-  try {
-    const { instance } = await WebAssembly.instantiate(bytes, {});
-    return new WasmTransformBackend(instance);
-  } catch (e3) {
-    return null;
+
+// src/wasm/anim-backend.ts
+var PAD3 = 8;
+var AnimBackend = (_class3 = class {
+  
+  __init12() {this.springCap = 0}
+  __init13() {this.tweenCap = 0}
+  
+  
+  constructor(instance) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);
+    this.ex = instance.exports;
   }
-}
-async function instantiateStreaming(source) {
-  try {
-    const resp = typeof source === "string" || source instanceof URL ? await fetch(String(source)) : await source;
-    if (typeof WebAssembly.instantiateStreaming === "function") {
-      const buffered = resp.clone();
-      try {
-        const { instance: instance2 } = await WebAssembly.instantiateStreaming(resp, {});
-        return new WasmTransformBackend(instance2);
-      } catch (e4) {
-        const { instance: instance2 } = await WebAssembly.instantiate(await buffered.arrayBuffer(), {});
-        return new WasmTransformBackend(instance2);
-      }
-    }
-    const { instance } = await WebAssembly.instantiate(await resp.arrayBuffer(), {});
-    return new WasmTransformBackend(instance);
-  } catch (e5) {
-    return null;
+  /** The resident spring SoA input/output views, valid until the next capacity
+   *  growth. Write gathered driver state here before calling {@link stepSprings}. */
+  springView() {
+    return this.sv;
   }
-}
-
-// src/wasm/hit-store.ts
-function gatherHitAABBs(root, currentFrame) {
-  const slotEntity = [];
-  const boundless = [];
-  const minxs = [];
-  const minys = [];
-  const maxxs = [];
-  const maxys = [];
-  const scratch = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
-  const visit = (node) => {
-    const index = slotEntity.length;
-    slotEntity.push(node);
-    const bounds = node.getBounds();
-    if (bounds === null) {
-      boundless.push({ entity: node, index });
-      minxs.push(0);
-      minys.push(0);
-      maxxs.push(0);
-      maxys.push(0);
-    } else {
-      if (!node._readWorldCache(currentFrame, scratch)) {
-        const t = node.getWorldTransform();
-        scratch.a = t.a;
-        scratch.b = t.b;
-        scratch.c = t.c;
-        scratch.d = t.d;
-        scratch.e = t.e;
-        scratch.f = t.f;
-      }
-      const { a, b, c, d, e, f } = scratch;
-      let minX = Infinity;
-      let minY = Infinity;
-      let maxX = -Infinity;
-      let maxY = -Infinity;
-      for (let i = 0; i < 4; i++) {
-        const lx = i & 1 ? bounds.x + bounds.width : bounds.x;
-        const ly = i & 2 ? bounds.y + bounds.height : bounds.y;
-        const wx = a * lx + c * ly + e;
-        const wy = b * lx + d * ly + f;
-        if (wx < minX) minX = wx;
-        if (wx > maxX) maxX = wx;
-        if (wy < minY) minY = wy;
-        if (wy > maxY) maxY = wy;
-      }
-      minxs.push(minX);
-      minys.push(minY);
-      maxxs.push(maxX);
-      maxys.push(maxY);
-    }
-    const kids = node.children;
-    for (let i = 0; i < kids.length; i++) visit(kids[i]);
-  };
-  visit(root);
-  return {
-    count: slotEntity.length,
-    slotEntity,
-    boundless,
-    minx: Float64Array.from(minxs),
-    miny: Float64Array.from(minys),
-    maxx: Float64Array.from(maxxs),
-    maxy: Float64Array.from(maxys)
-  };
-}
+  /** The resident tween SoA input/output views, valid until the next capacity
+   *  growth. Write gathered driver state here before calling {@link stepTweens}. */
+  tweenView() {
+    return this.tv;
+  }
+  /**
+   * Size (and grow, if needed) capacity for `springCount` springs and
+   * `tweenCount` tweens. Call this BEFORE writing into {@link springView}/
+   * {@link tweenView} — a capacity growth detaches the previous views, so
+   * writing first and sizing after would write into a stale buffer.
+   */
+  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);
+    this.refreshViews();
+  }
+  /** Advance `count` springs (from index 0) by `dtMs` milliseconds, in place. */
+  stepSprings(dtMs, count) {
+    this.ex.spring_step(dtMs / 1e3, count);
+  }
+  /** Advance `count` tweens (from index 0) by `dtMs` milliseconds, writing `val`. */
+  stepTweens(dtMs, count) {
+    this.ex.tween_step(dtMs, count);
+  }
+  refreshViews() {
+    const buf = this.ex.memory.buffer;
+    const sCap = this.springCap;
+    const tCap = this.tweenCap;
+    this.sv = {
+      val: new Float64Array(buf, this.ex.p_s_val(), sCap),
+      target: new Float64Array(buf, this.ex.p_s_target(), sCap),
+      vel: new Float64Array(buf, this.ex.p_s_vel(), sCap),
+      stiff: new Float64Array(buf, this.ex.p_s_stiff(), sCap),
+      damp: new Float64Array(buf, this.ex.p_s_damp(), sCap),
+      mass: new Float64Array(buf, this.ex.p_s_mass(), sCap)
+    };
+    this.tv = {
+      from: new Float64Array(buf, this.ex.p_t_from(), tCap),
+      to: new Float64Array(buf, this.ex.p_t_to(), tCap),
+      elapsed: new Float64Array(buf, this.ex.p_t_elapsed(), tCap),
+      dur: new Float64Array(buf, this.ex.p_t_dur(), tCap),
+      delay: new Float64Array(buf, this.ex.p_t_delay(), tCap),
+      ease: new Float64Array(buf, this.ex.p_t_ease(), tCap),
+      val: new Float64Array(buf, this.ex.p_t_val(), tCap)
+    };
+  }
+}, _class3);
 
 // src/wasm/hit-backend.ts
-var PAD3 = 8;
+var PAD4 = 8;
 var CELLS_PER_ENTITY_HINT = 4;
-var HitTestBackend = (_class3 = class {
+var HitTestBackend = (_class4 = class {
   
-  __init11() {this.entityCap = 0}
-  __init12() {this.cellCap = 0}
-  __init13() {this.itemCap = 0}
+  __init14() {this.entityCap = 0}
+  __init15() {this.cellCap = 0}
+  __init16() {this.itemCap = 0}
   
   
   
@@ -773,10 +925,10 @@ var HitTestBackend = (_class3 = class {
   
   
   /** Grid geometry from the last {@link ensure} call. */
-  __init14() {this.gridW = 0}
-  __init15() {this.gridH = 0}
-  __init16() {this.cellSize = 64}
-  constructor(instance) {;_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);
+  __init17() {this.gridW = 0}
+  __init18() {this.gridH = 0}
+  __init19() {this.cellSize = 64}
+  constructor(instance) {;_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);
     this.ex = instance.exports;
   }
   /** The resident AABB input views (`minx/miny/maxx/maxy`), valid until the
@@ -830,10 +982,10 @@ var HitTestBackend = (_class3 = class {
     return this.vItems.subarray(start, start + count);
   }
   growIfNeeded(count, cellCount, itemCount) {
-    if (count + PAD3 <= this.entityCap && cellCount <= this.cellCap && itemCount <= this.itemCap) {
+    if (count + PAD4 <= this.entityCap && cellCount <= this.cellCap && itemCount <= this.itemCap) {
       return;
     }
-    this.entityCap = count + PAD3;
+    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);
@@ -854,135 +1006,15 @@ var HitTestBackend = (_class3 = class {
     this.vCellCount = new Int32Array(buf, this.ex.p_h_cell_count(), cCap);
     this.vItems = new Int32Array(buf, this.ex.p_h_items(), iCap);
   }
-}, _class3);
-async function instantiateAsync2(bytes) {
-  try {
-    const { instance } = await WebAssembly.instantiate(bytes, {});
-    return new HitTestBackend(instance);
-  } catch (e6) {
-    return null;
-  }
-}
-async function instantiateStreaming2(source) {
-  try {
-    const resp = typeof source === "string" || source instanceof URL ? await fetch(String(source)) : await source;
-    if (typeof WebAssembly.instantiateStreaming === "function") {
-      const buffered = resp.clone();
-      try {
-        const { instance: instance2 } = await WebAssembly.instantiateStreaming(resp, {});
-        return new HitTestBackend(instance2);
-      } catch (e7) {
-        const { instance: instance2 } = await WebAssembly.instantiate(await buffered.arrayBuffer(), {});
-        return new HitTestBackend(instance2);
-      }
-    }
-    const { instance } = await WebAssembly.instantiate(await resp.arrayBuffer(), {});
-    return new HitTestBackend(instance);
-  } catch (e8) {
-    return null;
-  }
-}
-
-// src/wasm/anim-backend.ts
-var PAD4 = 8;
-var AnimBackend = (_class4 = class {
-  
-  __init17() {this.springCap = 0}
-  __init18() {this.tweenCap = 0}
-  
-  
-  constructor(instance) {;_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);
-    this.ex = instance.exports;
-  }
-  /** The resident spring SoA input/output views, valid until the next capacity
-   *  growth. Write gathered driver state here before calling {@link stepSprings}. */
-  springView() {
-    return this.sv;
-  }
-  /** The resident tween SoA input/output views, valid until the next capacity
-   *  growth. Write gathered driver state here before calling {@link stepTweens}. */
-  tweenView() {
-    return this.tv;
-  }
-  /**
-   * Size (and grow, if needed) capacity for `springCount` springs and
-   * `tweenCount` tweens. Call this BEFORE writing into {@link springView}/
-   * {@link tweenView} — a capacity growth detaches the previous views, so
-   * writing first and sizing after would write into a stale buffer.
-   */
-  ensure(springCount, tweenCount) {
-    if (springCount + PAD4 <= this.springCap && tweenCount + PAD4 <= this.tweenCap) return;
-    this.springCap = springCount + PAD4;
-    this.tweenCap = tweenCount + PAD4;
-    this.ex.anim_init(this.springCap, this.tweenCap);
-    this.refreshViews();
-  }
-  /** Advance `count` springs (from index 0) by `dtMs` milliseconds, in place. */
-  stepSprings(dtMs, count) {
-    this.ex.spring_step(dtMs / 1e3, count);
-  }
-  /** Advance `count` tweens (from index 0) by `dtMs` milliseconds, writing `val`. */
-  stepTweens(dtMs, count) {
-    this.ex.tween_step(dtMs, count);
-  }
-  refreshViews() {
-    const buf = this.ex.memory.buffer;
-    const sCap = this.springCap;
-    const tCap = this.tweenCap;
-    this.sv = {
-      val: new Float64Array(buf, this.ex.p_s_val(), sCap),
-      target: new Float64Array(buf, this.ex.p_s_target(), sCap),
-      vel: new Float64Array(buf, this.ex.p_s_vel(), sCap),
-      stiff: new Float64Array(buf, this.ex.p_s_stiff(), sCap),
-      damp: new Float64Array(buf, this.ex.p_s_damp(), sCap),
-      mass: new Float64Array(buf, this.ex.p_s_mass(), sCap)
-    };
-    this.tv = {
-      from: new Float64Array(buf, this.ex.p_t_from(), tCap),
-      to: new Float64Array(buf, this.ex.p_t_to(), tCap),
-      elapsed: new Float64Array(buf, this.ex.p_t_elapsed(), tCap),
-      dur: new Float64Array(buf, this.ex.p_t_dur(), tCap),
-      delay: new Float64Array(buf, this.ex.p_t_delay(), tCap),
-      ease: new Float64Array(buf, this.ex.p_t_ease(), tCap),
-      val: new Float64Array(buf, this.ex.p_t_val(), tCap)
-    };
-  }
 }, _class4);
-async function instantiateAsync3(bytes) {
-  try {
-    const { instance } = await WebAssembly.instantiate(bytes, {});
-    return new AnimBackend(instance);
-  } catch (e9) {
-    return null;
-  }
-}
-async function instantiateStreaming3(source) {
-  try {
-    const resp = typeof source === "string" || source instanceof URL ? await fetch(String(source)) : await source;
-    if (typeof WebAssembly.instantiateStreaming === "function") {
-      const buffered = resp.clone();
-      try {
-        const { instance: instance2 } = await WebAssembly.instantiateStreaming(resp, {});
-        return new AnimBackend(instance2);
-      } catch (e10) {
-        const { instance: instance2 } = await WebAssembly.instantiate(await buffered.arrayBuffer(), {});
-        return new AnimBackend(instance2);
-      }
-    }
-    const { instance } = await WebAssembly.instantiate(await resp.arrayBuffer(), {});
-    return new AnimBackend(instance);
-  } catch (e11) {
-    return null;
-  }
-}
 
 // src/wasm/particle-backend.ts
 var PAD5 = 8;
 var ParticleBackend = (_class5 = class {
   
-  __init19() {this.cap = 0}
+  __init20() {this.cap = 0}
   
-  constructor(instance) {;_class5.prototype.__init19.call(this);
+  constructor(instance) {;_class5.prototype.__init20.call(this);
     this.ex = instance.exports;
   }
   /** The resident SoA views, valid until the next capacity growth. */
@@ -1067,33 +1099,95 @@ var ParticleBackend = (_class5 = class {
     };
   }
 }, _class5);
-async function instantiateAsync4(bytes) {
-  try {
-    const { instance } = await WebAssembly.instantiate(bytes, {});
-    return new ParticleBackend(instance);
-  } catch (e12) {
-    return null;
+
+// src/wasm/runtime.ts
+var moduleCache = /* @__PURE__ */ new Map();
+function cacheKey(source) {
+  if (typeof source === "string") return source;
+  if (source instanceof URL) return source.href;
+  return null;
+}
+function compileBytes(bytes) {
+  return new WebAssembly.Module(bytes);
+}
+async function compileRemote(source) {
+  const response = typeof source === "string" || source instanceof URL ? await fetch(String(source)) : await source;
+  if (typeof WebAssembly.compileStreaming === "function") {
+    const buffered = response.clone();
+    try {
+      return await WebAssembly.compileStreaming(response);
+    } catch (e3) {
+      return await WebAssembly.compile(await buffered.arrayBuffer());
+    }
   }
+  return await WebAssembly.compile(await response.arrayBuffer());
 }
-async function instantiateStreaming4(source) {
-  try {
-    const resp = typeof source === "string" || source instanceof URL ? await fetch(String(source)) : await source;
-    if (typeof WebAssembly.instantiateStreaming === "function") {
-      const buffered = resp.clone();
+async function loadCoreWasmModule(source) {
+  const key = cacheKey(source);
+  if (key !== null) {
+    const hit = moduleCache.get(key);
+    if (hit) {
       try {
-        const { instance: instance2 } = await WebAssembly.instantiateStreaming(resp, {});
-        return new ParticleBackend(instance2);
-      } catch (e13) {
-        const { instance: instance2 } = await WebAssembly.instantiate(await buffered.arrayBuffer(), {});
-        return new ParticleBackend(instance2);
+        return await hit;
+      } catch (e4) {
+        moduleCache.delete(key);
+        return null;
       }
     }
-    const { instance } = await WebAssembly.instantiate(await resp.arrayBuffer(), {});
-    return new ParticleBackend(instance);
-  } catch (e14) {
+  }
+  const pending = source instanceof ArrayBuffer || ArrayBuffer.isView(source) ? Promise.resolve().then(() => compileBytes(source)) : compileRemote(source);
+  if (key !== null) moduleCache.set(key, pending);
+  try {
+    return await pending;
+  } catch (e5) {
+    if (key !== null) moduleCache.delete(key);
+    return null;
+  }
+}
+var CoreWasmRuntime = (_class6 = class {
+  
+  __init21() {this.transformBackend = null}
+  __init22() {this.animBackend = null}
+  __init23() {this.hitBackend = null}
+  __init24() {this.particleBackendInstance = null}
+  constructor(instance) {;_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);
+    this.instance = instance;
+  }
+  /**
+   * Backends are constructed lazily and memoised: each one's constructor calls
+   * into the instance to size its store and build typed-array views, so building
+   * all four up front would pay for accelerators the Scene never enables.
+   */
+  transform() {
+    if (!this.transformBackend) this.transformBackend = new WasmTransformBackend(this.instance);
+    return this.transformBackend;
+  }
+  anim() {
+    if (!this.animBackend) this.animBackend = new AnimBackend(this.instance);
+    return this.animBackend;
+  }
+  hit() {
+    if (!this.hitBackend) this.hitBackend = new HitTestBackend(this.instance);
+    return this.hitBackend;
+  }
+  particle() {
+    if (!this.particleBackendInstance)
+      this.particleBackendInstance = new ParticleBackend(this.instance);
+    return this.particleBackendInstance;
+  }
+}, _class6);
+function createCoreWasmRuntime(module) {
+  try {
+    return new CoreWasmRuntime(new WebAssembly.Instance(module, {}));
+  } catch (e6) {
     return null;
   }
 }
+async function loadCoreWasmRuntime(source) {
+  const module = await loadCoreWasmModule(source);
+  if (!module) return null;
+  return createCoreWasmRuntime(module);
+}
 
 // src/tree/Scene.ts
 var _text = require('@vectojs/text'); _createStarExport(_text);
@@ -1383,13 +1477,13 @@ function extendSelection(selection, anchor, focus) {
   try {
     selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
     return;
-  } catch (e15) {
+  } catch (e7) {
   }
   try {
     selection.collapse(anchor.node, anchor.offset);
     selection.extend(focus.node, focus.offset);
     return;
-  } catch (e16) {
+  } catch (e8) {
   }
   const anchorRange = document.createRange();
   anchorRange.setStart(anchor.node, anchor.offset);
@@ -1408,7 +1502,7 @@ function extendSelection(selection, anchor, focus) {
   selection.removeAllRanges();
   selection.addRange(range);
 }
-var Scene = (_class6 = class _Scene {
+var Scene = (_class7 = class _Scene {
   static __initStatic() {this.webglCreator = null}
   static __initStatic2() {this.webgpuManagerClass = null}
   /** Upper bound (ms) on a single frame's `dt`. Caps the giant elapsed gap a
@@ -1424,15 +1518,15 @@ var Scene = (_class6 = class _Scene {
   
   
   
-  __init20() {this.isRunning = false}
+  __init25() {this.isRunning = false}
   /** Whether the canvas is at least partially in the viewport. When it scrolls
    *  fully off-screen the rAF loop pauses (stops rescheduling) instead of
    *  burning frames on a scene nobody can see; an IntersectionObserver resumes
    *  it on re-entry. Defaults true (and stays true where IntersectionObserver
    *  is unavailable, e.g. SSR/jsdom, so behavior is unchanged there). */
-  __init21() {this._canvasOnScreen = true}
-  __init22() {this._canvasObserver = null}
-  __init23() {this.lastTime = 0}
+  __init26() {this._canvasOnScreen = true}
+  __init27() {this._canvasObserver = null}
+  __init28() {this.lastTime = 0}
   
   /**
    * Redraw strategy:
@@ -1441,31 +1535,31 @@ var Scene = (_class6 = class _Scene {
    *   {@link markDirty}) or while an animation is pending. Ideal for static /
    *   event-driven UIs where idle frames should cost ~0.
    */
-  __init24() {this.renderMode = "always"}
-  __init25() {this.dirty = true}
+  __init29() {this.renderMode = "always"}
+  __init30() {this.dirty = true}
   /** Whether to throttle rendering to 2 FPS when the scene is static to save power. */
-  __init26() {this.autoThrottle = true}
+  __init31() {this.autoThrottle = true}
   // --- Frame telemetry (read via `frameStats`) ---------------------------
   /** Wall-clock ms spent inside the last `render()` call. */
-  __init27() {this._lastFrameMs = 0}
+  __init32() {this._lastFrameMs = 0}
   /** Rolling exponential average of rendered-frame intervals, in ms. */
-  __init28() {this._avgFrameIntervalMs = 0}
+  __init33() {this._avgFrameIntervalMs = 0}
   /** dt (ms) handed to the last rendered frame. */
-  __init29() {this._lastDt = 0}
+  __init34() {this._lastDt = 0}
   /** Count of frames actually rendered since the loop started. */
-  __init30() {this._renderedFrames = 0}
+  __init35() {this._renderedFrames = 0}
   /** Count of rAF ticks skipped (idle / capped) since the loop started. */
-  __init31() {this._skippedFrames = 0}
+  __init36() {this._skippedFrames = 0}
   /** `time` of the previous *rendered* frame, for interval measurement. */
-  __init32() {this._lastRenderTick = 0}
+  __init37() {this._lastRenderTick = 0}
   /**
    * Frame-rate cap (power saving). `0` = uncapped (native refresh). When set,
    * the loop renders at most `maxFPS` times per second; animations still run,
    * just less often. See {@link SceneOptions.maxFPS}.
    */
-  __init33() {this.maxFPS = 60}
+  __init38() {this.maxFPS = 60}
   /** Whether the OS prefers-reduced-motion setting auto-caps the loop. */
-  __init34() {this.respectReducedMotion = true}
+  __init39() {this.respectReducedMotion = true}
   /**
    * Reading direction for accessibility tab/traversal order (`'ltr'` default,
    * `'rtl'`). Controls the inline sort within a visual row in
@@ -1481,15 +1575,15 @@ var Scene = (_class6 = class _Scene {
       this.a11yNeedsReorder = true;
     }
   }
-  __init35() {this._readingDirection = "ltr"}
+  __init40() {this._readingDirection = "ltr"}
   /** Cached media-query list; `.matches` is read live each frame. */
-  __init36() {this.reducedMotionQuery = null}
+  __init41() {this.reducedMotionQuery = null}
   /** Cached `(forced-colors: active)` query (Windows High Contrast etc.). A
    *  canvas gets NO automatic forced-colors treatment from the browser (it's
    *  opaque pixels), so components must read {@link forcedColors} and repaint
    *  with system colors themselves; a change listener repaints idle scenes. */
-  __init37() {this.forcedColorsQuery = null}
-  __init38() {this.forcedColorsChangeHandler = null}
+  __init42() {this.forcedColorsQuery = null}
+  __init43() {this.forcedColorsChangeHandler = null}
   /** True when the OS asks for reduced motion and we respect it. Read by the animation drivers. */
   get prefersReducedMotion() {
     return this.respectReducedMotion && !!_optionalChain([this, 'access', _21 => _21.reducedMotionQuery, 'optionalAccess', _22 => _22.matches]);
@@ -1509,82 +1603,82 @@ var Scene = (_class6 = class _Scene {
    * Throttle interval (ms) for the a11y/automation shadow sync. `0` = every
    * frame. See {@link SceneOptions.a11ySyncInterval}.
    */
-  __init39() {this.a11ySyncInterval = 0}
+  __init44() {this.a11ySyncInterval = 0}
   /** Timestamp of the last a11y sync, for throttling. */
-  __init40() {this.lastA11ySync = -Infinity}
+  __init45() {this.lastA11ySync = -Infinity}
   /** True if we skipped an a11y sync during animation and need to sync when at rest. */
-  __init41() {this.a11yPendingSyncAfterAnimation = false}
+  __init46() {this.a11yPendingSyncAfterAnimation = false}
   // A11y / Automation Layer. `null` in non-DOM (SSR/Node) environments — the
   // whole projection degrades to a no-op so the engine's logic stays usable
   // server-side (e.g. headless layout / vector export) without jsdom.
   
-  __init42() {this.a11yElements = /* @__PURE__ */ new Map()}
+  __init47() {this.a11yElements = /* @__PURE__ */ new Map()}
   /** DOM nodes mirroring static text content, keyed by entity id. */
-  __init43() {this.contentElements = /* @__PURE__ */ new Map()}
+  __init48() {this.contentElements = /* @__PURE__ */ new Map()}
   /** Pending cold font-calibration frame per projected grid entity. */
-  __init44() {this.contentGridCalibrationFrames = /* @__PURE__ */ new Map()}
+  __init49() {this.contentGridCalibrationFrames = /* @__PURE__ */ new Map()}
   /** Detached, untransformed font probes used by the cold calibration pass. */
-  __init45() {this.contentGridCalibrationProbes = /* @__PURE__ */ new Map()}
+  __init50() {this.contentGridCalibrationProbes = /* @__PURE__ */ new Map()}
   /** Invalidates grid font calibration after browser font availability changes. */
-  __init46() {this.contentFontEpoch = 0}
+  __init51() {this.contentFontEpoch = 0}
   /** Cached Canvas-to-client scale for the current font/viewport epoch. */
-  __init47() {this.contentMetricScaleEpoch = -1}
-  __init48() {this.contentMetricScaleX = 1}
-  __init49() {this.contentProjectionEnabled = true}
+  __init52() {this.contentMetricScaleEpoch = -1}
+  __init53() {this.contentMetricScaleX = 1}
+  __init54() {this.contentProjectionEnabled = true}
   // Virtualization margin (px) for content projection; `undefined` → one
   // viewport height, resolved at sync time. `Infinity` = materialize everything.
-  __init50() {this.contentProjectionMargin = void 0}
+  __init55() {this.contentProjectionMargin = void 0}
   /**
    * True while a text-selection drag that started on a projection's blank
    * region (no text node under the press) is being driven manually — the
    * browser has no native anchor for it, so mousemove extends the Selection
    * from the position we resolved ourselves.
    */
-  __init51() {this.blankRegionSelectionDrag = false}
-  __init52() {this.contentSelectionAnchor = null}
-  __init53() {this.contentSelectionEndListener = null}
+  __init56() {this.blankRegionSelectionDrag = false}
+  __init57() {this.contentSelectionAnchor = null}
+  __init58() {this.contentSelectionEndListener = null}
   // Animation/interactive flags collected during the render walk (tree-walk
   // fusion): the loop reads last frame's answers instead of re-walking the
   // tree up to 4× per tick. Start true so the first tick stays conservative.
-  __init54() {this.frameHadAnimation = true}
-  __init55() {this.frameHadInteractive = true}
+  __init59() {this.frameHadAnimation = true}
+  __init60() {this.frameHadInteractive = true}
   
   /** Active `(resolution: Ndppx)` media query watching for a runtime DPR change
    *  (window moved between monitors, browser zoom) so the canvas backing store
    *  can be re-scaled — otherwise it stays rasterized at the old DPR and blurs.
    *  A resolution media query only fires when leaving its exact value, so the
    *  handler re-arms a fresh query for the new DPR each time. */
-  __init56() {this.dprMediaQuery = null}
+  __init61() {this.dprMediaQuery = null}
   /** For embedded (`disableWindowResize`) scenes: observes the canvas element so
    *  a CSS/layout-driven size change re-runs `resize()`. A window `resize`
    *  listener never fires for these (the window isn't what changed), so without
    *  this an embedded canvas stayed at its initial size forever. */
-  __init57() {this.canvasResizeObserver = null}
-  __init58() {this.dprChangeHandler = null}
-  __init59() {this.focusedA11yElement = null}
+  __init62() {this.canvasResizeObserver = null}
+  __init63() {this.dprChangeHandler = null}
+  __init64() {this.focusedA11yElement = null}
   /** Last geometry `syncOverlayGeometry` wrote, so an unchanged frame can skip the
    *  style writes entirely. Reset to `null` to force the next sync (a new overlay
    *  layer was created and has never been positioned). */
-  __init60() {this._overlayGeometry = null}
+  __init65() {this._overlayGeometry = null}
   /** Shadow elements the pointer is currently inside. Lets a removal that happens
    *  mid-hover synthesize the `pointerleave` the browser never sends for a
    *  detached element, so the entity doesn't keep its hover state. */
-  __init61() {this.hoveredA11yElements = /* @__PURE__ */ new WeakSet()}
+  __init66() {this.hoveredA11yElements = /* @__PURE__ */ new WeakSet()}
   /** Persistent tabindex=-1 element in a11yRoot. When the focused a11y mirror is
    *  pruned (virtualization/streaming/removal) while it holds focus, we move
    *  focus here instead of letting the browser drop it to <body> — keeping the
    *  screen-reader virtual cursor inside the scene's a11y region. */
-  __init62() {this.focusSentinel = null}
-  __init63() {this.caretBlinkTimer = null}
-  __init64() {this.a11yNeedsReorder = true}
-  __init65() {this.portalRoot = null}
-  __init66() {this.fullViewportElements = []}
-  __init67() {this.normalElements = []}
-  __init68() {this.activeIds = /* @__PURE__ */ new Set()}
-  __init69() {this.activePortalsThisFrame = /* @__PURE__ */ new Set()}
-  __init70() {this.activePortalsPrevFrame = /* @__PURE__ */ new Set()}
-  __init71() {this.portalEntities = /* @__PURE__ */ new Map()}
-  __init72() {this.renderOrderCounter = 0}
+  __init67() {this.focusSentinel = null}
+  __init68() {this.caretBlinkTimer = null}
+  __init69() {this.a11yNeedsReorder = true}
+  __init70() {this.portalRoot = null}
+  __init71() {this.fullViewportElements = []}
+  __init72() {this.normalElements = []}
+  __init73() {this.activeIds = /* @__PURE__ */ new Set()}
+  __init74() {this.activePortalsThisFrame = /* @__PURE__ */ new Set()}
+  __init75() {this.activePortalsPrevFrame = /* @__PURE__ */ new Set()}
+  __init76() {this.portalEntities = /* @__PURE__ */ new Map()}
+  __init77() {this.renderOrderCounter = 0}
   /**
    * Monotonic render-frame counter, bumped once per authoritative `render()`
    * pass. Entities stamp their per-frame world-matrix cache with this value and
@@ -1593,7 +1687,7 @@ var Scene = (_class6 = class _Scene {
    * back to the ancestor walk. Public for the same reason `Entity._getTrig`/
    * `_setWorldCache` are: it is a cross-class render-internal contract.
    */
-  __init73() {this.currentFrame = 0}
+  __init78() {this.currentFrame = 0}
   // ── WASM transform backend (invisible accelerator) ──────────────────────────
   // When `_transformBackend === 'wasm'`, the main render walk sources each
   // entity's world matrix from an SoA store composed by `_wasm` (see
@@ -1601,24 +1695,24 @@ var Scene = (_class6 = class _Scene {
   // fallback and the default: a null backend, a non-main renderer, or any entity
   // absent from the store all fall back to the JS composition, so WASM can only
   // ever change *how fast* a world matrix is produced, never *what* it is.
-  __init74() {this._wasm = null}
-  __init75() {this._transformBackend = "js"}
+  __init79() {this._wasm = null}
+  __init80() {this._transformBackend = "js"}
   // Resident store state (Stage 3). The store layout — slot assignment + sibling
   // runs — depends only on tree TOPOLOGY, so it is rebuilt only when the
   // structure changes (add/remove/reparent bump `_structureVersion`). Between
   // rebuilds the per-frame cost is: gather each entity's transform into the
   // resident wasm input view + run the kernel — no reallocation, no readback.
-  __init76() {this._treeStore = null}
-  __init77() {this._slotEntity = []}
+  __init81() {this._treeStore = null}
+  __init82() {this._slotEntity = []}
   // store slot -> entity (also validates slots)
-  __init78() {this._wasmInputs = null}
-  __init79() {this._wasmWorld = null}
-  __init80() {this._structureVersion = 0}
-  __init81() {this._storeStructureVersion = -1}
+  __init83() {this._wasmInputs = null}
+  __init84() {this._wasmWorld = null}
+  __init85() {this._structureVersion = 0}
+  __init86() {this._storeStructureVersion = -1}
   // Cached list of ComputeParticleEntity instances in the tree, keyed by the
   // structure version it was gathered at. Rebuilt only on a topology change.
-  __init82() {this._computeEntities = []}
-  __init83() {this._computeEntitiesVersion = -1}
+  __init87() {this._computeEntities = []}
+  __init88() {this._computeEntitiesVersion = -1}
   /** Invalidate the resident WASM store layout; the next wasm-mode frame rebuilds
    *  it. Called by `Entity.add`/`remove` (topology changes only). */
   markStructureChanged() {
@@ -1674,10 +1768,9 @@ var Scene = (_class6 = class _Scene {
    * Resolves `true` if WASM is now active, `false` if the JS path remains.
    */
   async enableWasmTransforms(source) {
-    const isBytes = source instanceof ArrayBuffer || ArrayBuffer.isView(source);
-    const backend = isBytes ? await instantiateAsync(source) : await instantiateStreaming(source);
-    if (!backend) return false;
-    this.setTransformBackend(backend);
+    const runtime = await this.ensureWasmRuntime(source);
+    if (!runtime) return false;
+    this.setTransformBackend(runtime.transform());
     return true;
   }
   // ── WASM hit-test backend (invisible accelerator, G3) ───────────────────────
@@ -1691,16 +1784,72 @@ var Scene = (_class6 = class _Scene {
   // ever change *how fast* a hit is found, never *which* entity is returned —
   // every grid candidate is re-confirmed against its own precise
   // isPointInside before being trusted (see hit-store.ts / hit-backend.ts).
-  __init84() {this._hitWasm = null}
+  /**
+   * The one WASM instance this Scene's accelerators share.
+   *
+   * Each `enableWasm*` used to instantiate the binary itself, so enabling all
+   * four compiled the same module four times and held four linear memories. The
+   * Rust crate already keeps transform/anim/hit/particle in separate statics, so
+   * one instance serves all of them without aliasing. The compiled module is
+   * cached globally; the instance is per-Scene, which is the isolation that
+   * actually matters.
+   */
+  __init89() {this._wasmRuntime = null}
+  /**
+   * Load (or reuse) this Scene's shared WASM runtime.
+   *
+   * Returns `null` on any failure — CSP `wasm-unsafe-eval`, a 404, corrupt bytes,
+   * unsupported SIMD — so every caller keeps its JS path. Failure is the default
+   * state here, not an error path.
+   */
+  async ensureWasmRuntime(source) {
+    if (this._wasmRuntime) return this._wasmRuntime;
+    const runtime = await loadCoreWasmRuntime(source);
+    if (!runtime) return null;
+    if (this._wasmRuntime) return this._wasmRuntime;
+    this._wasmRuntime = runtime;
+    return runtime;
+  }
+  /**
+   * Install a pre-built runtime, so several Scenes can share one compile while
+   * each keeps its own stores. Pass `null` to detach (backends already installed
+   * keep working; only subsequent `enableWasm*` calls re-load).
+   */
+  setWasmRuntime(runtime) {
+    this._wasmRuntime = runtime;
+  }
+  /** The shared WASM runtime, if one has been loaded. */
+  get wasmRuntime() {
+    return this._wasmRuntime;
+  }
+  __init90() {this._hitWasm = null}
   // Cache key: which frame + structure version the grid was last (successfully,
   // non-overflowing) built for. findEntityAt is called ad-hoc (pointer
   // hover/click), not every frame, so the grid is refreshed lazily on demand
   // rather than proactively every render() — unlike the transform store, which
   // every frame's draw depends on.
-  __init85() {this._hitGridFrame = -1}
-  __init86() {this._hitGridOk = false}
-  __init87() {this._hitSlotEntity = []}
-  __init88() {this._hitBoundless = []}
+  __init91() {this._hitGridFrame = -1}
+  __init92() {this._hitGridOk = false}
+  __init93() {this._hitSlotEntity = []}
+  __init94() {this._hitBoundless = []}
+  /** Reused buffer for the fused gather, so a pointer query allocates nothing. */
+  __init95() {this._hitGatherBuffer = null}
+  /**
+   * Whether the last grid build sourced its AABBs from the WASM transform store
+   * rather than recomputing them in JS. Diagnostic only — both paths must
+   * produce the same entity for a given point.
+   */
+  __init96() {this._hitFusedGather = false}
+  /**
+   * Whether `compute_aabbs` has run against the current frame's world matrices.
+   * The AABB pass is only meaningful after a `compose_*`, so the fused gather
+   * must not read the views before then.
+   */
+  __init97() {this._wasmAabbsFresh = false}
+  /** Did the last hit-grid build use the fused (WASM-store) gather? */
+  get hitGatherPath() {
+    return this._hitFusedGather ? "fused" : "js";
+  }
   /** Which backend answers `findEntityAt` for the main tree. */
   get hitTestBackend() {
     return this._hitWasm ? "wasm" : "js";
@@ -1719,10 +1868,9 @@ var Scene = (_class6 = class _Scene {
    * state, not an error path. Resolves `true` if WASM is now active.
    */
   async enableWasmHitTest(source) {
-    const isBytes = source instanceof ArrayBuffer || ArrayBuffer.isView(source);
-    const backend = isBytes ? await instantiateAsync2(source) : await instantiateStreaming2(source);
-    if (!backend) return false;
-    this.setHitTestBackend(backend);
+    const runtime = await this.ensureWasmRuntime(source);
+    if (!runtime) return false;
+    this.setHitTestBackend(runtime.hit());
     return true;
   }
   /**
@@ -1739,7 +1887,22 @@ var Scene = (_class6 = class _Scene {
     const backend = this._hitWasm;
     if (!backend) return false;
     if (this._hitGridFrame === this.currentFrame) return this._hitGridOk;
-    const gathered = gatherHitAABBs(this.root, this.currentFrame);
+    let gathered = null;
+    if (this._wasm && this._ensureWasmAabbs()) {
+      this._hitGatherBuffer ??= createHitGatherBuffer();
+      this._wasm.revalidateViews();
+      gathered = gatherHitAABBsFromStore(
+        this.root,
+        this._wasm.aabbView(),
+        this._slotEntity,
+        this._hitGatherBuffer
+      );
+      if (gathered) this._hitFusedGather = true;
+    }
+    if (!gathered) {
+      this._hitFusedGather = false;
+      gathered = gatherHitAABBs(this.root, this.currentFrame);
+    }
     backend.ensure(gathered.count, this.width, this.height, 64);
     const view = backend.inputView();
     view.minx.set(gathered.minx.subarray(0, gathered.count));
@@ -1796,25 +1959,25 @@ var Scene = (_class6 = class _Scene {
   // EasingFn (which cannot cross into WASM) all fall through to it — WASM can
   // only ever change *how* a driver is advanced, never *what* value it lands
   // on.
-  __init89() {this._animWasm = null}
+  __init98() {this._animWasm = null}
   // Entities with at least one active driver, added by Entity._spawnDriver.
   // Self-pruning: _tickBatchedDrivers drops an entry the first time it visits
   // an entity whose drivers have since all completed or been removed. This is
   // what lets the batch pass find its candidates in O(active drivers), not
   // O(tree size) — the exact mistake G3's first integrated benchmark made.
-  __init90() {this._activeDriverEntities = /* @__PURE__ */ new Set()}
+  __init99() {this._activeDriverEntities = /* @__PURE__ */ new Set()}
   // Reused across frames instead of allocating a fresh array + N {entity,prop,
   // driver} objects every call — the integrated benchmark
   // (benchmarks/anim-wasm-scene) found that allocation churn was the
   // dominant integrated cost, not the wasm kernel itself. Parallel arrays,
   // truncated to the live count after each use so a stale tail slot never
   // pins a no-longer-active entity/driver in memory.
-  __init91() {this._springEntities = []}
-  __init92() {this._springProps = []}
-  __init93() {this._springDrivers = []}
-  __init94() {this._tweenEntities = []}
-  __init95() {this._tweenProps = []}
-  __init96() {this._tweenDrivers = []}
+  __init100() {this._springEntities = []}
+  __init101() {this._springProps = []}
+  __init102() {this._springDrivers = []}
+  __init103() {this._tweenEntities = []}
+  __init104() {this._tweenProps = []}
+  __init105() {this._tweenDrivers = []}
   /**
    * Minimum number of batchable (spring, or named-easing tween) active drivers
    * before a frame engages the WASM batch path at all; below it, every driver
@@ -1852,7 +2015,57 @@ var Scene = (_class6 = class _Scene {
    * own target browser mix and driver-kind distribution, or leave WASM
    * animation batching disabled entirely on a Firefox-heavy audience.
    */
-  __init97() {this.animDriverGateCount = 256}
+  /**
+   * Back-compat alias for {@link animGate}. Reading it returns the tween gate
+   * (the conservative one the single knob used to represent); writing it sets all
+   * three, so code that tuned one number keeps behaving as before.
+   *
+   * Prefer {@link animGate} — a single threshold cannot be right for both kinds,
+   * which is why this exists as an alias rather than the primary control.
+   */
+  get animDriverGateCount() {
+    return this.animGate.tween;
+  }
+  set animDriverGateCount(n) {
+    this.animGate = { spring: n, tween: n, mixed: n };
+  }
+  /**
+   * Per-kind driver gates, in active batchable drivers.
+   *
+   * Measured on the integrated path (`benchmarks/anim-wasm-scene`, real Chrome
+   * 150 / Firefox 153): spring and mixed workloads are a ~1.4-2.3x win from 128
+   * drivers up through 16384, while pure tween is a **0.71x loss** at 128 and
+   * only turns net-positive near 256. One scalar threshold therefore had to be
+   * set for the worst kind, discarding the 128-255 spring win to avoid making a
+   * tween-heavy scene slower.
+   *
+   * Firefox is a net loss at every count measured up to 16384 — not an
+   * allocation artifact (confirmed after removing all per-frame allocation from
+   * gather/scatter); SpiderMonkey's wasm-boundary cost for this call shape
+   * appears to structurally exceed the saving at these scales. These defaults are
+   * Chrome-oriented; on a Firefox-heavy audience, leave
+   * {@link enableWasmAnimBatching} off entirely rather than tuning these.
+   *
+   * Setting {@link animDriverGateCount} overwrites all three, so existing code
+   * that tuned the single knob keeps working unchanged.
+   */
+  __init106() {this._animBatchedLastFrame = false}
+  /**
+   * Whether the WASM batch path actually ran on the most recent frame.
+   *
+   * Distinct from {@link animBackend}, which reports only that a backend is
+   * installed — a gate below the driver count means the frame still ticked in JS.
+   * Conflating the two makes it easy to believe an accelerator is active when it
+   * never opens.
+   */
+  get animBatchedLastFrame() {
+    return this._animBatchedLastFrame;
+  }
+  __init107() {this.animGate = {
+    spring: 128,
+    tween: 256,
+    mixed: 128
+  }}
   /** Which backend advances active property drivers on the current gate
    *  decision. Reflects only whether a backend is installed — the per-frame
    *  gate can still choose the JS path even when this reads `'wasm'`. */
@@ -1873,10 +2086,9 @@ var Scene = (_class6 = class _Scene {
    * if WASM is now available (not necessarily active every frame).
    */
   async enableWasmAnimBatching(source) {
-    const isBytes = source instanceof ArrayBuffer || ArrayBuffer.isView(source);
-    const backend = isBytes ? await instantiateAsync3(source) : await instantiateStreaming3(source);
-    if (!backend) return false;
-    this.setAnimBackend(backend);
+    const runtime = await this.ensureWasmRuntime(source);
+    if (!runtime) return false;
+    this.setAnimBackend(runtime.anim());
     return true;
   }
   // ── WASM particle CPU-sim backend (invisible accelerator, G4) ───────────────
@@ -1887,7 +2099,7 @@ var Scene = (_class6 = class _Scene {
   // (benchmarks/particle-wasm). f32 (matches the WGSL shader), bit-identical to
   // a JS f32 reference oracle; updateCPU (f64) stays the permanent fallback when
   // no backend is installed or a scene runs on WebGPU.
-  __init98() {this._particleWasm = null}
+  __init108() {this._particleWasm = null}
   /** Which backend runs the CPU particle simulation. Reflects only whether a
    *  backend is installed (the WebGPU compute path, when active, is used first
    *  regardless). */
@@ -1907,10 +2119,9 @@ var Scene = (_class6 = class _Scene {
    * Resolves `true` if WASM is now active.
    */
   async enableWasmParticles(source) {
-    const isBytes = source instanceof ArrayBuffer || ArrayBuffer.isView(source);
-    const backend = isBytes ? await instantiateAsync4(source) : await instantiateStreaming4(source);
-    if (!backend) return false;
-    this.setParticleBackend(backend);
+    const runtime = await this.ensureWasmRuntime(source);
+    if (!runtime) return false;
+    this.setParticleBackend(runtime.particle());
     return true;
   }
   /** Internal: called by `Entity._spawnDriver` when a new property driver
@@ -1969,7 +2180,8 @@ var Scene = (_class6 = class _Scene {
    */
   _tickBatchedDrivers(dt) {
     if (this._activeDriverEntities.size === 0) return;
-    let batchable = 0;
+    let springBatchable = 0;
+    let tweenBatchable = 0;
     for (const entity of this._activeDriverEntities) {
       const entries = entity._driverEntries();
       if (!entries || entries.size === 0) {
@@ -1977,12 +2189,17 @@ var Scene = (_class6 = class _Scene {
         continue;
       }
       for (const driver of entries.values()) {
-        if (driver instanceof _animation.SpringDriver) batchable++;
-        else if (driver instanceof _animation.TweenDriver && driver.wasmEasingId !== null) batchable++;
+        if (driver instanceof _animation.SpringDriver) springBatchable++;
+        else if (driver instanceof _animation.TweenDriver && driver.wasmEasingId !== null) tweenBatchable++;
       }
     }
+    const batchable = springBatchable + tweenBatchable;
     const backend = this._animWasm;
-    if (!backend || batchable < this.animDriverGateCount) return;
+    this._animBatchedLastFrame = false;
+    if (!backend) return;
+    const gate = springBatchable > 0 && tweenBatchable > 0 ? this.animGate.mixed : tweenBatchable > 0 ? this.animGate.tween : this.animGate.spring;
+    if (batchable < gate) return;
+    this._animBatchedLastFrame = true;
     const sE = this._springEntities;
     const sP = this._springProps;
     const sD = this._springDrivers;
@@ -2073,6 +2290,11 @@ var Scene = (_class6 = class _Scene {
       this._wasmWorld = backend.worldView();
       this._storeStructureVersion = this._structureVersion;
     }
+    backend.revalidateViews();
+    if (this._wasmInputs && this._wasmInputs.x.length === 0) {
+      this._wasmInputs = backend.inputView();
+      this._wasmWorld = backend.worldView();
+    }
     const inp = this._wasmInputs;
     const slotEntity = this._slotEntity;
     for (let slot = 1; slot < slotEntity.length; slot++) {
@@ -2087,54 +2309,86 @@ var Scene = (_class6 = class _Scene {
       inp.opacity[slot] = e.opacity;
     }
     backend.runKernel("simd");
+    this._wasmAabbsFresh = false;
     return this._wasmWorld;
   }
+  /**
+   * Run the WASM world-AABB pass over the current frame's world matrices, so the
+   * fused hit gather can read AABBs straight out of the store.
+   *
+   * Local bounds are uploaded here rather than in the per-frame transform sync
+   * because `getBounds()` is a virtual call that allocates a rect on most
+   * entities — paying it every frame for a query that may never come would move
+   * cost onto the render path to save it on hover. Returns `false` if any entity
+   * cannot supply bounds through the store, so the caller uses the JS gather.
+   */
+  _ensureWasmAabbs() {
+    const backend = this._wasm;
+    const store = this._treeStore;
+    if (!backend || !store) return false;
+    if (this._wasmAabbsFresh) return true;
+    backend.revalidateViews();
+    const bounds = backend.boundsView();
+    const slotEntity = this._slotEntity;
+    for (let slot = 0; slot < slotEntity.length; slot++) {
+      const e = slotEntity[slot];
+      if (!e) continue;
+      const b = e.getBounds();
+      bounds.bx[slot] = b ? b.x : 0;
+      bounds.by[slot] = b ? b.y : 0;
+      bounds.bw[slot] = b ? b.width : 0;
+      bounds.bh[slot] = b ? b.height : 0;
+    }
+    backend.runAabbs(slotEntity.length);
+    this._wasmAabbsFresh = true;
+    return true;
+  }
   /**
    * Authoritative paint order for semantic nodes discovered during the main
    * render. A node may not have a DOM projection until the following a11y
    * sync, so retaining the order prevents a newly opened overlay from spending
    * its first frame below previously projected controls.
    */
-  __init99() {this.a11yRenderOrders = /* @__PURE__ */ new Map()}
+  __init109() {this.a11yRenderOrders = /* @__PURE__ */ new Map()}
   // Optional WebGL point-cloud layer (see SceneOptions.pointBackend).
-  __init100() {this.pointRenderer = null}
-  __init101() {this.glCanvas = null}
-  __init102() {this.glContextLostHandler = null}
-  __init103() {this.glContextRestoredHandler = null}
+  __init110() {this.pointRenderer = null}
+  __init111() {this.glCanvas = null}
+  __init112() {this.glContextLostHandler = null}
+  __init113() {this.glContextRestoredHandler = null}
   
   
   
-  __init104() {this.disableWindowResize = false}
+  __init114() {this.disableWindowResize = false}
   /** See {@link SceneOptions.maxDPR}. `undefined` = uncapped (real DPR). */
   
   // WebGPU properties
-  __init105() {this.destroyed = false}
-  __init106() {this.device = null}
-  __init107() {this.deviceLost = false}
-  __init108() {this.particleBackend = "auto"}
-  __init109() {this._webgpuDisabled = false}
+  __init115() {this.destroyed = false}
+  __init116() {this.device = null}
+  __init117() {this.deviceLost = false}
+  __init118() {this.particleBackend = "auto"}
+  __init119() {this._webgpuDisabled = false}
   get webgpuDisabled() {
     return this._webgpuDisabled || this.particleBackend === "cpu";
   }
   set webgpuDisabled(value) {
     this._webgpuDisabled = value;
   }
-  __init110() {this.recoveryTimerId = null}
-  __init111() {this.manager = null}
-  __init112() {this.initializingWebGPU = false}
-  __init113() {this.gpuCanvas = null}
-  __init114() {this.gpuContext = null}
+  __init120() {this.recoveryTimerId = null}
+  __init121() {this.manager = null}
+  __init122() {this.initializingWebGPU = false}
+  __init123() {this.gpuCanvas = null}
+  __init124() {this.gpuContext = null}
   /** True while the GPU canvas holds a presented particle frame (needs clearing when they leave). */
-  __init115() {this.gpuHasContent = false}
-  __init116() {this.mouseX = -9999}
-  __init117() {this.mouseY = -9999}
-  __init118() {this.pointerMoveListener = null}
-  __init119() {this.pointerLeaveListener = null}
+  __init125() {this.gpuHasContent = false}
+  __init126() {this.mouseX = -9999}
+  __init127() {this.mouseY = -9999}
+  __init128() {this.pointerMoveListener = null}
+  __init129() {this.pointerLeaveListener = null}
   /** Element the pointer listeners are bound to (parent container if present,
    *  else the canvas). Stored so `destroy()` detaches from the same element. */
-  __init120() {this.pointerEventTarget = null}
-  __init121() {this.hasWarnedZeroSize = false}
-  __init122() {this.fontLoadHandler = null}
+  __init130() {this.pointerEventTarget = null}
+  __init131() {this.hasWarnedZeroSize = false}
+  __init132() {this.fontLoadHandler = null}
   // ── Dev-mode warning infrastructure ──────────────────────────────
   //
   // Enable with `Scene.devMode = true` or by setting `globalThis.__DEV__`.
@@ -2152,7 +2406,7 @@ var Scene = (_class6 = class _Scene {
     return false;
   }
   
-  __init123() {this._devFrameCount = 0}
+  __init133() {this._devFrameCount = 0}
   _devWarn(message) {
     if (!this._devActive) return;
     console.warn(`[vectojs/dev] ${message}`);
@@ -2196,7 +2450,7 @@ var Scene = (_class6 = class _Scene {
     };
     walkProjections(this.root);
   }
-  constructor(canvas, options = {}) {;_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);_class6.prototype.__init27.call(this);_class6.prototype.__init28.call(this);_class6.prototype.__init29.call(this);_class6.prototype.__init30.call(this);_class6.prototype.__init31.call(this);_class6.prototype.__init32.call(this);_class6.prototype.__init33.call(this);_class6.prototype.__init34.call(this);_class6.prototype.__init35.call(this);_class6.prototype.__init36.call(this);_class6.prototype.__init37.call(this);_class6.prototype.__init38.call(this);_class6.prototype.__init39.call(this);_class6.prototype.__init40.call(this);_class6.prototype.__init41.call(this);_class6.prototype.__init42.call(this);_class6.prototype.__init43.call(this);_class6.prototype.__init44.call(this);_class6.prototype.__init45.call(this);_class6.prototype.__init46.call(this);_class6.prototype.__init47.call(this);_class6.prototype.__init48.call(this);_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);_class6.prototype.__init53.call(this);_class6.prototype.__init54.call(this);_class6.prototype.__init55.call(this);_class6.prototype.__init56.call(this);_class6.prototype.__init57.call(this);_class6.prototype.__init58.call(this);_class6.prototype.__init59.call(this);_class6.prototype.__init60.call(this);_class6.prototype.__init61.call(this);_class6.prototype.__init62.call(this);_class6.prototype.__init63.call(this);_class6.prototype.__init64.call(this);_class6.prototype.__init65.call(this);_class6.prototype.__init66.call(this);_class6.prototype.__init67.call(this);_class6.prototype.__init68.call(this);_class6.prototype.__init69.call(this);_class6.prototype.__init70.call(this);_class6.prototype.__init71.call(this);_class6.prototype.__init72.call(this);_class6.prototype.__init73.call(this);_class6.prototype.__init74.call(this);_class6.prototype.__init75.call(this);_class6.prototype.__init76.call(this);_class6.prototype.__init77.call(this);_class6.prototype.__init78.call(this);_class6.prototype.__init79.call(this);_class6.prototype.__init80.call(this);_class6.prototype.__init81.call(this);_class6.prototype.__init82.call(this);_class6.prototype.__init83.call(this);_class6.prototype.__init84.call(this);_class6.prototype.__init85.call(this);_class6.prototype.__init86.call(this);_class6.prototype.__init87.call(this);_class6.prototype.__init88.call(this);_class6.prototype.__init89.call(this);_class6.prototype.__init90.call(this);_class6.prototype.__init91.call(this);_class6.prototype.__init92.call(this);_class6.prototype.__init93.call(this);_class6.prototype.__init94.call(this);_class6.prototype.__init95.call(this);_class6.prototype.__init96.call(this);_class6.prototype.__init97.call(this);_class6.prototype.__init98.call(this);_class6.prototype.__init99.call(this);_class6.prototype.__init100.call(this);_class6.prototype.__init101.call(this);_class6.prototype.__init102.call(this);_class6.prototype.__init103.call(this);_class6.prototype.__init104.call(this);_class6.prototype.__init105.call(this);_class6.prototype.__init106.call(this);_class6.prototype.__init107.call(this);_class6.prototype.__init108.call(this);_class6.prototype.__init109.call(this);_class6.prototype.__init110.call(this);_class6.prototype.__init111.call(this);_class6.prototype.__init112.call(this);_class6.prototype.__init113.call(this);_class6.prototype.__init114.call(this);_class6.prototype.__init115.call(this);_class6.prototype.__init116.call(this);_class6.prototype.__init117.call(this);_class6.prototype.__init118.call(this);_class6.prototype.__init119.call(this);_class6.prototype.__init120.call(this);_class6.prototype.__init121.call(this);_class6.prototype.__init122.call(this);_class6.prototype.__init123.call(this);
+  constructor(canvas, options = {}) {;_class7.prototype.__init25.call(this);_class7.prototype.__init26.call(this);_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);_class7.prototype.__init29.call(this);_class7.prototype.__init30.call(this);_class7.prototype.__init31.call(this);_class7.prototype.__init32.call(this);_class7.prototype.__init33.call(this);_class7.prototype.__init34.call(this);_class7.prototype.__init35.call(this);_class7.prototype.__init36.call(this);_class7.prototype.__init37.call(this);_class7.prototype.__init38.call(this);_class7.prototype.__init39.call(this);_class7.prototype.__init40.call(this);_class7.prototype.__init41.call(this);_class7.prototype.__init42.call(this);_class7.prototype.__init43.call(this);_class7.prototype.__init44.call(this);_class7.prototype.__init45.call(this);_class7.prototype.__init46.call(this);_class7.prototype.__init47.call(this);_class7.prototype.__init48.call(this);_class7.prototype.__init49.call(this);_class7.prototype.__init50.call(this);_class7.prototype.__init51.call(this);_class7.prototype.__init52.call(this);_class7.prototype.__init53.call(this);_class7.prototype.__init54.call(this);_class7.prototype.__init55.call(this);_class7.prototype.__init56.call(this);_class7.prototype.__init57.call(this);_class7.prototype.__init58.call(this);_class7.prototype.__init59.call(this);_class7.prototype.__init60.call(this);_class7.prototype.__init61.call(this);_class7.prototype.__init62.call(this);_class7.prototype.__init63.call(this);_class7.prototype.__init64.call(this);_class7.prototype.__init65.call(this);_class7.prototype.__init66.call(this);_class7.prototype.__init67.call(this);_class7.prototype.__init68.call(this);_class7.prototype.__init69.call(this);_class7.prototype.__init70.call(this);_class7.prototype.__init71.call(this);_class7.prototype.__init72.call(this);_class7.prototype.__init73.call(this);_class7.prototype.__init74.call(this);_class7.prototype.__init75.call(this);_class7.prototype.__init76.call(this);_class7.prototype.__init77.call(this);_class7.prototype.__init78.call(this);_class7.prototype.__init79.call(this);_class7.prototype.__init80.call(this);_class7.prototype.__init81.call(this);_class7.prototype.__init82.call(this);_class7.prototype.__init83.call(this);_class7.prototype.__init84.call(this);_class7.prototype.__init85.call(this);_class7.prototype.__init86.call(this);_class7.prototype.__init87.call(this);_class7.prototype.__init88.call(this);_class7.prototype.__init89.call(this);_class7.prototype.__init90.call(this);_class7.prototype.__init91.call(this);_class7.prototype.__init92.call(this);_class7.prototype.__init93.call(this);_class7.prototype.__init94.call(this);_class7.prototype.__init95.call(this);_class7.prototype.__init96.call(this);_class7.prototype.__init97.call(this);_class7.prototype.__init98.call(this);_class7.prototype.__init99.call(this);_class7.prototype.__init100.call(this);_class7.prototype.__init101.call(this);_class7.prototype.__init102.call(this);_class7.prototype.__init103.call(this);_class7.prototype.__init104.call(this);_class7.prototype.__init105.call(this);_class7.prototype.__init106.call(this);_class7.prototype.__init107.call(this);_class7.prototype.__init108.call(this);_class7.prototype.__init109.call(this);_class7.prototype.__init110.call(this);_class7.prototype.__init111.call(this);_class7.prototype.__init112.call(this);_class7.prototype.__init113.call(this);_class7.prototype.__init114.call(this);_class7.prototype.__init115.call(this);_class7.prototype.__init116.call(this);_class7.prototype.__init117.call(this);_class7.prototype.__init118.call(this);_class7.prototype.__init119.call(this);_class7.prototype.__init120.call(this);_class7.prototype.__init121.call(this);_class7.prototype.__init122.call(this);_class7.prototype.__init123.call(this);_class7.prototype.__init124.call(this);_class7.prototype.__init125.call(this);_class7.prototype.__init126.call(this);_class7.prototype.__init127.call(this);_class7.prototype.__init128.call(this);_class7.prototype.__init129.call(this);_class7.prototype.__init130.call(this);_class7.prototype.__init131.call(this);_class7.prototype.__init132.call(this);_class7.prototype.__init133.call(this);
     this.canvas = canvas;
     this.debugA11y = _nullishCoalesce(options.debugA11y, () => ( false));
     this.disableWindowResize = _nullishCoalesce(options.disableWindowResize, () => ( false));
@@ -2524,7 +2778,7 @@ var Scene = (_class6 = class _Scene {
     if (!anchor || !focus) return;
     try {
       selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
-    } catch (e17) {
+    } catch (e9) {
     }
   }
   /**
@@ -3223,11 +3477,17 @@ var Scene = (_class6 = class _Scene {
       this.syncOptionalAttribute(el, "aria-modal", attrs.ariaModal);
       this.syncOptionalAttribute(el, "aria-labelledby", attrs.labelledby);
       this.syncOptionalAttribute(el, "aria-describedby", attrs.describedby);
-      this.syncOptionalAttribute(
-        el,
-        "aria-required",
-        attrs.required === void 0 ? void 0 : String(attrs.required)
-      );
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+        const wantRequired = attrs.required === true;
+        if (el.required !== wantRequired) el.required = wantRequired;
+        this.syncOptionalAttribute(el, "aria-required", void 0);
+      } else {
+        this.syncOptionalAttribute(
+          el,
+          "aria-required",
+          attrs.required === void 0 ? void 0 : String(attrs.required)
+        );
+      }
       this.syncOptionalAttribute(
         el,
         "aria-invalid",
@@ -4460,7 +4720,7 @@ var Scene = (_class6 = class _Scene {
       });
       pass.end();
       this.device.queue.submit([encoder.finish()]);
-    } catch (e18) {
+    } catch (e10) {
     }
     this.gpuHasContent = false;
   }
@@ -4628,7 +4888,7 @@ var Scene = (_class6 = class _Scene {
     }
     return true;
   }
-}, _class6.__initStatic(), _class6.__initStatic2(), _class6.__initStatic3(), _class6.__initStatic4(), _class6);
+}, _class7.__initStatic(), _class7.__initStatic2(), _class7.__initStatic3(), _class7.__initStatic4(), _class7);
 function intersectBounds(a, b) {
   const x = Math.max(a.x, b.x);
   const y = Math.max(a.y, b.y);
@@ -4655,20 +4915,20 @@ function defaultMeasurer() {
   if (sharedMeasurer === void 0) sharedMeasurer = _layout.createCanvasMeasurer.call(void 0, "sans-serif");
   return sharedMeasurer;
 }
-var TextEntity = (_class7 = class extends _chunkDUYB4GX4js.Entity {
+var TextEntity = (_class8 = class extends _chunkDUYB4GX4js.Entity {
   
   
   
   
-  __init124() {this.nodes = []}
+  __init134() {this.nodes = []}
   
-  __init125() {this.fillStyle = "#94a3b8"}
-  __init126() {this.strokeStyle = null}
-  __init127() {this.hoveredFillStyle = "#ffffff"}
-  __init128() {this.lineWidth = 1}
-  __init129() {this.isHovered = false}
+  __init135() {this.fillStyle = "#94a3b8"}
+  __init136() {this.strokeStyle = null}
+  __init137() {this.hoveredFillStyle = "#ffffff"}
+  __init138() {this.lineWidth = 1}
+  __init139() {this.isHovered = false}
   constructor(text, atlas, maxWidth, fontSize = 24) {
-    super();_class7.prototype.__init124.call(this);_class7.prototype.__init125.call(this);_class7.prototype.__init126.call(this);_class7.prototype.__init127.call(this);_class7.prototype.__init128.call(this);_class7.prototype.__init129.call(this);;
+    super();_class8.prototype.__init134.call(this);_class8.prototype.__init135.call(this);_class8.prototype.__init136.call(this);_class8.prototype.__init137.call(this);_class8.prototype.__init138.call(this);_class8.prototype.__init139.call(this);;
     this.text = text;
     this.atlas = atlas;
     this.fontSize = fontSize;
@@ -4778,20 +5038,20 @@ var TextEntity = (_class7 = class extends _chunkDUYB4GX4js.Entity {
       renderer.restore();
     }
   }
-}, _class7);
+}, _class8);
 
 // src/components/GridTextEntity.ts
-var GridTextEntity = (_class8 = class extends _chunkDUYB4GX4js.Entity {
+var GridTextEntity = (_class9 = class extends _chunkDUYB4GX4js.Entity {
   
-  __init130() {this.fillStyle = "#ffffff"}
-  __init131() {this.grid = []}
+  __init140() {this.fillStyle = "#ffffff"}
+  __init141() {this.grid = []}
   // Array of rows
-  __init132() {this.cols = 0}
-  __init133() {this.rows = 0}
+  __init142() {this.cols = 0}
+  __init143() {this.rows = 0}
   
   
   constructor(_atlas, fontSize = 10) {
-    super();_class8.prototype.__init130.call(this);_class8.prototype.__init131.call(this);_class8.prototype.__init132.call(this);_class8.prototype.__init133.call(this);;
+    super();_class9.prototype.__init140.call(this);_class9.prototype.__init141.call(this);_class9.prototype.__init142.call(this);_class9.prototype.__init143.call(this);;
     this.fontSize = fontSize;
     this.charWidth = fontSize * 1;
     this.charHeight = fontSize * 1.1;
@@ -4822,7 +5082,7 @@ var GridTextEntity = (_class8 = class extends _chunkDUYB4GX4js.Entity {
       }
     }
   }
-}, _class8);
+}, _class9);
 
 // src/components/SplineEntity.ts
 function polySegmentToBezier(seg) {
@@ -4875,7 +5135,7 @@ function distSqToSegment(px, py, x1, y1, x2, y2) {
   const ey = py - cy;
   return ex * ex + ey * ey;
 }
-var SplineEntity = (_class9 = class extends _chunkDUYB4GX4js.Entity {
+var SplineEntity = (_class10 = class extends _chunkDUYB4GX4js.Entity {
   
   
   
@@ -4883,23 +5143,23 @@ var SplineEntity = (_class9 = class extends _chunkDUYB4GX4js.Entity {
   
   
   
-  __init134() {this.offscreen = null}
-  __init135() {this.baked = false}
+  __init144() {this.offscreen = null}
+  __init145() {this.baked = false}
   /** Logical (CSS-pixel) size of the baked bitmap — the blit destination size. */
-  __init136() {this.bakedWidth = 0}
-  __init137() {this.bakedHeight = 0}
+  __init146() {this.bakedWidth = 0}
+  __init147() {this.bakedHeight = 0}
   /** Gradient strokes can't be baked to a solid-color bitmap; they render per-frame. */
   
   /** Lazily-flattened polylines (one Float32Array of [x,y,...] per segment) for hit-testing. */
-  __init138() {this.polylines = null}
+  __init148() {this.polylines = null}
   /**
    * When `true`, the renderer draws a rounded-rect outline of the entity's
    * local bounds after painting the curves. Useful for drag feedback and
    * debugging hit areas. Defaults to `false`.
    */
-  __init139() {this.showBounds = false}
+  __init149() {this.showBounds = false}
   constructor(doc, opts = {}) {
-    super();_class9.prototype.__init134.call(this);_class9.prototype.__init135.call(this);_class9.prototype.__init136.call(this);_class9.prototype.__init137.call(this);_class9.prototype.__init138.call(this);_class9.prototype.__init139.call(this);;
+    super();_class10.prototype.__init144.call(this);_class10.prototype.__init145.call(this);_class10.prototype.__init146.call(this);_class10.prototype.__init147.call(this);_class10.prototype.__init148.call(this);_class10.prototype.__init149.call(this);;
     this.doc = doc;
     this.lineWidth = _nullishCoalesce(opts.lineWidth, () => ( 2));
     this.cache = _nullishCoalesce(opts.cache, () => ( true));
@@ -5143,7 +5403,7 @@ var SplineEntity = (_class9 = class extends _chunkDUYB4GX4js.Entity {
       r.stroke("rgba(0, 150, 255, 0.8)", 2);
     }
   }
-}, _class9);
+}, _class10);
 async function loadSpline(url) {
   const res = await fetch(url);
   return await res.json();
@@ -5278,21 +5538,21 @@ var _math = require('@vectojs/math'); _createStarExport(_math);
 
 
 // src/tree/DOMPortalEntity.ts
-var DOMPortalEntity = (_class10 = class extends _chunkDUYB4GX4js.Entity {
+var DOMPortalEntity = (_class11 = class extends _chunkDUYB4GX4js.Entity {
   
-  __init140() {this.isDOMPortal = true}
-  __init141() {this.domListeners = []}
-  __init142() {this.resizeObserver = null}
-  __init143() {this.domBound = false}
-  __init144() {this.cachedWidth = 100}
-  __init145() {this.cachedHeight = 100}
-  __init146() {this.lastWidth = ""}
-  __init147() {this.lastHeight = ""}
-  __init148() {this.lastTransform = ""}
-  __init149() {this.lastZIndex = ""}
-  __init150() {this.lastOpacity = ""}
+  __init150() {this.isDOMPortal = true}
+  __init151() {this.domListeners = []}
+  __init152() {this.resizeObserver = null}
+  __init153() {this.domBound = false}
+  __init154() {this.cachedWidth = 100}
+  __init155() {this.cachedHeight = 100}
+  __init156() {this.lastWidth = ""}
+  __init157() {this.lastHeight = ""}
+  __init158() {this.lastTransform = ""}
+  __init159() {this.lastZIndex = ""}
+  __init160() {this.lastOpacity = ""}
   constructor(domElement, width, height, id) {
-    super(id);_class10.prototype.__init140.call(this);_class10.prototype.__init141.call(this);_class10.prototype.__init142.call(this);_class10.prototype.__init143.call(this);_class10.prototype.__init144.call(this);_class10.prototype.__init145.call(this);_class10.prototype.__init146.call(this);_class10.prototype.__init147.call(this);_class10.prototype.__init148.call(this);_class10.prototype.__init149.call(this);_class10.prototype.__init150.call(this);;
+    super(id);_class11.prototype.__init150.call(this);_class11.prototype.__init151.call(this);_class11.prototype.__init152.call(this);_class11.prototype.__init153.call(this);_class11.prototype.__init154.call(this);_class11.prototype.__init155.call(this);_class11.prototype.__init156.call(this);_class11.prototype.__init157.call(this);_class11.prototype.__init158.call(this);_class11.prototype.__init159.call(this);_class11.prototype.__init160.call(this);;
     this.domElement = domElement;
     this.width = _nullishCoalesce(width, () => ( 0));
     this.height = _nullishCoalesce(height, () => ( 0));
@@ -5401,7 +5661,7 @@ var DOMPortalEntity = (_class10 = class extends _chunkDUYB4GX4js.Entity {
     }
     super.destroy();
   }
-}, _class10);
+}, _class11);
 
 // src/index.ts
 Scene.registerWebGLPointRendererCreator(_chunkL4SWVP2Hjs.createWebGLPointRenderer);