@vectojs/core 1.22.0 → 1.24.0

package/dist/index.js

@@ -9,7 +9,7 @@
 
 
 
-var _chunkLHONR3GOjs = require('./chunk-LHONR3GO.js');
+var _chunkKEBYJVD6js = require('./chunk-KEBYJVD6.js');
 
 
 
@@ -308,12 +308,16 @@ var ComputeParticleEntity = (_class = class extends _chunkAGP4VLF4js.Entity {
    * The backend holds one resident SoA store, so a Scene with multiple particle
    * entities reuses it sequentially — origin is therefore re-gathered each call
    * (not upload-once), a couple of extra f32 reads per particle.
+   *
+   * Returns `false` if the kernel declined the call and {@link updateCPU} ran
+   * instead, so the Scene can report which path actually simulated this frame
+   * rather than assuming an installed backend did the work.
    */
   stepWithBackend(backend, dt, mouseX, mouseY, width, height) {
     const count = this.maxParticles;
     backend.ensure(count);
     backend.gather(this.particleData, count, true);
-    this._wasmPending = backend.step(count, {
+    const pending = backend.step(count, {
       dt,
       mouseX,
       mouseY,
@@ -325,8 +329,14 @@ var ComputeParticleEntity = (_class = class extends _chunkAGP4VLF4js.Entity {
       maxVelocity: this.maxVelocity,
       explosion: this.pendingExplosion
     });
+    if (pending === null) {
+      this.updateCPU(dt, mouseX, mouseY, width, height);
+      return false;
+    }
+    this._wasmPending = pending;
     backend.scatter(this.particleData, count);
     this.pendingExplosion = null;
+    return true;
   }
   destroy() {
     this.destroyGPUResources();
@@ -470,148 +480,6 @@ 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,
@@ -704,7 +572,10 @@ var WasmTransformBackend = (_class2 = class {
     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. */
+   *  the resident views. Call when the tree structure changes, not per frame.
+   *  Returns `false` if the crate rejected the run count, in which case the
+   *  PREVIOUS topology is still published and any kernel run against it would
+   *  compose the wrong tree — the caller must not proceed. */
   uploadRuns(store) {
     this.ensure(store.count, store.runCount);
     const rc = store.runCount;
@@ -712,6 +583,7 @@ var WasmTransformBackend = (_class2 = class {
     this.vrs.set(store.runStart.subarray(0, rc));
     this.vrl.set(store.runLen.subarray(0, rc));
     this.lastStatus = this.ex.set_run_count(rc);
+    return this.lastStatus === WASM_STATUS.OK;
   }
   /**
    * Status of the most recent kernel or run-table call. `WASM_STATUS.OK` unless
@@ -760,7 +632,8 @@ var WasmTransformBackend = (_class2 = class {
     this.vby.set(store.by.subarray(0, n));
     this.vbw.set(store.bw.subarray(0, n));
     this.vbh.set(store.bh.subarray(0, n));
-    this.ex.compute_aabbs(n);
+    this.lastStatus = this.ex.compute_aabbs(n);
+    if (this.lastStatus !== WASM_STATUS.OK) return;
     store.aminx.set(this.vaminx.subarray(0, n));
     store.aminy.set(this.vaminy.subarray(0, n));
     store.amaxx.set(this.vamaxx.subarray(0, n));
@@ -768,9 +641,12 @@ var WasmTransformBackend = (_class2 = class {
   }
   /** Run the AABB pass only, over `count` entities already resident in wasm
    *  memory (bounds written via {@link boundsView}, world matrices already
-   *  composed). No upload/readback — the per-frame resident path. */
+   *  composed). No upload/readback — the per-frame resident path. Returns
+   *  `false` if the kernel rejected `count` (beyond capacity, or uninitialized),
+   *  in which case {@link aabbView} still holds the previous frame's bounds. */
   runAabbs(count) {
-    this.ex.compute_aabbs(count);
+    this.lastStatus = this.ex.compute_aabbs(count);
+    return this.lastStatus === WASM_STATUS.OK;
   }
   /** Resident wasm local-bounds input views (`bx,by,bw,bh`) for the AABB pass. */
   boundsView() {
@@ -844,6 +720,148 @@ var WasmTransformBackend = (_class2 = class {
   }
 }, _class2);
 
+// 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/anim-backend.ts
 var PAD3 = 8;
 var AnimBackend = (_class3 = class {
@@ -852,7 +870,7 @@ var AnimBackend = (_class3 = class {
   __init13() {this.tweenCap = 0}
   
   
-  constructor(instance) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);
+  constructor(instance) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);
     this.ex = instance.exports;
   }
   /** The resident spring SoA input/output views, valid until the next capacity
@@ -878,14 +896,33 @@ var AnimBackend = (_class3 = class {
     this.ex.anim_init(this.springCap, this.tweenCap);
     this.refreshViews();
   }
-  /** Advance `count` springs (from index 0) by `dtMs` milliseconds, in place. */
+  /**
+   * Advance `count` springs (from index 0) by `dtMs` milliseconds, in place.
+   * Returns `true` when the kernel ran. `false` means it rejected the call
+   * (count beyond the capacity {@link ensure} allocated, or no `anim_init` yet)
+   * and wrote nothing, so the caller must tick those drivers in JS instead of
+   * scattering back a pack the kernel never touched. See {@link lastStatus}.
+   */
   stepSprings(dtMs, count) {
-    this.ex.spring_step(dtMs / 1e3, count);
+    this.lastStatus = this.ex.spring_step(dtMs / 1e3, count);
+    return this.lastStatus === WASM_STATUS.OK;
   }
-  /** Advance `count` tweens (from index 0) by `dtMs` milliseconds, writing `val`. */
+  /**
+   * Advance `count` tweens (from index 0) by `dtMs` milliseconds, writing `val`.
+   * Returns `true` when the kernel ran; `false` means it rejected the call and
+   * wrote nothing (see {@link stepSprings}). `elapsed` is kernel-side state, so
+   * a rejected tween pack must not be read back — it is unadvanced, not
+   * partially advanced.
+   */
   stepTweens(dtMs, count) {
-    this.ex.tween_step(dtMs, count);
+    this.lastStatus = this.ex.tween_step(dtMs, count);
+    return this.lastStatus === WASM_STATUS.OK;
   }
+  /**
+   * Status of the most recent kernel call — `WASM_STATUS.OK` unless the kernel
+   * declined it. Mirrors {@link TransformBackend.lastStatus}.
+   */
+  __init14() {this.lastStatus = WASM_STATUS.OK}
   refreshViews() {
     const buf = this.ex.memory.buffer;
     const sCap = this.springCap;
@@ -915,9 +952,9 @@ var PAD4 = 8;
 var CELLS_PER_ENTITY_HINT = 4;
 var HitTestBackend = (_class4 = class {
   
-  __init14() {this.entityCap = 0}
-  __init15() {this.cellCap = 0}
-  __init16() {this.itemCap = 0}
+  __init15() {this.entityCap = 0}
+  __init16() {this.cellCap = 0}
+  __init17() {this.itemCap = 0}
   
   
   
@@ -926,10 +963,10 @@ var HitTestBackend = (_class4 = class {
   
   
   /** Grid geometry from the last {@link ensure} call. */
-  __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);
+  __init18() {this.gridW = 0}
+  __init19() {this.gridH = 0}
+  __init20() {this.cellSize = 64}
+  constructor(instance) {;_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);_class4.prototype.__init20.call(this);
     this.ex = instance.exports;
   }
   /** The resident AABB input views (`minx/miny/maxx/maxy`), valid until the
@@ -1013,9 +1050,9 @@ var HitTestBackend = (_class4 = class {
 var PAD5 = 8;
 var ParticleBackend = (_class5 = class {
   
-  __init20() {this.cap = 0}
+  __init21() {this.cap = 0}
   
-  constructor(instance) {;_class5.prototype.__init20.call(this);
+  constructor(instance) {;_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);
     this.ex = instance.exports;
   }
   /** The resident SoA views, valid until the next capacity growth. */
@@ -1036,6 +1073,12 @@ var ParticleBackend = (_class5 = class {
    * 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
    * `hasPendingAnimations` flag), so the caller need not re-scan the buffer.
+   *
+   * Returns `null` when the kernel REJECTED the call — `count` beyond the
+   * capacity {@link ensure} allocated, or no `particle_init` yet. Nothing was
+   * written, so the caller must NOT {@link scatter} (that would write the
+   * gathered pre-step values back and freeze the simulation) and should fall
+   * back to the JS `updateCPU` path for this frame. See {@link lastStatus}.
    */
   step(count, p) {
     const e = p.explosion;
@@ -1055,8 +1098,18 @@ var ParticleBackend = (_class5 = class {
       e ? e.force : 0,
       count
     );
+    if (flag < 0) {
+      this.lastStatus = -flag;
+      return null;
+    }
+    this.lastStatus = WASM_STATUS.OK;
     return flag !== 0;
   }
+  /**
+   * Status of the most recent {@link step} — `WASM_STATUS.OK` unless the kernel
+   * declined it. Mirrors {@link TransformBackend.lastStatus}.
+   */
+  __init22() {this.lastStatus = WASM_STATUS.OK}
   /** Transpose the AoS stride-8 buffer into the SoA views (position/velocity/
    *  life every frame; origin upload-once when `withOrigin`). */
   gather(data, count, withOrigin) {
@@ -1147,11 +1200,11 @@ async function loadCoreWasmModule(source) {
 }
 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);
+  __init23() {this.transformBackend = null}
+  __init24() {this.animBackend = null}
+  __init25() {this.hitBackend = null}
+  __init26() {this.particleBackendInstance = null}
+  constructor(instance) {;_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);
     this.instance = instance;
   }
   /**
@@ -1190,6 +1243,79 @@ async function loadCoreWasmRuntime(source) {
   return createCoreWasmRuntime(module);
 }
 
+// src/performance/UserTiming.ts
+var VECTO_USER_TIMING = {
+  scene: {
+    transform: "vecto:scene:transform",
+    drawWalk: "vecto:scene:draw-walk",
+    entityPaint: "vecto:scene:entity-paint",
+    flush: "vecto:scene:flush",
+    a11ySync: "vecto:scene:a11y-sync"
+  },
+  markdown: {
+    parse: "vecto:markdown:parse"
+  }
+};
+var nextSpanId = 0;
+function beginVectoUserTiming(name) {
+  const candidate = globalThis.performance;
+  if (typeof _optionalChain([candidate, 'optionalAccess', _13 => _13.mark]) !== "function" || typeof candidate.measure !== "function") {
+    return null;
+  }
+  const id = nextSpanId++;
+  const startMark = `${name}:start:${id}`;
+  const endMark = `${name}:end:${id}`;
+  try {
+    candidate.mark(startMark);
+    return {
+      name,
+      startMark,
+      endMark,
+      performance: candidate
+    };
+  } catch (e7) {
+    return null;
+  }
+}
+function endVectoUserTiming(span) {
+  if (!span) return;
+  const timing = span.performance;
+  try {
+    timing.mark(span.endMark);
+    timing.measure(span.name, span.startMark, span.endMark);
+  } catch (e8) {
+  } finally {
+    try {
+      _optionalChain([timing, 'access', _14 => _14.clearMarks, 'optionalCall', _15 => _15(span.startMark)]);
+      _optionalChain([timing, 'access', _16 => _16.clearMarks, 'optionalCall', _17 => _17(span.endMark)]);
+    } catch (e9) {
+    }
+  }
+}
+function measureVectoUserTiming(name, durationMs) {
+  const candidate = globalThis.performance;
+  if (typeof _optionalChain([candidate, 'optionalAccess', _18 => _18.now]) !== "function" || typeof candidate.mark !== "function" || typeof candidate.measure !== "function") {
+    return;
+  }
+  const id = nextSpanId++;
+  const startMark = `${name}:start:${id}`;
+  const endMark = `${name}:end:${id}`;
+  const endTime = candidate.now();
+  const startTime = Math.max(0, endTime - Math.max(0, durationMs));
+  try {
+    candidate.mark(startMark, { startTime });
+    candidate.mark(endMark, { startTime: endTime });
+    candidate.measure(name, startMark, endMark);
+  } catch (e10) {
+  } finally {
+    try {
+      _optionalChain([candidate, 'access', _19 => _19.clearMarks, 'optionalCall', _20 => _20(startMark)]);
+      _optionalChain([candidate, 'access', _21 => _21.clearMarks, 'optionalCall', _22 => _22(endMark)]);
+    } catch (e11) {
+    }
+  }
+}
+
 // src/tree/Scene.ts
 var _text = require('@vectojs/text'); _createStarExport(_text);
 var RANGE_VALUE_ROLES = /* @__PURE__ */ new Set(["slider", "spinbutton", "progressbar", "scrollbar", "meter"]);
@@ -1204,9 +1330,47 @@ var INTERACTIVE_A11Y_ROLES = /* @__PURE__ */ new Set([
   "slider",
   "combobox"
 ]);
+var A11Y_REQUIRED_OWNED = /* @__PURE__ */ new Map([
+  ["grid", /* @__PURE__ */ new Set(["row", "rowgroup"])],
+  ["table", /* @__PURE__ */ new Set(["row", "rowgroup"])],
+  ["treegrid", /* @__PURE__ */ new Set(["row", "rowgroup"])],
+  ["rowgroup", /* @__PURE__ */ new Set(["row"])],
+  ["row", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
+  ["tablist", /* @__PURE__ */ new Set(["tab"])],
+  ["tree", /* @__PURE__ */ new Set(["treeitem", "group"])],
+  ["group", /* @__PURE__ */ new Set(["treeitem", "menuitem", "menuitemcheckbox", "menuitemradio", "option"])],
+  ["menu", /* @__PURE__ */ new Set(["menuitem", "menuitemcheckbox", "menuitemradio", "group", "separator"])],
+  ["menubar", /* @__PURE__ */ new Set(["menuitem", "menuitemcheckbox", "menuitemradio", "group", "separator"])],
+  ["listbox", /* @__PURE__ */ new Set(["option", "group"])],
+  ["list", /* @__PURE__ */ new Set(["listitem"])]
+]);
 function isNativelyFocusable(element) {
   return element instanceof HTMLButtonElement || element instanceof HTMLInputElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement || element instanceof HTMLAnchorElement && element.hasAttribute("href");
 }
+var REBASED_BOX = { left: 0, top: 0, matrix: "" };
+function rebaseChildBox(parent, parentOriginX, parentOriginY, child, childOriginX, childOriginY) {
+  const det = parent.a * parent.d - parent.b * parent.c;
+  if (!Number.isFinite(det) || Math.abs(det) < 1e-12) {
+    REBASED_BOX.left = 0;
+    REBASED_BOX.top = 0;
+    REBASED_BOX.matrix = "matrix(1, 0, 0, 1, 0, 0)";
+    return REBASED_BOX;
+  }
+  const ia = parent.d / det;
+  const ib = -parent.b / det;
+  const ic = -parent.c / det;
+  const id = parent.a / det;
+  const dx = childOriginX - parentOriginX;
+  const dy = childOriginY - parentOriginY;
+  REBASED_BOX.left = ia * dx + ic * dy;
+  REBASED_BOX.top = ib * dx + id * dy;
+  const a = ia * child.a + ic * child.b;
+  const b = ib * child.a + id * child.b;
+  const c = ia * child.c + ic * child.d;
+  const d = ib * child.c + id * child.d;
+  REBASED_BOX.matrix = `matrix(${a}, ${b}, ${c}, ${d}, 0, 0)`;
+  return REBASED_BOX;
+}
 var REDUCED_MOTION_FPS = 30;
 function parseInlinePx(value) {
   if (!value || !value.endsWith("px")) return null;
@@ -1292,9 +1456,9 @@ function parseCssMatrix(transform) {
 }
 function clientToGridLocal(contentEl, canvas, clientX, clientY) {
   const line = contentEl.querySelector("[data-vecto-grid-line]");
-  const originMarker = _optionalChain([line, 'optionalAccess', _13 => _13.querySelector, 'call', _14 => _14('[data-vecto-grid-basis="origin"]')]);
-  const xMarker = _optionalChain([line, 'optionalAccess', _15 => _15.querySelector, 'call', _16 => _16('[data-vecto-grid-basis="x"]')]);
-  const yMarker = _optionalChain([line, 'optionalAccess', _17 => _17.querySelector, 'call', _18 => _18('[data-vecto-grid-basis="y"]')]);
+  const originMarker = _optionalChain([line, 'optionalAccess', _23 => _23.querySelector, 'call', _24 => _24('[data-vecto-grid-basis="origin"]')]);
+  const xMarker = _optionalChain([line, 'optionalAccess', _25 => _25.querySelector, 'call', _26 => _26('[data-vecto-grid-basis="x"]')]);
+  const yMarker = _optionalChain([line, 'optionalAccess', _27 => _27.querySelector, 'call', _28 => _28('[data-vecto-grid-basis="y"]')]);
   if (line && originMarker && xMarker && yMarker) {
     const origin = originMarker.getBoundingClientRect();
     const xPoint = xMarker.getBoundingClientRect();
@@ -1378,7 +1542,7 @@ function nearestTextPositionInLine(line, x, y) {
       nearest = { position: { node, offset }, distance: candidate.distance };
     }
   }
-  return _nullishCoalesce(_optionalChain([nearest, 'optionalAccess', _19 => _19.position]), () => ( null));
+  return _nullishCoalesce(_optionalChain([nearest, 'optionalAccess', _29 => _29.position]), () => ( null));
 }
 function nearestTextPositionInProjection(contentEl, canvas, x, y, eventTarget) {
   if (contentEl.dataset.vectoContentGrid !== void 0) {
@@ -1392,7 +1556,7 @@ function nearestTextPositionInProjection(contentEl, canvas, x, y, eventTarget) {
     }
     targetLine = targetLine.parentElement;
   }
-  if (_optionalChain([targetLine, 'optionalAccess', _20 => _20.parentElement]) === contentEl) {
+  if (_optionalChain([targetLine, 'optionalAccess', _30 => _30.parentElement]) === contentEl) {
     return nearestTextPositionInLine(targetLine, x, y);
   }
   let bestLine = null;
@@ -1479,13 +1643,13 @@ function extendSelection(selection, anchor, focus) {
   try {
     selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
     return;
-  } catch (e7) {
+  } catch (e12) {
   }
   try {
     selection.collapse(anchor.node, anchor.offset);
     selection.extend(focus.node, focus.offset);
     return;
-  } catch (e8) {
+  } catch (e13) {
   }
   const anchorRange = document.createRange();
   anchorRange.setStart(anchor.node, anchor.offset);
@@ -1520,15 +1684,15 @@ var Scene = (_class7 = class _Scene {
   
   
   
-  __init25() {this.isRunning = false}
+  __init27() {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). */
-  __init26() {this._canvasOnScreen = true}
-  __init27() {this._canvasObserver = null}
-  __init28() {this.lastTime = 0}
+  __init28() {this._canvasOnScreen = true}
+  __init29() {this._canvasObserver = null}
+  __init30() {this.lastTime = 0}
   
   /**
    * Redraw strategy:
@@ -1537,11 +1701,12 @@ var Scene = (_class7 = class _Scene {
    *   {@link markDirty}) or while an animation is pending. Ideal for static /
    *   event-driven UIs where idle frames should cost ~0.
    */
-  __init29() {this.renderMode = "always"}
+  __init31() {this.renderMode = "always"}
   /** Cap on distinct recorded dirty reasons (see `recordDirtyReason`). */
   static __initStatic4() {this.MAX_DIRTY_REASONS = 200}
-  __init30() {this._phaseTiming = false}
-  __init31() {this._phaseTotals = /* @__PURE__ */ new Map()}
+  __init32() {this._phaseTiming = false}
+  __init33() {this._userTiming = false}
+  __init34() {this._phaseTotals = /* @__PURE__ */ new Map()}
   /**
    * Start or stop per-phase render timing.
    *
@@ -1563,6 +1728,19 @@ var Scene = (_class7 = class _Scene {
   get phaseTiming() {
     return this._phaseTiming;
   }
+  /**
+   * Enable or disable browser User Timing phase instrumentation.
+   *
+   * Off by default. The disabled frame path performs only boolean checks and
+   * emits no Performance Timeline entries.
+   */
+  setUserTiming(enabled) {
+    this._userTiming = enabled;
+  }
+  /** Whether browser User Timing phase instrumentation is enabled. */
+  get userTiming() {
+    return this._userTiming;
+  }
   /**
    * Accumulate one phase sample.
    *
@@ -1604,32 +1782,32 @@ var Scene = (_class7 = class _Scene {
   clearRenderPhases() {
     this._phaseTotals.clear();
   }
-  __init32() {this._dirtyTracking = false}
-  __init33() {this._dirtyReasons = /* @__PURE__ */ new Map()}
-  __init34() {this.dirty = true}
+  __init35() {this._dirtyTracking = false}
+  __init36() {this._dirtyReasons = /* @__PURE__ */ new Map()}
+  __init37() {this.dirty = true}
   /** Whether to throttle rendering to 2 FPS when the scene is static to save power. */
-  __init35() {this.autoThrottle = true}
+  __init38() {this.autoThrottle = true}
   // --- Frame telemetry (read via `frameStats`) ---------------------------
   /** Wall-clock ms spent inside the last `render()` call. */
-  __init36() {this._lastFrameMs = 0}
+  __init39() {this._lastFrameMs = 0}
   /** Rolling exponential average of rendered-frame intervals, in ms. */
-  __init37() {this._avgFrameIntervalMs = 0}
+  __init40() {this._avgFrameIntervalMs = 0}
   /** dt (ms) handed to the last rendered frame. */
-  __init38() {this._lastDt = 0}
+  __init41() {this._lastDt = 0}
   /** Count of frames actually rendered since the loop started. */
-  __init39() {this._renderedFrames = 0}
+  __init42() {this._renderedFrames = 0}
   /** Count of rAF ticks skipped (idle / capped) since the loop started. */
-  __init40() {this._skippedFrames = 0}
+  __init43() {this._skippedFrames = 0}
   /** `time` of the previous *rendered* frame, for interval measurement. */
-  __init41() {this._lastRenderTick = 0}
+  __init44() {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}.
    */
-  __init42() {this.maxFPS = 60}
+  __init45() {this.maxFPS = 60}
   /** Whether the OS prefers-reduced-motion setting auto-caps the loop. */
-  __init43() {this.respectReducedMotion = true}
+  __init46() {this.respectReducedMotion = true}
   /**
    * Reading direction for accessibility tab/traversal order (`'ltr'` default,
    * `'rtl'`). Controls the inline sort within a visual row in
@@ -1645,18 +1823,18 @@ var Scene = (_class7 = class _Scene {
       this.a11yNeedsReorder = true;
     }
   }
-  __init44() {this._readingDirection = "ltr"}
+  __init47() {this._readingDirection = "ltr"}
   /** Cached media-query list; `.matches` is read live each frame. */
-  __init45() {this.reducedMotionQuery = null}
+  __init48() {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. */
-  __init46() {this.forcedColorsQuery = null}
-  __init47() {this.forcedColorsChangeHandler = null}
+  __init49() {this.forcedColorsQuery = null}
+  __init50() {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]);
+    return this.respectReducedMotion && !!_optionalChain([this, 'access', _31 => _31.reducedMotionQuery, 'optionalAccess', _32 => _32.matches]);
   }
   /**
    * True when the OS is in a forced-colors mode (Windows High Contrast, and the
@@ -1667,28 +1845,28 @@ var Scene = (_class7 = class _Scene {
    * when the setting toggles.
    */
   get forcedColors() {
-    return !!_optionalChain([this, 'access', _23 => _23.forcedColorsQuery, 'optionalAccess', _24 => _24.matches]);
+    return !!_optionalChain([this, 'access', _33 => _33.forcedColorsQuery, 'optionalAccess', _34 => _34.matches]);
   }
   /**
    * Throttle interval (ms) for the a11y/automation shadow sync. `0` = every
    * frame. See {@link SceneOptions.a11ySyncInterval}.
    */
-  __init48() {this.a11ySyncInterval = 0}
+  __init51() {this.a11ySyncInterval = 0}
   /** Timestamp of the last a11y sync, for throttling. */
-  __init49() {this.lastA11ySync = -Infinity}
+  __init52() {this.lastA11ySync = -Infinity}
   /** True if we skipped an a11y sync during animation and need to sync when at rest. */
-  __init50() {this.a11yPendingSyncAfterAnimation = false}
+  __init53() {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.
   
-  __init51() {this.a11yElements = /* @__PURE__ */ new Map()}
+  __init54() {this.a11yElements = /* @__PURE__ */ new Map()}
   /** DOM nodes mirroring static text content, keyed by entity id. */
-  __init52() {this.contentElements = /* @__PURE__ */ new Map()}
+  __init55() {this.contentElements = /* @__PURE__ */ new Map()}
   /** Pending cold font-calibration frame per projected grid entity. */
-  __init53() {this.contentGridCalibrationFrames = /* @__PURE__ */ new Map()}
+  __init56() {this.contentGridCalibrationFrames = /* @__PURE__ */ new Map()}
   /** Detached, untransformed font probes used by the cold calibration pass. */
-  __init54() {this.contentGridCalibrationProbes = /* @__PURE__ */ new Map()}
+  __init57() {this.contentGridCalibrationProbes = /* @__PURE__ */ new Map()}
   /**
    * Monotonic stamp identifying the conditions grid cells were calibrated under.
    *
@@ -1709,69 +1887,71 @@ var Scene = (_class7 = class _Scene {
    * A plain incrementing integer rather than the descriptive calibration key,
    * because it goes into an attribute selector and must not need escaping.
    */
-  __init55() {this.contentGridCalibrationGeneration = 0}
+  __init58() {this.contentGridCalibrationGeneration = 0}
   /** The `(fontEpoch, pageScale)` pair the current generation corresponds to. */
-  __init56() {this.contentGridCalibrationStamp = ""}
+  __init59() {this.contentGridCalibrationStamp = ""}
   /** Invalidates grid font calibration after browser font availability changes. */
-  __init57() {this.contentFontEpoch = 0}
+  __init60() {this.contentFontEpoch = 0}
   /** Cached Canvas-to-client scale for the current font/viewport epoch. */
-  __init58() {this.contentMetricScaleEpoch = -1}
-  __init59() {this.contentMetricScaleX = 1}
-  __init60() {this.contentProjectionEnabled = true}
+  __init61() {this.contentMetricScaleEpoch = -1}
+  __init62() {this.contentMetricScaleX = 1}
+  __init63() {this.contentProjectionEnabled = true}
   // Virtualization margin (px) for content projection; `undefined` → one
   // viewport height, resolved at sync time. `Infinity` = materialize everything.
-  __init61() {this.contentProjectionMargin = void 0}
+  __init64() {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.
    */
-  __init62() {this.blankRegionSelectionDrag = false}
-  __init63() {this.contentSelectionAnchor = null}
-  __init64() {this.contentSelectionEndListener = null}
+  __init65() {this.blankRegionSelectionDrag = false}
+  __init66() {this.contentSelectionAnchor = null}
+  __init67() {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.
-  __init65() {this.frameHadAnimation = true}
-  __init66() {this.frameHadInteractive = true}
+  __init68() {this.frameHadAnimation = true}
+  __init69() {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. */
-  __init67() {this.dprMediaQuery = null}
+  __init70() {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. */
-  __init68() {this.canvasResizeObserver = null}
-  __init69() {this.dprChangeHandler = null}
-  __init70() {this.focusedA11yElement = null}
+  __init71() {this.canvasResizeObserver = null}
+  __init72() {this.dprChangeHandler = null}
+  __init73() {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). */
-  __init71() {this._overlayGeometry = null}
+  __init74() {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. */
-  __init72() {this.hoveredA11yElements = /* @__PURE__ */ new WeakSet()}
+  __init75() {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. */
-  __init73() {this.focusSentinel = null}
-  __init74() {this.caretBlinkTimer = null}
-  __init75() {this.a11yNeedsReorder = true}
-  __init76() {this.portalRoot = null}
-  __init77() {this.fullViewportElements = []}
-  __init78() {this.normalElements = []}
-  __init79() {this.activeIds = /* @__PURE__ */ new Set()}
-  __init80() {this.activePortalsThisFrame = /* @__PURE__ */ new Set()}
-  __init81() {this.activePortalsPrevFrame = /* @__PURE__ */ new Set()}
-  __init82() {this.portalEntities = /* @__PURE__ */ new Map()}
-  __init83() {this.renderOrderCounter = 0}
+  __init76() {this.focusSentinel = null}
+  __init77() {this.caretBlinkTimer = null}
+  __init78() {this.a11yNeedsReorder = true}
+  __init79() {this.portalRoot = null}
+  __init80() {this.fullViewportElements = []}
+  __init81() {this.normalElements = []}
+  __init82() {this.activeIds = /* @__PURE__ */ new Set()}
+  /** Per-parent insertion cursor, reused by `enforceA11yDomOrder`. */
+  __init83() {this.a11yOrderCursors = /* @__PURE__ */ new Map()}
+  __init84() {this.activePortalsThisFrame = /* @__PURE__ */ new Set()}
+  __init85() {this.activePortalsPrevFrame = /* @__PURE__ */ new Set()}
+  __init86() {this.portalEntities = /* @__PURE__ */ new Map()}
+  __init87() {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
@@ -1780,7 +1960,7 @@ var Scene = (_class7 = class _Scene {
    * back to the ancestor walk. Public for the same reason `Entity._getTrig`/
    * `_setWorldCache` are: it is a cross-class render-internal contract.
    */
-  __init84() {this.currentFrame = 0}
+  __init88() {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
@@ -1788,24 +1968,24 @@ var Scene = (_class7 = 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.
-  __init85() {this._wasm = null}
-  __init86() {this._transformBackend = "js"}
+  __init89() {this._wasm = null}
+  __init90() {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.
-  __init87() {this._treeStore = null}
-  __init88() {this._slotEntity = []}
+  __init91() {this._treeStore = null}
+  __init92() {this._slotEntity = []}
   // store slot -> entity (also validates slots)
-  __init89() {this._wasmInputs = null}
-  __init90() {this._wasmWorld = null}
-  __init91() {this._structureVersion = 0}
-  __init92() {this._storeStructureVersion = -1}
+  __init93() {this._wasmInputs = null}
+  __init94() {this._wasmWorld = null}
+  __init95() {this._structureVersion = 0}
+  __init96() {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.
-  __init93() {this._computeEntities = []}
-  __init94() {this._computeEntitiesVersion = -1}
+  __init97() {this._computeEntities = []}
+  __init98() {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() {
@@ -1867,10 +2047,13 @@ var Scene = (_class7 = class _Scene {
     return true;
   }
   // ── WASM hit-test backend (invisible accelerator, G3) ───────────────────────
-  // A separate WASM module instance from the transform backend (each crate
-  // export lives in independent linear memory per instance, so there is no
-  // shared-state hazard in running both) that indexes the main tree's world
-  // AABBs into a dense viewport grid for findEntityAt. The JS depth-first walk
+  // Served by the same instance as every other accelerator (see
+  // `_wasmRuntime`): the crate keeps transform/anim/hit/particle in distinct
+  // statics, so one instance runs them all without aliasing. It indexes the
+  // main tree's world AABBs into a dense viewport grid for findEntityAt. Note
+  // that sharing one linear memory means an allocation here can grow it and
+  // detach views built over the old buffer, so each backend re-checks buffer
+  // identity (`revalidateViews`) before use. The JS depth-first walk
   // (findHitRecursively) is the permanent fallback: a null backend, a build
   // that overflows its item budget, or the overlay tree (never indexed — small
   // and rare, not worth accelerating) all fall through to it, so WASM can only
@@ -1887,7 +2070,7 @@ var Scene = (_class7 = class _Scene {
    * cached globally; the instance is per-Scene, which is the isolation that
    * actually matters.
    */
-  __init95() {this._wasmRuntime = null}
+  __init99() {this._wasmRuntime = null}
   /**
    * Load (or reuse) this Scene's shared WASM runtime.
    *
@@ -1915,34 +2098,98 @@ var Scene = (_class7 = class _Scene {
   get wasmRuntime() {
     return this._wasmRuntime;
   }
-  __init96() {this._hitWasm = null}
+  __init100() {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.
-  __init97() {this._hitGridFrame = -1}
-  __init98() {this._hitGridOk = false}
-  __init99() {this._hitSlotEntity = []}
-  __init100() {this._hitBoundless = []}
+  __init101() {this._hitGridFrame = -1}
+  __init102() {this._hitGridOk = false}
+  __init103() {this._hitSlotEntity = []}
+  __init104() {this._hitBoundless = []}
   /** Reused buffer for the fused gather, so a pointer query allocates nothing. */
-  __init101() {this._hitGatherBuffer = null}
+  __init105() {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.
    */
-  __init102() {this._hitFusedGather = false}
+  __init106() {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.
    */
-  __init103() {this._wasmAabbsFresh = false}
+  __init107() {this._wasmAabbsFresh = false}
   /** Did the last hit-grid build use the fused (WASM-store) gather? */
   get hitGatherPath() {
     return this._hitFusedGather ? "fused" : "js";
   }
+  /**
+   * Why the transform accelerator did or did not run on the most recent frame.
+   * Written by the render walk and `_syncWasmStore`.
+   */
+  __init108() {this._transformReason = "not-installed"}
+  /** Why the batched-driver accelerator did or did not run. */
+  __init109() {this._animReason = "not-installed"}
+  /**
+   * Why the hit-test accelerator did or did not serve the last pointer query.
+   * The grid is built lazily on demand, not every frame, so this describes the
+   * most recent BUILD. Starts at `'not-installed'` because that is the truth
+   * before a backend exists; `_ensureHitGrid` moves it to `'not-applicable'`
+   * once one is installed but nothing has queried yet.
+   */
+  __init110() {this._hitReason = "not-installed"}
+  /** Why the particle accelerator did or did not run. */
+  __init111() {this._particleReason = "not-applicable"}
+  /** Which particle implementation actually simulated the most recent frame. */
+  __init112() {this._particlePath = "none"}
+  /**
+   * Per-frame status of every invisible accelerator: whether each is installed,
+   * whether it actually ran on the most recent frame, and why.
+   *
+   * This exists because the older per-accelerator getters
+   * ({@link transformBackend}, {@link animBackend}, {@link hitTestBackend},
+   * {@link particleBackend}) report only that a backend is INSTALLED. Reading
+   * `'wasm'` from one of those and concluding the accelerator is doing work is
+   * wrong whenever a gate never opens, a kernel rejects its arguments, or a
+   * faster backend takes the pass instead. Read {@link AcceleratorStatus.reason}
+   * for which of those happened.
+   *
+   * Reflects the most recent main-renderer frame; a secondary renderer (SVG
+   * export, offscreen snapshot) does not overwrite it.
+   */
+  get accelerators() {
+    return {
+      transform: {
+        available: this._wasm !== null && this._transformBackend === "wasm",
+        activeThisFrame: this._transformReason === "active",
+        reason: this._transformReason,
+        path: this._transformReason === "active" ? "wasm" : "js"
+      },
+      animation: {
+        available: this._animWasm !== null,
+        activeThisFrame: this._animBatchedLastFrame,
+        reason: this._animReason,
+        path: this._animBatchedLastFrame ? "wasm" : "js"
+      },
+      hitTest: {
+        available: this._hitWasm !== null,
+        // The grid is built lazily on a pointer query, not every frame, so this
+        // describes the last BUILD rather than the last frame.
+        activeThisFrame: this._hitReason === "active",
+        reason: this._hitReason,
+        path: this._hitReason !== "active" ? "js" : this._hitFusedGather ? "wasm-fused" : "wasm"
+      },
+      particle: {
+        available: this._particleWasm !== null || this.webgpuActive,
+        activeThisFrame: this._particleReason === "active",
+        reason: this._particleReason,
+        path: this._particlePath
+      }
+    };
+  }
   /** Which backend answers `findEntityAt` for the main tree. */
   get hitTestBackend() {
     return this._hitWasm ? "wasm" : "js";
@@ -1952,6 +2199,7 @@ var Scene = (_class7 = class _Scene {
   setHitTestBackend(backend) {
     this._hitWasm = backend;
     this._hitGridFrame = -1;
+    this._hitReason = backend ? "not-applicable" : "not-installed";
   }
   /**
    * Asynchronously instantiate the WASM hit-test core and, on success, hot-swap
@@ -1978,7 +2226,10 @@ var Scene = (_class7 = class _Scene {
    */
   _ensureHitGrid() {
     const backend = this._hitWasm;
-    if (!backend) return false;
+    if (!backend) {
+      this._hitReason = "not-installed";
+      return false;
+    }
     if (this._hitGridFrame === this.currentFrame) return this._hitGridOk;
     let gathered = null;
     if (this._wasm && this._ensureWasmAabbs()) {
@@ -2007,6 +2258,7 @@ var Scene = (_class7 = class _Scene {
     this._hitBoundless = gathered.boundless;
     this._hitGridFrame = this.currentFrame;
     this._hitGridOk = ok;
+    this._hitReason = ok ? "active" : "rejected";
     return ok;
   }
   /**
@@ -2029,7 +2281,7 @@ var Scene = (_class7 = class _Scene {
         const idx = cell[k];
         if (x < minx[idx] || x > maxx[idx] || y < miny[idx] || y > maxy[idx]) continue;
         const entity = this._hitSlotEntity[idx];
-        if (_optionalChain([entity, 'optionalAccess', _25 => _25.isPointInside, 'call', _26 => _26(x, y)]) && this.isHitEligible(entity, x, y)) {
+        if (_optionalChain([entity, 'optionalAccess', _35 => _35.isPointInside, 'call', _36 => _36(x, y)]) && this.isHitEligible(entity, x, y)) {
           bestIndex = idx;
           bestEntity = entity;
           break;
@@ -2052,25 +2304,25 @@ var Scene = (_class7 = 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.
-  __init104() {this._animWasm = null}
+  __init113() {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.
-  __init105() {this._activeDriverEntities = /* @__PURE__ */ new Set()}
+  __init114() {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.
-  __init106() {this._springEntities = []}
-  __init107() {this._springProps = []}
-  __init108() {this._springDrivers = []}
-  __init109() {this._tweenEntities = []}
-  __init110() {this._tweenProps = []}
-  __init111() {this._tweenDrivers = []}
+  __init115() {this._springEntities = []}
+  __init116() {this._springProps = []}
+  __init117() {this._springDrivers = []}
+  __init118() {this._tweenEntities = []}
+  __init119() {this._tweenProps = []}
+  __init120() {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
@@ -2142,7 +2394,7 @@ var Scene = (_class7 = class _Scene {
    * Setting {@link animDriverGateCount} overwrites all three, so existing code
    * that tuned the single knob keeps working unchanged.
    */
-  __init112() {this._animBatchedLastFrame = false}
+  __init121() {this._animBatchedLastFrame = false}
   /**
    * Whether the WASM batch path actually ran on the most recent frame.
    *
@@ -2154,7 +2406,7 @@ var Scene = (_class7 = class _Scene {
   get animBatchedLastFrame() {
     return this._animBatchedLastFrame;
   }
-  __init113() {this.animGate = {
+  __init122() {this.animGate = {
     spring: 128,
     tween: 256,
     mixed: 128
@@ -2192,7 +2444,7 @@ var Scene = (_class7 = 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.
-  __init114() {this._particleWasm = null}
+  __init123() {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). */
@@ -2272,7 +2524,10 @@ var Scene = (_class7 = class _Scene {
    * pre-pass.
    */
   _tickBatchedDrivers(dt) {
-    if (this._activeDriverEntities.size === 0) return;
+    if (this._activeDriverEntities.size === 0) {
+      this._animReason = "not-applicable";
+      return;
+    }
     let springBatchable = 0;
     let tweenBatchable = 0;
     for (const entity of this._activeDriverEntities) {
@@ -2289,10 +2544,17 @@ var Scene = (_class7 = class _Scene {
     const batchable = springBatchable + tweenBatchable;
     const backend = this._animWasm;
     this._animBatchedLastFrame = false;
-    if (!backend) return;
+    if (!backend) {
+      this._animReason = "not-installed";
+      return;
+    }
     const gate = springBatchable > 0 && tweenBatchable > 0 ? this.animGate.mixed : tweenBatchable > 0 ? this.animGate.tween : this.animGate.spring;
-    if (batchable < gate) return;
+    if (batchable < gate) {
+      this._animReason = "below-gate";
+      return;
+    }
     this._animBatchedLastFrame = true;
+    this._animReason = "active";
     const sE = this._springEntities;
     const sP = this._springProps;
     const sD = this._springDrivers;
@@ -2339,8 +2601,13 @@ var Scene = (_class7 = class _Scene {
         sv.damp[i] = phys.damping;
         sv.mass[i] = phys.mass;
       }
-      backend.stepSprings(dt, springCount);
-      for (let i = 0; i < springCount; i++) sD[i].syncExternal(sv.val[i], sv.vel[i]);
+      if (backend.stepSprings(dt, springCount)) {
+        for (let i = 0; i < springCount; i++) sD[i].syncExternal(sv.val[i], sv.vel[i]);
+      } else {
+        for (let i = 0; i < springCount; i++) sD[i].tick(dt);
+        this._animReason = "rejected";
+        this._animBatchedLastFrame = false;
+      }
     }
     if (tweenCount > 0) {
       const tv = backend.tweenView();
@@ -2353,8 +2620,13 @@ var Scene = (_class7 = class _Scene {
         tv.delay[i] = d.delayMs;
         tv.ease[i] = d.wasmEasingId;
       }
-      backend.stepTweens(dt, tweenCount);
-      for (let i = 0; i < tweenCount; i++) tD[i].syncExternal(tv.val[i], tv.elapsed[i]);
+      if (backend.stepTweens(dt, tweenCount)) {
+        for (let i = 0; i < tweenCount; i++) tD[i].syncExternal(tv.val[i], tv.elapsed[i]);
+      } else {
+        for (let i = 0; i < tweenCount; i++) tD[i].tick(dt);
+        this._animReason = "rejected";
+        this._animBatchedLastFrame = false;
+      }
     }
     for (let i = 0; i < springCount; i++) sE[i]._applyDriverTick(sP[i], sD[i]);
     for (let i = 0; i < tweenCount; i++) tE[i]._applyDriverTick(tP[i], tD[i]);
@@ -2376,7 +2648,10 @@ var Scene = (_class7 = class _Scene {
         slotEntity2[slot] = entity;
         entity._storeSlot = slot;
       }
-      backend.uploadRuns(built.store);
+      if (!backend.uploadRuns(built.store)) {
+        this._transformReason = "rejected";
+        return null;
+      }
       this._treeStore = built.store;
       this._slotEntity = slotEntity2;
       this._wasmInputs = backend.inputView();
@@ -2401,8 +2676,12 @@ var Scene = (_class7 = class _Scene {
       inp.sin[slot] = trig.sin;
       inp.opacity[slot] = e.opacity;
     }
-    backend.runKernel("simd");
+    if (backend.runKernel("simd") !== WASM_STATUS.OK) {
+      this._transformReason = "rejected";
+      return null;
+    }
     this._wasmAabbsFresh = false;
+    this._transformReason = "active";
     return this._wasmWorld;
   }
   /**
@@ -2432,7 +2711,7 @@ var Scene = (_class7 = class _Scene {
       bounds.bw[slot] = b ? b.width : 0;
       bounds.bh[slot] = b ? b.height : 0;
     }
-    backend.runAabbs(slotEntity.length);
+    if (!backend.runAabbs(slotEntity.length)) return false;
     this._wasmAabbsFresh = true;
     return true;
   }
@@ -2442,24 +2721,24 @@ var Scene = (_class7 = class _Scene {
    * sync, so retaining the order prevents a newly opened overlay from spending
    * its first frame below previously projected controls.
    */
-  __init115() {this.a11yRenderOrders = /* @__PURE__ */ new Map()}
+  __init124() {this.a11yRenderOrders = /* @__PURE__ */ new Map()}
   // Optional WebGL point-cloud layer (see SceneOptions.pointBackend).
-  __init116() {this.pointRenderer = null}
-  __init117() {this.glCanvas = null}
-  __init118() {this.glContextLostHandler = null}
-  __init119() {this.glContextRestoredHandler = null}
+  __init125() {this.pointRenderer = null}
+  __init126() {this.glCanvas = null}
+  __init127() {this.glContextLostHandler = null}
+  __init128() {this.glContextRestoredHandler = null}
   
   
   
-  __init120() {this.disableWindowResize = false}
+  __init129() {this.disableWindowResize = false}
   /** See {@link SceneOptions.maxDPR}. `undefined` = uncapped (real DPR). */
   
   // WebGPU properties
-  __init121() {this.destroyed = false}
-  __init122() {this.device = null}
-  __init123() {this.deviceLost = false}
-  __init124() {this.particleBackend = "auto"}
-  __init125() {this._webgpuDisabled = false}
+  __init130() {this.destroyed = false}
+  __init131() {this.device = null}
+  __init132() {this.deviceLost = false}
+  __init133() {this.particleBackend = "auto"}
+  __init134() {this._webgpuDisabled = false}
   get webgpuDisabled() {
     return this._webgpuDisabled || this.particleBackend === "cpu";
   }
@@ -2473,7 +2752,7 @@ var Scene = (_class7 = class _Scene {
    * active.
    */
   get webglDrawStats() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _27 => _27.pointRenderer, 'optionalAccess', _28 => _28.stats, 'optionalCall', _29 => _29()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _37 => _37.pointRenderer, 'optionalAccess', _38 => _38.stats, 'optionalCall', _39 => _39()]), () => ( null));
   }
   /**
    * Whether a WebGPU device is currently live for particle compute.
@@ -2487,22 +2766,22 @@ var Scene = (_class7 = class _Scene {
   set webgpuDisabled(value) {
     this._webgpuDisabled = value;
   }
-  __init126() {this.recoveryTimerId = null}
-  __init127() {this.manager = null}
-  __init128() {this.initializingWebGPU = false}
-  __init129() {this.gpuCanvas = null}
-  __init130() {this.gpuContext = null}
+  __init135() {this.recoveryTimerId = null}
+  __init136() {this.manager = null}
+  __init137() {this.initializingWebGPU = false}
+  __init138() {this.gpuCanvas = null}
+  __init139() {this.gpuContext = null}
   /** True while the GPU canvas holds a presented particle frame (needs clearing when they leave). */
-  __init131() {this.gpuHasContent = false}
-  __init132() {this.mouseX = -9999}
-  __init133() {this.mouseY = -9999}
-  __init134() {this.pointerMoveListener = null}
-  __init135() {this.pointerLeaveListener = null}
+  __init140() {this.gpuHasContent = false}
+  __init141() {this.mouseX = -9999}
+  __init142() {this.mouseY = -9999}
+  __init143() {this.pointerMoveListener = null}
+  __init144() {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. */
-  __init136() {this.pointerEventTarget = null}
-  __init137() {this.hasWarnedZeroSize = false}
-  __init138() {this.fontLoadHandler = null}
+  __init145() {this.pointerEventTarget = null}
+  __init146() {this.hasWarnedZeroSize = false}
+  __init147() {this.fontLoadHandler = null}
   // ── Dev-mode warning infrastructure ──────────────────────────────
   //
   // Enable with `Scene.devMode = true` or by setting `globalThis.__DEV__`.
@@ -2515,12 +2794,12 @@ var Scene = (_class7 = class _Scene {
   static _devModeDetected() {
     if (_Scene.devMode) return true;
     const gp = typeof globalThis !== "undefined" ? globalThis : void 0;
-    if (_optionalChain([gp, 'optionalAccess', _30 => _30.__DEV__])) return true;
-    if (_optionalChain([gp, 'optionalAccess', _31 => _31.process, 'optionalAccess', _32 => _32.env, 'optionalAccess', _33 => _33.NODE_ENV]) === "development") return true;
+    if (_optionalChain([gp, 'optionalAccess', _40 => _40.__DEV__])) return true;
+    if (_optionalChain([gp, 'optionalAccess', _41 => _41.process, 'optionalAccess', _42 => _42.env, 'optionalAccess', _43 => _43.NODE_ENV]) === "development") return true;
     return false;
   }
   
-  __init139() {this._devFrameCount = 0}
+  __init148() {this._devFrameCount = 0}
   _devWarn(message) {
     if (!this._devActive) return;
     console.warn(`[vectojs/dev] ${message}`);
@@ -2547,9 +2826,9 @@ var Scene = (_class7 = class _Scene {
     let checked = 0;
     const walkProjections = (node) => {
       if (checked > 10) return;
-      const proj = _optionalChain([node, 'access', _34 => _34.getContentProjection, 'optionalCall', _35 => _35()]);
-      if (_optionalChain([proj, 'optionalAccess', _36 => _36.text]) && proj.selectable !== false) {
-        const el = _optionalChain([this, 'access', _37 => _37.contentElements, 'optionalAccess', _38 => _38.get, 'call', _39 => _39(node.id)]);
+      const proj = _optionalChain([node, 'access', _44 => _44.getContentProjection, 'optionalCall', _45 => _45()]);
+      if (_optionalChain([proj, 'optionalAccess', _46 => _46.text]) && proj.selectable !== false) {
+        const el = _optionalChain([this, 'access', _47 => _47.contentElements, 'optionalAccess', _48 => _48.get, 'call', _49 => _49(node.id)]);
         if (el) {
           const projectedText = el.textContent || "";
           if (projectedText !== "" && projectedText !== proj.text) {
@@ -2564,14 +2843,14 @@ var Scene = (_class7 = class _Scene {
     };
     walkProjections(this.root);
   }
-  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);_class7.prototype.__init134.call(this);_class7.prototype.__init135.call(this);_class7.prototype.__init136.call(this);_class7.prototype.__init137.call(this);_class7.prototype.__init138.call(this);_class7.prototype.__init139.call(this);
+  constructor(canvas, options = {}) {;_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);_class7.prototype.__init134.call(this);_class7.prototype.__init135.call(this);_class7.prototype.__init136.call(this);_class7.prototype.__init137.call(this);_class7.prototype.__init138.call(this);_class7.prototype.__init139.call(this);_class7.prototype.__init140.call(this);_class7.prototype.__init141.call(this);_class7.prototype.__init142.call(this);_class7.prototype.__init143.call(this);_class7.prototype.__init144.call(this);_class7.prototype.__init145.call(this);_class7.prototype.__init146.call(this);_class7.prototype.__init147.call(this);_class7.prototype.__init148.call(this);
     this.canvas = canvas;
     this.debugA11y = _nullishCoalesce(options.debugA11y, () => ( false));
     this.disableWindowResize = _nullishCoalesce(options.disableWindowResize, () => ( false));
     this.maxDPR = options.maxDPR;
     if (this.disableWindowResize) {
-      const styleWidth = parseInlinePx(_optionalChain([canvas, 'access', _40 => _40.style, 'optionalAccess', _41 => _41.width]));
-      const styleHeight = parseInlinePx(_optionalChain([canvas, 'access', _42 => _42.style, 'optionalAccess', _43 => _43.height]));
+      const styleWidth = parseInlinePx(_optionalChain([canvas, 'access', _50 => _50.style, 'optionalAccess', _51 => _51.width]));
+      const styleHeight = parseInlinePx(_optionalChain([canvas, 'access', _52 => _52.style, 'optionalAccess', _53 => _53.height]));
       this.width = _nullishCoalesce(styleWidth, () => ( (canvas.width || canvas.clientWidth || 0)));
       this.height = _nullishCoalesce(styleHeight, () => ( (canvas.height || canvas.clientHeight || 0)));
     } else {
@@ -2579,10 +2858,11 @@ var Scene = (_class7 = class _Scene {
       this.height = typeof window !== "undefined" ? window.innerHeight : canvas.clientHeight || canvas.height || 600;
     }
     const globalProcess = typeof globalThis !== "undefined" ? globalThis.process : void 0;
-    const isTest = globalProcess && (_optionalChain([globalProcess, 'access', _44 => _44.env, 'optionalAccess', _45 => _45.NODE_ENV]) === "test" || _optionalChain([globalProcess, 'access', _46 => _46.env, 'optionalAccess', _47 => _47.VITEST]) === "true");
+    const isTest = globalProcess && (_optionalChain([globalProcess, 'access', _54 => _54.env, 'optionalAccess', _55 => _55.NODE_ENV]) === "test" || _optionalChain([globalProcess, 'access', _56 => _56.env, 'optionalAccess', _57 => _57.VITEST]) === "true");
     this.maxFPS = _nullishCoalesce(options.maxFPS, () => ( (isTest ? 0 : 60)));
     this.respectReducedMotion = _nullishCoalesce(options.respectReducedMotion, () => ( true));
     this.autoThrottle = _nullishCoalesce(options.autoThrottle, () => ( true));
+    this._userTiming = _nullishCoalesce(options.userTiming, () => ( false));
     this.particleBackend = _nullishCoalesce(options.particleBackend, () => ( "auto"));
     this.a11ySyncInterval = _nullishCoalesce(options.a11ySyncInterval, () => ( 0));
     this.contentProjectionEnabled = _nullishCoalesce(options.contentProjection, () => ( true));
@@ -2593,7 +2873,7 @@ var Scene = (_class7 = class _Scene {
     if (typeof window !== "undefined" && typeof window.matchMedia === "function") {
       this.forcedColorsQuery = window.matchMedia("(forced-colors: active)");
       this.forcedColorsChangeHandler = () => this.markDirty();
-      _optionalChain([this, 'access', _48 => _48.forcedColorsQuery, 'access', _49 => _49.addEventListener, 'optionalCall', _50 => _50("change", this.forcedColorsChangeHandler)]);
+      _optionalChain([this, 'access', _58 => _58.forcedColorsQuery, 'access', _59 => _59.addEventListener, 'optionalCall', _60 => _60("change", this.forcedColorsChangeHandler)]);
     }
     this.root = new class RootEntity extends _chunkAGP4VLF4js.Entity {
       isPointInside() {
@@ -2615,18 +2895,19 @@ var Scene = (_class7 = class _Scene {
     if (options.renderer) {
       this.renderer = options.renderer;
     } else {
-      this.renderer = new (0, _chunkLHONR3GOjs.CanvasRenderer)(
+      this.renderer = new (0, _chunkKEBYJVD6js.CanvasRenderer)(
         canvas,
         this.disableWindowResize ? { width: this.width, height: this.height } : void 0,
         this.maxDPR
       );
     }
-    _optionalChain([this, 'access', _51 => _51.renderer, 'access', _52 => _52.onContextRestored, 'optionalCall', _53 => _53(() => {
+    _optionalChain([this, 'access', _61 => _61.renderer, 'access', _62 => _62.onContextRestored, 'optionalCall', _63 => _63(() => {
       this.markDirty();
-      if (_optionalChain([this, 'access', _54 => _54.renderer, 'access', _55 => _55.isContextLost, 'optionalCall', _56 => _56()]) !== true) this.render(this.renderer);
+      if (_optionalChain([this, 'access', _64 => _64.renderer, 'access', _65 => _65.isContextLost, 'optionalCall', _66 => _66()]) !== true) this.render(this.renderer);
     })]);
     if (typeof document !== "undefined") {
       this.a11yRoot = document.createElement("div");
+      this.a11yRoot.setAttribute("data-vecto-a11y-root", "");
       this.a11yRoot.style.position = "absolute";
       this.a11yRoot.style.top = "0";
       this.a11yRoot.style.left = "0";
@@ -2792,7 +3073,7 @@ var Scene = (_class7 = class _Scene {
   watchDevicePixelRatio() {
     if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
     if (this.dprMediaQuery && this.dprChangeHandler) {
-      _optionalChain([this, 'access', _57 => _57.dprMediaQuery, 'access', _58 => _58.removeEventListener, 'optionalCall', _59 => _59("change", this.dprChangeHandler)]);
+      _optionalChain([this, 'access', _67 => _67.dprMediaQuery, 'access', _68 => _68.removeEventListener, 'optionalCall', _69 => _69("change", this.dprChangeHandler)]);
     }
     const dpr = window.devicePixelRatio || 1;
     const query = window.matchMedia(`(resolution: ${dpr}dppx)`);
@@ -2800,7 +3081,7 @@ var Scene = (_class7 = class _Scene {
       this.resize(this.width, this.height);
       this.watchDevicePixelRatio();
     };
-    _optionalChain([query, 'access', _60 => _60.addEventListener, 'optionalCall', _61 => _61("change", handler)]);
+    _optionalChain([query, 'access', _70 => _70.addEventListener, 'optionalCall', _71 => _71("change", handler)]);
     this.dprMediaQuery = query;
     this.dprChangeHandler = handler;
   }
@@ -2820,7 +3101,7 @@ var Scene = (_class7 = class _Scene {
     if (typeof gl.addEventListener !== "function") return;
     this.glContextLostHandler = (e) => {
       e.preventDefault();
-      _optionalChain([this, 'access', _62 => _62.pointRenderer, 'optionalAccess', _63 => _63.destroy, 'call', _64 => _64()]);
+      _optionalChain([this, 'access', _72 => _72.pointRenderer, 'optionalAccess', _73 => _73.destroy, 'call', _74 => _74()]);
       this.pointRenderer = null;
     };
     this.glContextRestoredHandler = () => {
@@ -2850,26 +3131,26 @@ var Scene = (_class7 = class _Scene {
    * to the live DOM selection.
    */
   contentGridSelectionLine(el) {
-    const candidates = [_optionalChain([this, 'access', _65 => _65.contentSelectionAnchor, 'optionalAccess', _66 => _66.node])];
+    const candidates = [_optionalChain([this, 'access', _75 => _75.contentSelectionAnchor, 'optionalAccess', _76 => _76.node])];
     if (typeof window !== "undefined" && typeof window.getSelection === "function") {
       const selection = window.getSelection();
-      candidates.push(_optionalChain([selection, 'optionalAccess', _67 => _67.anchorNode]), _optionalChain([selection, 'optionalAccess', _68 => _68.focusNode]));
+      candidates.push(_optionalChain([selection, 'optionalAccess', _77 => _77.anchorNode]), _optionalChain([selection, 'optionalAccess', _78 => _78.focusNode]));
     }
     for (const candidate of candidates) {
       if (!candidate || !el.contains(candidate)) continue;
       let cursor = candidate;
       while (cursor && cursor.parentNode !== el) cursor = cursor.parentNode;
-      const lineIndex = _optionalChain([cursor, 'optionalAccess', _69 => _69.dataset, 'optionalAccess', _70 => _70.vectoGridLine]);
+      const lineIndex = _optionalChain([cursor, 'optionalAccess', _79 => _79.dataset, 'optionalAccess', _80 => _80.vectoGridLine]);
       if (lineIndex !== void 0) return Number(lineIndex);
     }
     return null;
   }
   releaseContentSelectionForRebuild(el) {
     const selection = typeof window !== "undefined" && typeof window.getSelection === "function" ? window.getSelection() : null;
-    const ownsSelection = this.contentSelectionAnchor && el.contains(this.contentSelectionAnchor.node) || (_optionalChain([selection, 'optionalAccess', _71 => _71.anchorNode]) ? el.contains(selection.anchorNode) : false) || (_optionalChain([selection, 'optionalAccess', _72 => _72.focusNode]) ? el.contains(selection.focusNode) : false);
+    const ownsSelection = this.contentSelectionAnchor && el.contains(this.contentSelectionAnchor.node) || (_optionalChain([selection, 'optionalAccess', _81 => _81.anchorNode]) ? el.contains(selection.anchorNode) : false) || (_optionalChain([selection, 'optionalAccess', _82 => _82.focusNode]) ? el.contains(selection.focusNode) : false);
     if (!ownsSelection) return;
     this.endContentSelectionDrag();
-    _optionalChain([selection, 'optionalAccess', _73 => _73.removeAllRanges, 'call', _74 => _74()]);
+    _optionalChain([selection, 'optionalAccess', _83 => _83.removeAllRanges, 'call', _84 => _84()]);
   }
   /**
    * Rebuild a content-projection element's DOM (`rebuild`) while preserving a
@@ -2915,7 +3196,7 @@ var Scene = (_class7 = class _Scene {
     if (!anchor || !focus) return;
     try {
       selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset);
-    } catch (e9) {
+    } catch (e14) {
     }
   }
   /**
@@ -2928,7 +3209,7 @@ var Scene = (_class7 = class _Scene {
   }
   /** Convert browser viewport coordinates into this Scene's logical coordinates. */
   clientToScene(clientX, clientY) {
-    const rect = _optionalChain([this, 'access', _75 => _75.canvas, 'access', _76 => _76.getBoundingClientRect, 'optionalCall', _77 => _77()]);
+    const rect = _optionalChain([this, 'access', _85 => _85.canvas, 'access', _86 => _86.getBoundingClientRect, 'optionalCall', _87 => _87()]);
     if (!rect) return { x: clientX, y: clientY };
     const cssWidth = rect.width || this.canvas.clientWidth || this.width;
     const cssHeight = rect.height || this.canvas.clientHeight || this.height;
@@ -2966,7 +3247,7 @@ var Scene = (_class7 = class _Scene {
       cancelAnimationFrame(calibrationFrame);
     }
     this.contentGridCalibrationFrames.delete(entityId);
-    _optionalChain([this, 'access', _78 => _78.contentGridCalibrationProbes, 'access', _79 => _79.get, 'call', _80 => _80(entityId), 'optionalAccess', _81 => _81.remove, 'call', _82 => _82()]);
+    _optionalChain([this, 'access', _88 => _88.contentGridCalibrationProbes, 'access', _89 => _89.get, 'call', _90 => _90(entityId), 'optionalAccess', _91 => _91.remove, 'call', _92 => _92()]);
     this.contentGridCalibrationProbes.delete(entityId);
     delete el.dataset.vectoGridCalibrationPending;
     delete el.dataset.vectoGridCalibration;
@@ -3120,12 +3401,12 @@ var Scene = (_class7 = class _Scene {
       this.canvasResizeObserver = null;
     }
     if (this.dprMediaQuery && this.dprChangeHandler) {
-      _optionalChain([this, 'access', _83 => _83.dprMediaQuery, 'access', _84 => _84.removeEventListener, 'optionalCall', _85 => _85("change", this.dprChangeHandler)]);
+      _optionalChain([this, 'access', _93 => _93.dprMediaQuery, 'access', _94 => _94.removeEventListener, 'optionalCall', _95 => _95("change", this.dprChangeHandler)]);
       this.dprMediaQuery = null;
       this.dprChangeHandler = null;
     }
     if (this.forcedColorsQuery && this.forcedColorsChangeHandler) {
-      _optionalChain([this, 'access', _86 => _86.forcedColorsQuery, 'access', _87 => _87.removeEventListener, 'optionalCall', _88 => _88("change", this.forcedColorsChangeHandler)]);
+      _optionalChain([this, 'access', _96 => _96.forcedColorsQuery, 'access', _97 => _97.removeEventListener, 'optionalCall', _98 => _98("change", this.forcedColorsChangeHandler)]);
       this.forcedColorsQuery = null;
       this.forcedColorsChangeHandler = null;
     }
@@ -3143,9 +3424,9 @@ var Scene = (_class7 = class _Scene {
       }
       this.pointerEventTarget = null;
     }
-    _optionalChain([this, 'access', _89 => _89.a11yRoot, 'optionalAccess', _90 => _90.remove, 'call', _91 => _91()]);
+    _optionalChain([this, 'access', _99 => _99.a11yRoot, 'optionalAccess', _100 => _100.remove, 'call', _101 => _101()]);
     this.focusSentinel = null;
-    _optionalChain([this, 'access', _92 => _92.portalRoot, 'optionalAccess', _93 => _93.remove, 'call', _94 => _94()]);
+    _optionalChain([this, 'access', _102 => _102.portalRoot, 'optionalAccess', _103 => _103.remove, 'call', _104 => _104()]);
     this.a11yElements.clear();
     for (const el of this.contentElements.values()) el.remove();
     this.contentElements.clear();
@@ -3168,10 +3449,10 @@ var Scene = (_class7 = class _Scene {
     }
     this.glContextLostHandler = null;
     this.glContextRestoredHandler = null;
-    _optionalChain([this, 'access', _95 => _95.pointRenderer, 'optionalAccess', _96 => _96.destroy, 'call', _97 => _97()]);
-    _optionalChain([this, 'access', _98 => _98.renderer, 'access', _99 => _99.dispose, 'optionalCall', _100 => _100()]);
-    _optionalChain([this, 'access', _101 => _101.glCanvas, 'optionalAccess', _102 => _102.remove, 'call', _103 => _103()]);
-    _optionalChain([this, 'access', _104 => _104.gpuCanvas, 'optionalAccess', _105 => _105.remove, 'call', _106 => _106()]);
+    _optionalChain([this, 'access', _105 => _105.pointRenderer, 'optionalAccess', _106 => _106.destroy, 'call', _107 => _107()]);
+    _optionalChain([this, 'access', _108 => _108.renderer, 'access', _109 => _109.dispose, 'optionalCall', _110 => _110()]);
+    _optionalChain([this, 'access', _111 => _111.glCanvas, 'optionalAccess', _112 => _112.remove, 'call', _113 => _113()]);
+    _optionalChain([this, 'access', _114 => _114.gpuCanvas, 'optionalAccess', _115 => _115.remove, 'call', _116 => _116()]);
     this.gpuCanvas = null;
     this.gpuContext = null;
     if (this.recoveryTimerId) {
@@ -3183,7 +3464,7 @@ var Scene = (_class7 = class _Scene {
       this.manager = null;
     }
     if (this.device) {
-      _optionalChain([this, 'access', _107 => _107.device, 'access', _108 => _108.destroy, 'optionalCall', _109 => _109()]);
+      _optionalChain([this, 'access', _117 => _117.device, 'access', _118 => _118.destroy, 'optionalCall', _119 => _119()]);
       this.device = null;
     }
   }
@@ -3479,7 +3760,7 @@ var Scene = (_class7 = class _Scene {
   shouldProjectA11y(node) {
     return node.interactive && (node.width > 0 || node.a11yFullViewport);
   }
-  syncA11y(node) {
+  syncA11y(node, container = null) {
     if (!this.a11yRoot) return;
     if (node.isDOMPortal) {
       return;
@@ -3489,6 +3770,7 @@ var Scene = (_class7 = class _Scene {
       return;
     }
     const nodeStart = this._phaseTiming ? performance.now() : 0;
+    let childContainer = container;
     if (this.shouldProjectA11y(node)) {
       let el = this.a11yElements.get(node.id);
       const attrs = node.getA11yAttributes();
@@ -3501,9 +3783,9 @@ var Scene = (_class7 = class _Scene {
             this.caretBlinkTimer = null;
           }
         }
-        if (el.parentNode === this.a11yRoot) {
+        if (el.parentNode) {
           this.preserveFocusOnRemoval(el);
-          this.a11yRoot.removeChild(el);
+          el.remove();
         }
         this.a11yElements.delete(node.id);
         el = void 0;
@@ -3615,7 +3897,7 @@ var Scene = (_class7 = class _Scene {
           el.addEventListener("compositionupdate", (e) => {
             const data = _nullishCoalesce(e.data, () => ( ""));
             composition = {
-              start: _nullishCoalesce(_optionalChain([composition, 'optionalAccess', _110 => _110.start]), () => ( 0)),
+              start: _nullishCoalesce(_optionalChain([composition, 'optionalAccess', _120 => _120.start]), () => ( 0)),
               length: data.length
             };
             forward();
@@ -3688,7 +3970,7 @@ var Scene = (_class7 = class _Scene {
         this.syncOptionalAttribute(
           el,
           "href",
-          attrs.href === void 0 ? void 0 : _chunkLHONR3GOjs.sanitizeUrl.call(void 0, attrs.href)
+          attrs.href === void 0 ? void 0 : _chunkKEBYJVD6js.sanitizeUrl.call(void 0, attrs.href)
         );
         this.syncOptionalAttribute(el, "target", attrs.target);
       }
@@ -3811,6 +4093,7 @@ var Scene = (_class7 = class _Scene {
         if (el.style.boxSizing !== "border-box") el.style.boxSizing = "border-box";
         if (el instanceof HTMLTextAreaElement) el.style.resize = "none";
       }
+      const nestedIn = container && attrs.role && container.owned.has(attrs.role) ? container : null;
       if (node.a11yFullViewport) {
         el.style.left = "0px";
         el.style.top = "0px";
@@ -3821,11 +4104,36 @@ var Scene = (_class7 = class _Scene {
       } else {
         const worldTf = node.getWorldTransform();
         const { a, b, c, d, e, f } = worldTf;
-        el.style.left = `${e + node.a11yOffsetX}px`;
-        el.style.top = `${f + node.a11yOffsetY}px`;
+        const originX = e + node.a11yOffsetX;
+        const originY = f + node.a11yOffsetY;
+        const parentEl = nestedIn && nestedIn.el !== el && nestedIn.el.isConnected ? nestedIn.el : this.a11yRoot;
+        if (el.parentNode !== parentEl) {
+          parentEl.appendChild(el);
+          this.a11yNeedsReorder = true;
+        }
+        if (parentEl === this.a11yRoot) {
+          el.style.left = `${originX}px`;
+          el.style.top = `${originY}px`;
+          el.style.transform = `matrix(${a}, ${b}, ${c}, ${d}, 0, 0)`;
+        } else {
+          const box = rebaseChildBox(
+            nestedIn.transform,
+            nestedIn.originX,
+            nestedIn.originY,
+            worldTf,
+            originX,
+            originY
+          );
+          el.style.left = `${box.left}px`;
+          el.style.top = `${box.top}px`;
+          el.style.transform = box.matrix;
+        }
         el.style.width = `${node.width}px`;
         el.style.height = `${node.height}px`;
-        el.style.transform = `matrix(${a}, ${b}, ${c}, ${d}, 0, 0)`;
+        const owned = attrs.role ? A11Y_REQUIRED_OWNED.get(attrs.role) : void 0;
+        if (owned) {
+          childContainer = { el, owned, transform: worldTf, originX, originY };
+        }
         const visible = this.projectionBoxVisible(node, worldTf, 0);
         const display = visible ? "" : "none";
         if (el.style.display !== display) el.style.display = display;
@@ -3839,9 +4147,9 @@ var Scene = (_class7 = class _Scene {
     } else {
       this.syncContentProjection(node);
     }
-    for (const child of node.children) this.syncA11y(child);
+    for (const child of node.children) this.syncA11y(child, childContainer);
     if (node === this.root) {
-      for (const overlay of this.overlayRoot.children) this.syncA11y(overlay);
+      for (const overlay of this.overlayRoot.children) this.syncA11y(overlay, null);
     }
   }
   /**
@@ -4068,9 +4376,9 @@ var Scene = (_class7 = class _Scene {
       for (let lineIndex = 0; lineIndex < grid.lines.length; lineIndex++) {
         const gridLine = grid.lines[lineIndex];
         const projectedLine = projectionLines[lineIndex];
-        const lineHeight = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _111 => _111.lineHeight]), () => ( grid.lineHeight));
-        const baseline = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _112 => _112.baseline]), () => ( grid.baseline));
-        const lineFont = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _113 => _113.font]), () => ( grid.font));
+        const lineHeight = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _121 => _121.lineHeight]), () => ( grid.lineHeight));
+        const baseline = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _122 => _122.baseline]), () => ( grid.baseline));
+        const lineFont = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _123 => _123.font]), () => ( grid.font));
         const lineSignature = contentGridLineSignature(
           grid,
           gridLine,
@@ -4090,8 +4398,8 @@ var Scene = (_class7 = class _Scene {
         lineElement.dir = "ltr";
         lineElement.dataset.vectoGridLine = `${lineIndex}`;
         lineElement.style.position = "absolute";
-        lineElement.style.left = `${_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _114 => _114.x]), () => ( 0))}px`;
-        lineElement.style.top = `${(_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _115 => _115.y]), () => ( lineIndex * grid.lineHeight))) + baseline - _text.cssLineBoxBaseline.call(void 0, lineFont, lineHeight)}px`;
+        lineElement.style.left = `${_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _124 => _124.x]), () => ( 0))}px`;
+        lineElement.style.top = `${(_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _125 => _125.y]), () => ( lineIndex * grid.lineHeight))) + baseline - _text.cssLineBoxBaseline.call(void 0, lineFont, lineHeight)}px`;
         lineElement.style.width = `${gridLine.width}px`;
         lineElement.style.height = `${lineHeight}px`;
         lineElement.style.whiteSpace = "pre";
@@ -4161,7 +4469,7 @@ var Scene = (_class7 = class _Scene {
         if (selectionLine !== null && selectionLine >= grid.lines.length) {
           rebuiltSelectionLine = true;
         }
-        _optionalChain([el, 'access', _116 => _116.lastElementChild, 'optionalAccess', _117 => _117.remove, 'call', _118 => _118()]);
+        _optionalChain([el, 'access', _126 => _126.lastElementChild, 'optionalAccess', _127 => _127.remove, 'call', _128 => _128()]);
       }
       if (rebuiltSelectionLine) this.releaseContentSelectionForRebuild(el);
       el.dataset.vectoProjectionLines = signature;
@@ -4225,7 +4533,7 @@ var Scene = (_class7 = class _Scene {
     if (previous !== void 0 && typeof cancelAnimationFrame === "function") {
       cancelAnimationFrame(previous);
     }
-    _optionalChain([this, 'access', _119 => _119.contentGridCalibrationProbes, 'access', _120 => _120.get, 'call', _121 => _121(entityId), 'optionalAccess', _122 => _122.remove, 'call', _123 => _123()]);
+    _optionalChain([this, 'access', _129 => _129.contentGridCalibrationProbes, 'access', _130 => _130.get, 'call', _131 => _131(entityId), 'optionalAccess', _132 => _132.remove, 'call', _133 => _133()]);
     this.contentGridCalibrationProbes.delete(entityId);
     const calibrationStart = typeof performance !== "undefined" ? performance.now() : 0;
     const probe = document.createElement("div");
@@ -4259,7 +4567,7 @@ var Scene = (_class7 = class _Scene {
         target.dataset.vectoGridCalib = generation;
         continue;
       }
-      const sourceText = _nullishCoalesce(_optionalChain([target, 'access', _124 => _124.textContent, 'optionalAccess', _125 => _125.slice, 'call', _126 => _126(0, sourceLength)]), () => ( ""));
+      const sourceText = _nullishCoalesce(_optionalChain([target, 'access', _134 => _134.textContent, 'optionalAccess', _135 => _135.slice, 'call', _136 => _136(0, sourceLength)]), () => ( ""));
       if (!sourceText) {
         target.dataset.vectoGridCalib = generation;
         continue;
@@ -4399,9 +4707,9 @@ var Scene = (_class7 = class _Scene {
             this.caretBlinkTimer = null;
           }
         }
-        if (el.parentNode === this.a11yRoot) {
+        if (el.parentNode) {
           this.preserveFocusOnRemoval(el);
-          this.a11yRoot.removeChild(el);
+          el.remove();
         }
         this.a11yElements.delete(id);
       }
@@ -4414,23 +4722,39 @@ var Scene = (_class7 = class _Scene {
     const fullLen = this.fullViewportElements.length;
     const normalLen = this.normalElements.length;
     const totalLen = fullLen + normalLen;
+    this.a11yOrderCursors.clear();
     for (let i = 0; i < totalLen; i++) {
       const expected = i < fullLen ? this.fullViewportElements[i] : this.normalElements[i - fullLen];
-      const current = this.a11yRoot.childNodes[i];
+      const parent = expected.parentNode;
+      if (!parent) continue;
+      const at = _nullishCoalesce(this.a11yOrderCursors.get(parent), () => ( 0));
+      this.a11yOrderCursors.set(parent, at + 1);
+      const current = parent.childNodes[at];
       if (current !== expected) {
-        this.a11yRoot.insertBefore(expected, current || null);
+        parent.insertBefore(expected, current || null);
       }
     }
     this.a11yNeedsReorder = false;
   }
   /**
    * Reorder `normalElements` (in place) into visual reading order using the
-   * world positions `syncA11y` already wrote to each element's inline style
+   * positions `syncA11y` already wrote to each element's inline style
    * (`top`/`left`/`height`). Elements are grouped into rows top-to-bottom (an
    * element belongs to the current row while its top is above the row's
    * running bottom edge), then sorted within a row by `left` — ascending for
    * `'ltr'`, descending for `'rtl'`. The sort is stable, so entities at the
    * same position keep their scene-graph (collection) order as a tiebreak.
+   *
+   * Those inline values are world coordinates for a top-level mirror but
+   * PARENT-RELATIVE for a nested one, so this list mixes coordinate spaces.
+   * That is sound because the result is only ever applied per DOM parent
+   * ({@link enforceA11yDomOrder} advances a cursor per parent), and all of one
+   * parent's children share one space: a `grid`'s rows are all grid-relative, a
+   * `row`'s cells all row-relative. Comparisons ACROSS spaces do happen while
+   * banding, but they only affect the relative order of elements in different
+   * parents, which no `insertBefore` ever acts on. Normalizing everything back
+   * to world coordinates here would cost a transform per element per frame to
+   * change nothing observable.
    */
   sortNormalElementsVisually() {
     const els = this.normalElements;
@@ -4470,12 +4794,12 @@ var Scene = (_class7 = class _Scene {
   syncOverlayGeometry() {
     const parent = this.canvas.parentElement;
     if (!parent) return;
-    const canvasRect = _optionalChain([this, 'access', _127 => _127.canvas, 'access', _128 => _128.getBoundingClientRect, 'optionalCall', _129 => _129()]);
-    const parentRect = _optionalChain([parent, 'access', _130 => _130.getBoundingClientRect, 'optionalCall', _131 => _131()]);
-    const cssWidth = _optionalChain([canvasRect, 'optionalAccess', _132 => _132.width]) || this.canvas.clientWidth || this.width;
-    const cssHeight = _optionalChain([canvasRect, 'optionalAccess', _133 => _133.height]) || this.canvas.clientHeight || this.height;
-    const left = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _134 => _134.left]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _135 => _135.left]), () => ( 0))) - (parent.clientLeft || 0) + parent.scrollLeft;
-    const top = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _136 => _136.top]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _137 => _137.top]), () => ( 0))) - (parent.clientTop || 0) + parent.scrollTop;
+    const canvasRect = _optionalChain([this, 'access', _137 => _137.canvas, 'access', _138 => _138.getBoundingClientRect, 'optionalCall', _139 => _139()]);
+    const parentRect = _optionalChain([parent, 'access', _140 => _140.getBoundingClientRect, 'optionalCall', _141 => _141()]);
+    const cssWidth = _optionalChain([canvasRect, 'optionalAccess', _142 => _142.width]) || this.canvas.clientWidth || this.width;
+    const cssHeight = _optionalChain([canvasRect, 'optionalAccess', _143 => _143.height]) || this.canvas.clientHeight || this.height;
+    const left = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _144 => _144.left]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _145 => _145.left]), () => ( 0))) - (parent.clientLeft || 0) + parent.scrollLeft;
+    const top = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _146 => _146.top]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _147 => _147.top]), () => ( 0))) - (parent.clientTop || 0) + parent.scrollTop;
     const scaleX = this.width > 0 ? cssWidth / this.width : 1;
     const scaleY = this.height > 0 ? cssHeight / this.height : 1;
     const prev = this._overlayGeometry;
@@ -4614,7 +4938,7 @@ var Scene = (_class7 = class _Scene {
    * (and {@link respectReducedMotion} is on). `0` means uncapped.
    */
   effectiveMaxFPS() {
-    const reduced = this.respectReducedMotion && !!_optionalChain([this, 'access', _138 => _138.reducedMotionQuery, 'optionalAccess', _139 => _139.matches]);
+    const reduced = this.respectReducedMotion && !!_optionalChain([this, 'access', _148 => _148.reducedMotionQuery, 'optionalAccess', _149 => _149.matches]);
     if (reduced)
       return this.maxFPS > 0 ? Math.min(this.maxFPS, REDUCED_MOTION_FPS) : REDUCED_MOTION_FPS;
     return this.maxFPS;
@@ -4666,9 +4990,11 @@ var Scene = (_class7 = class _Scene {
     if ((hasInteractive || this.a11yElements.size > 0 || wantsContentSync) && (shouldSyncInterval || this.a11yPendingSyncAfterAnimation)) {
       this.lastA11ySync = time;
       if (hasInteractive || wantsContentSync) {
+        const userTiming = this._userTiming ? beginVectoUserTiming(VECTO_USER_TIMING.scene.a11ySync) : null;
         const t0 = this._phaseTiming ? performance.now() : 0;
         this.syncA11y(this.root);
         if (this._phaseTiming) this._recordPhase("a11ySync", performance.now() - t0);
+        if (userTiming) endVectoUserTiming(userTiming);
       }
       const t1 = this._phaseTiming ? performance.now() : 0;
       this.enforceA11yDomOrder();
@@ -4682,12 +5008,32 @@ var Scene = (_class7 = class _Scene {
   /**
    * Render the entire scene graph onto the specified renderer.
    *
+   * Main-frame causal order is a correctness contract:
+   *
+   * 1. Browser/input callbacks finish before the scheduled frame begins.
+   * 2. Batched property drivers and particle simulation advance.
+   * 3. Entity `update()` hooks run.
+   * 4. Transform inputs are gathered and world matrices are composed.
+   * 5. Updated world bounds are tested for culling.
+   * 6. Visible entities paint in scene-graph order.
+   * 7. Canvas/GPU batches flush and retained renderers present.
+   * 8. The rAF loop synchronizes content and accessibility projections after
+   *    this method returns.
+   *
+   * The causal order is fixed; physical walks may stay fused. The JavaScript
+   * transform path interleaves update → compose → cull → paint per node in
+   * pre-order. The WASM path updates the whole tree first, then gathers and
+   * composes it in one store pass before the same cull/paint walk. Both must
+   * expose an update's transform mutation in that same rendered frame.
+   * Secondary renderers are read-only snapshots: they skip simulation and
+   * updates, then compose/cull/paint/flush the current state.
+   *
    * @param renderer - The renderer instance to draw to.
    * @param dt - Delta time in milliseconds (default 0).
    * @param time - Current absolute time in milliseconds (default 0).
    */
   render(renderer, dt = 0, time = 0) {
-    if (_optionalChain([renderer, 'access', _140 => _140.isContextLost, 'optionalCall', _141 => _141()])) return;
+    if (_optionalChain([renderer, 'access', _150 => _150.isContextLost, 'optionalCall', _151 => _151()])) return;
     const isMainRenderer = renderer === this.renderer;
     if (isMainRenderer && this.a11yRoot && this.canvas.parentElement) {
       const parentStyle = this.canvas.parentElement.style;
@@ -4706,6 +5052,10 @@ var Scene = (_class7 = class _Scene {
     const computeEntities = this._computeEntitiesFor(this._structureVersion);
     if (computeEntities.length > 0) {
       const isMainRenderPath = renderer === this.renderer;
+      if (isMainRenderPath) {
+        this._particleReason = this._particleWasm ? "active" : "not-installed";
+        this._particlePath = this._particleWasm ? "wasm" : "js";
+      }
       if (isMainRenderPath && !this.device && !this.webgpuDisabled && !this.initializingWebGPU && !this.deviceLost) {
         this.initializingWebGPU = true;
         this.initWebGPUContext(computeEntities).then((newDevice) => {
@@ -4781,6 +5131,8 @@ var Scene = (_class7 = class _Scene {
           }
           this.device.queue.submit([commandEncoder.finish()]);
           if (this.gpuContext) this.gpuHasContent = true;
+          this._particleReason = "active";
+          this._particlePath = "webgpu";
         } catch (e) {
           console.error("WebGPU frame execution failed. Falling back.", e);
           this.deviceLost = true;
@@ -4802,18 +5154,30 @@ var Scene = (_class7 = class _Scene {
             }
           }
           if (this._particleWasm) {
-            entity.stepWithBackend(this._particleWasm, dt / 1e3, mx, my, this.width, this.height);
+            if (!entity.stepWithBackend(
+              this._particleWasm,
+              dt / 1e3,
+              mx,
+              my,
+              this.width,
+              this.height
+            )) {
+              this._particleReason = "rejected";
+              this._particlePath = "js";
+            }
           } else {
             entity.updateCPU(dt / 1e3, mx, my, this.width, this.height);
           }
         }
       }
     } else if (isMainRenderer) {
+      this._particleReason = "not-applicable";
+      this._particlePath = "none";
       this.clearGPUCanvasIfStale();
     }
     renderer.clear();
     if (isMainRenderer) {
-      _optionalChain([this, 'access', _142 => _142.pointRenderer, 'optionalAccess', _143 => _143.begin, 'call', _144 => _144()]);
+      _optionalChain([this, 'access', _152 => _152.pointRenderer, 'optionalAccess', _153 => _153.begin, 'call', _154 => _154()]);
     }
     const vw = this.width;
     const vh = this.height;
@@ -4837,6 +5201,9 @@ var Scene = (_class7 = class _Scene {
       }
     };
     const wasmMain = isMainRenderer && this._wasm !== null && this._transformBackend === "wasm";
+    if (isMainRenderer) {
+      this._transformReason = wasmMain ? "active" : "not-installed";
+    }
     if (wasmMain) {
       const updateWalk = (node) => {
         runUpdate(node);
@@ -4846,10 +5213,13 @@ var Scene = (_class7 = class _Scene {
       updateWalk(this.root);
       for (const overlay of this.overlayRoot.children) updateWalk(overlay);
     }
+    const transformTiming = this._userTiming ? beginVectoUserTiming(VECTO_USER_TIMING.scene.transform) : null;
     const wasmT0 = this._phaseTiming ? performance.now() : 0;
     const wasmWorld = wasmMain ? this._syncWasmStore() : null;
     if (this._phaseTiming) this._recordPhase("transform", performance.now() - wasmT0);
+    if (transformTiming) endVectoUserTiming(transformTiming);
     const wasmSlotEntity = this._slotEntity;
+    let userEntityPaintMs = 0;
     const renderNode = (node, pa, pb, pc, pd, pe, pf, parentOpacity) => {
       if (isMainRenderer && !wasmMain) {
         runUpdate(node);
@@ -4978,10 +5348,15 @@ var Scene = (_class7 = class _Scene {
             );
           }
         } else {
-          if (this._phaseTiming) {
+          if (this._userTiming || this._phaseTiming) {
             const t0 = performance.now();
-            node.render(renderer);
-            this._recordPhase("entityPaint", performance.now() - t0);
+            try {
+              node.render(renderer);
+            } finally {
+              const elapsed = performance.now() - t0;
+              if (this._userTiming) userEntityPaintMs += elapsed;
+              if (this._phaseTiming) this._recordPhase("entityPaint", elapsed);
+            }
           } else {
             node.render(renderer);
           }
@@ -4996,24 +5371,31 @@ var Scene = (_class7 = class _Scene {
       renderer.flush();
       renderer.restore();
     };
+    const drawTiming = this._userTiming ? beginVectoUserTiming(VECTO_USER_TIMING.scene.drawWalk) : null;
     const drawT0 = this._phaseTiming ? performance.now() : 0;
     renderNode(this.root, 1, 0, 0, 1, 0, 0, 1);
     for (const overlay of this.overlayRoot.children) {
       renderNode(overlay, 1, 0, 0, 1, 0, 0, 1);
     }
     if (this._phaseTiming) this._recordPhase("drawWalk", performance.now() - drawT0);
+    if (drawTiming) endVectoUserTiming(drawTiming);
+    if (this._userTiming) {
+      measureVectoUserTiming(VECTO_USER_TIMING.scene.entityPaint, userEntityPaintMs);
+    }
     if (isMainRenderer) {
       this.frameHadAnimation = walkHadAnimation;
       this.frameHadInteractive = walkHadInteractive;
       this.reconcilePortals();
     }
+    const flushTiming = this._userTiming ? beginVectoUserTiming(VECTO_USER_TIMING.scene.flush) : null;
     const flushT0 = this._phaseTiming ? performance.now() : 0;
     renderer.flush();
     if (isMainRenderer) {
-      _optionalChain([this, 'access', _145 => _145.pointRenderer, 'optionalAccess', _146 => _146.flush, 'call', _147 => _147()]);
+      _optionalChain([this, 'access', _155 => _155.pointRenderer, 'optionalAccess', _156 => _156.flush, 'call', _157 => _157()]);
     }
-    _optionalChain([renderer, 'access', _148 => _148.present, 'optionalCall', _149 => _149()]);
+    _optionalChain([renderer, 'access', _158 => _158.present, 'optionalCall', _159 => _159()]);
     if (this._phaseTiming) this._recordPhase("flush", performance.now() - flushT0);
+    if (flushTiming) endVectoUserTiming(flushTiming);
     if (this._devActive) {
       this._devFrameCount++;
       this._devRunChecks();
@@ -5023,7 +5405,7 @@ var Scene = (_class7 = class _Scene {
    * Export the current scene state to a lightweight, flat SVG XML string.
    */
   toSVG() {
-    const renderer = new (0, _chunkLHONR3GOjs.SVGRenderer)(this.width, this.height);
+    const renderer = new (0, _chunkKEBYJVD6js.SVGRenderer)(this.width, this.height);
     this.render(renderer, 0, 0);
     return renderer.toXMLString();
   }
@@ -5105,7 +5487,7 @@ var Scene = (_class7 = class _Scene {
       });
       pass.end();
       this.device.queue.submit([encoder.finish()]);
-    } catch (e10) {
+    } catch (e15) {
     }
     this.gpuHasContent = false;
   }
@@ -5292,8 +5674,8 @@ function pointInBounds(b, x, y) {
 function contentGridLineSignature(grid, line, projected, lineHeight, baseline, font, isFirstLine) {
   const parts = [
     // Line box: position, size, and the font that resolves its baseline.
-    `${_nullishCoalesce(_optionalChain([projected, 'optionalAccess', _150 => _150.x]), () => ( 0))}`,
-    `${_nullishCoalesce(_optionalChain([projected, 'optionalAccess', _151 => _151.y]), () => ( ""))}`,
+    `${_nullishCoalesce(_optionalChain([projected, 'optionalAccess', _160 => _160.x]), () => ( 0))}`,
+    `${_nullishCoalesce(_optionalChain([projected, 'optionalAccess', _161 => _161.y]), () => ( ""))}`,
     `${lineHeight}`,
     `${baseline}`,
     font,
@@ -5340,15 +5722,15 @@ var TextEntity = (_class8 = class extends _chunkAGP4VLF4js.Entity {
   
   
   
-  __init140() {this.nodes = []}
+  __init149() {this.nodes = []}
   
-  __init141() {this.fillStyle = "#94a3b8"}
-  __init142() {this.strokeStyle = null}
-  __init143() {this.hoveredFillStyle = "#ffffff"}
-  __init144() {this.lineWidth = 1}
-  __init145() {this.isHovered = false}
+  __init150() {this.fillStyle = "#94a3b8"}
+  __init151() {this.strokeStyle = null}
+  __init152() {this.hoveredFillStyle = "#ffffff"}
+  __init153() {this.lineWidth = 1}
+  __init154() {this.isHovered = false}
   constructor(text, atlas, maxWidth, fontSize = 24) {
-    super();_class8.prototype.__init140.call(this);_class8.prototype.__init141.call(this);_class8.prototype.__init142.call(this);_class8.prototype.__init143.call(this);_class8.prototype.__init144.call(this);_class8.prototype.__init145.call(this);;
+    super();_class8.prototype.__init149.call(this);_class8.prototype.__init150.call(this);_class8.prototype.__init151.call(this);_class8.prototype.__init152.call(this);_class8.prototype.__init153.call(this);_class8.prototype.__init154.call(this);;
     this.text = text;
     this.atlas = atlas;
     this.fontSize = fontSize;
@@ -5463,15 +5845,15 @@ var TextEntity = (_class8 = class extends _chunkAGP4VLF4js.Entity {
 // src/components/GridTextEntity.ts
 var GridTextEntity = (_class9 = class extends _chunkAGP4VLF4js.Entity {
   
-  __init146() {this.fillStyle = "#ffffff"}
-  __init147() {this.grid = []}
+  __init155() {this.fillStyle = "#ffffff"}
+  __init156() {this.grid = []}
   // Array of rows
-  __init148() {this.cols = 0}
-  __init149() {this.rows = 0}
+  __init157() {this.cols = 0}
+  __init158() {this.rows = 0}
   
   
   constructor(_atlas, fontSize = 10) {
-    super();_class9.prototype.__init146.call(this);_class9.prototype.__init147.call(this);_class9.prototype.__init148.call(this);_class9.prototype.__init149.call(this);;
+    super();_class9.prototype.__init155.call(this);_class9.prototype.__init156.call(this);_class9.prototype.__init157.call(this);_class9.prototype.__init158.call(this);;
     this.fontSize = fontSize;
     this.charWidth = fontSize * 1;
     this.charHeight = fontSize * 1.1;
@@ -5480,7 +5862,7 @@ var GridTextEntity = (_class9 = class extends _chunkAGP4VLF4js.Entity {
   updateGrid(ascii) {
     this.grid = ascii;
     this.rows = ascii.length;
-    this.cols = _optionalChain([ascii, 'access', _152 => _152[0], 'optionalAccess', _153 => _153.length]) || 0;
+    this.cols = _optionalChain([ascii, 'access', _162 => _162[0], 'optionalAccess', _163 => _163.length]) || 0;
   }
   isPointInside(_globalX, _globalY) {
     return false;
@@ -5563,23 +5945,23 @@ var SplineEntity = (_class10 = class extends _chunkAGP4VLF4js.Entity {
   
   
   
-  __init150() {this.offscreen = null}
-  __init151() {this.baked = false}
+  __init159() {this.offscreen = null}
+  __init160() {this.baked = false}
   /** Logical (CSS-pixel) size of the baked bitmap — the blit destination size. */
-  __init152() {this.bakedWidth = 0}
-  __init153() {this.bakedHeight = 0}
+  __init161() {this.bakedWidth = 0}
+  __init162() {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. */
-  __init154() {this.polylines = null}
+  __init163() {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`.
    */
-  __init155() {this.showBounds = false}
+  __init164() {this.showBounds = false}
   constructor(doc, opts = {}) {
-    super();_class10.prototype.__init150.call(this);_class10.prototype.__init151.call(this);_class10.prototype.__init152.call(this);_class10.prototype.__init153.call(this);_class10.prototype.__init154.call(this);_class10.prototype.__init155.call(this);;
+    super();_class10.prototype.__init159.call(this);_class10.prototype.__init160.call(this);_class10.prototype.__init161.call(this);_class10.prototype.__init162.call(this);_class10.prototype.__init163.call(this);_class10.prototype.__init164.call(this);;
     this.doc = doc;
     this.lineWidth = _nullishCoalesce(opts.lineWidth, () => ( 2));
     this.cache = _nullishCoalesce(opts.cache, () => ( true));
@@ -5590,7 +5972,7 @@ var SplineEntity = (_class10 = class extends _chunkAGP4VLF4js.Entity {
     this.width = this.bounds.width;
     this.height = this.bounds.height;
     const isGradient = (c) => c !== null && !Array.isArray(c);
-    this.containsGradient = (_nullishCoalesce(_optionalChain([this, 'access', _154 => _154.doc, 'access', _155 => _155.equations, 'optionalAccess', _156 => _156.some, 'call', _157 => _157((eq) => isGradient(eq.color_rgb))]), () => ( false))) || (_nullishCoalesce(_optionalChain([this, 'access', _158 => _158.doc, 'access', _159 => _159.paths, 'optionalAccess', _160 => _160.some, 'call', _161 => _161((p) => isGradient(p.color_rgb))]), () => ( false)));
+    this.containsGradient = (_nullishCoalesce(_optionalChain([this, 'access', _164 => _164.doc, 'access', _165 => _165.equations, 'optionalAccess', _166 => _166.some, 'call', _167 => _167((eq) => isGradient(eq.color_rgb))]), () => ( false))) || (_nullishCoalesce(_optionalChain([this, 'access', _168 => _168.doc, 'access', _169 => _169.paths, 'optionalAccess', _170 => _170.some, 'call', _171 => _171((p) => isGradient(p.color_rgb))]), () => ( false)));
     this.interactive = true;
   }
   computeBounds() {
@@ -5960,19 +6342,19 @@ var _math = require('@vectojs/math'); _createStarExport(_math);
 // src/tree/DOMPortalEntity.ts
 var DOMPortalEntity = (_class11 = class extends _chunkAGP4VLF4js.Entity {
   
-  __init156() {this.isDOMPortal = true}
-  __init157() {this.domListeners = []}
-  __init158() {this.resizeObserver = null}
-  __init159() {this.domBound = false}
-  __init160() {this.cachedWidth = 100}
-  __init161() {this.cachedHeight = 100}
-  __init162() {this.lastWidth = ""}
-  __init163() {this.lastHeight = ""}
-  __init164() {this.lastTransform = ""}
-  __init165() {this.lastZIndex = ""}
-  __init166() {this.lastOpacity = ""}
+  __init165() {this.isDOMPortal = true}
+  __init166() {this.domListeners = []}
+  __init167() {this.resizeObserver = null}
+  __init168() {this.domBound = false}
+  __init169() {this.cachedWidth = 100}
+  __init170() {this.cachedHeight = 100}
+  __init171() {this.lastWidth = ""}
+  __init172() {this.lastHeight = ""}
+  __init173() {this.lastTransform = ""}
+  __init174() {this.lastZIndex = ""}
+  __init175() {this.lastOpacity = ""}
   constructor(domElement, width, height, id) {
-    super(id);_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);_class11.prototype.__init161.call(this);_class11.prototype.__init162.call(this);_class11.prototype.__init163.call(this);_class11.prototype.__init164.call(this);_class11.prototype.__init165.call(this);_class11.prototype.__init166.call(this);;
+    super(id);_class11.prototype.__init165.call(this);_class11.prototype.__init166.call(this);_class11.prototype.__init167.call(this);_class11.prototype.__init168.call(this);_class11.prototype.__init169.call(this);_class11.prototype.__init170.call(this);_class11.prototype.__init171.call(this);_class11.prototype.__init172.call(this);_class11.prototype.__init173.call(this);_class11.prototype.__init174.call(this);_class11.prototype.__init175.call(this);;
     this.domElement = domElement;
     this.width = _nullishCoalesce(width, () => ( 0));
     this.height = _nullishCoalesce(height, () => ( 0));
@@ -6084,8 +6466,12 @@ var DOMPortalEntity = (_class11 = class extends _chunkAGP4VLF4js.Entity {
 }, _class11);
 
 // src/index.ts
-Scene.registerWebGLPointRendererCreator(_chunkLHONR3GOjs.createWebGLPointRenderer);
-Scene.registerWebGPUParticleSystemManager(_chunkLHONR3GOjs.WebGPUParticleSystemManager);
+Scene.registerWebGLPointRendererCreator(_chunkKEBYJVD6js.createWebGLPointRenderer);
+Scene.registerWebGPUParticleSystemManager(_chunkKEBYJVD6js.WebGPUParticleSystemManager);
+
+
+
+
 
 
 
@@ -6121,4 +6507,4 @@ Scene.registerWebGPUParticleSystemManager(_chunkLHONR3GOjs.WebGPUParticleSystemM
 
 
 
-exports.CanvasRenderer = _chunkLHONR3GOjs.CanvasRenderer; exports.Circle = Circle; exports.ComputeParticleEntity = ComputeParticleEntity; exports.DOMPortalEntity = DOMPortalEntity; exports.Entity = _chunkAGP4VLF4js.Entity; exports.GlyphRasterAtlas = _chunkLHONR3GOjs.GlyphRasterAtlas; exports.GridTextEntity = GridTextEntity; exports.Group = Group; exports.MSDFTextEntity = _chunkAGP4VLF4js.MSDFTextEntity; exports.PARTICLE_OFFSET_LIFE = PARTICLE_OFFSET_LIFE; exports.PARTICLE_OFFSET_ORIGIN_X = PARTICLE_OFFSET_ORIGIN_X; exports.PARTICLE_OFFSET_ORIGIN_Y = PARTICLE_OFFSET_ORIGIN_Y; exports.PARTICLE_OFFSET_POSITION_X = PARTICLE_OFFSET_POSITION_X; exports.PARTICLE_OFFSET_POSITION_Y = PARTICLE_OFFSET_POSITION_Y; exports.PARTICLE_OFFSET_SIZE = PARTICLE_OFFSET_SIZE; exports.PARTICLE_OFFSET_VELOCITY_X = PARTICLE_OFFSET_VELOCITY_X; exports.PARTICLE_OFFSET_VELOCITY_Y = PARTICLE_OFFSET_VELOCITY_Y; exports.PARTICLE_STRIDE_FLOATS = PARTICLE_STRIDE_FLOATS; exports.REDUCED_MOTION_FPS = REDUCED_MOTION_FPS; exports.Rect = Rect; exports.SVGEntity = _chunkAGP4VLF4js.SVGEntity; exports.SVGRenderer = _chunkLHONR3GOjs.SVGRenderer; exports.Scene = Scene; exports.SplineEntity = SplineEntity; exports.TextEntity = TextEntity; exports.TextRasterCache = _chunkLHONR3GOjs.TextRasterCache; exports.VectoJSEvent = _chunkAGP4VLF4js.VectoJSEvent; exports.WebGPUParticleSystemManager = _chunkLHONR3GOjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkLHONR3GOjs.createWebGLPointRenderer; exports.isSafeUrl = _chunkLHONR3GOjs.isSafeUrl; exports.loadSpline = loadSpline; exports.parseColorToRGBA = _chunkLHONR3GOjs.parseColorToRGBA; exports.polySegmentToBezier = polySegmentToBezier; exports.sanitizeUrl = _chunkLHONR3GOjs.sanitizeUrl;
+exports.CanvasRenderer = _chunkKEBYJVD6js.CanvasRenderer; exports.Circle = Circle; exports.ComputeParticleEntity = ComputeParticleEntity; exports.DOMPortalEntity = DOMPortalEntity; exports.Entity = _chunkAGP4VLF4js.Entity; exports.GlyphRasterAtlas = _chunkKEBYJVD6js.GlyphRasterAtlas; exports.GridTextEntity = GridTextEntity; exports.Group = Group; exports.MSDFTextEntity = _chunkAGP4VLF4js.MSDFTextEntity; exports.PARTICLE_OFFSET_LIFE = PARTICLE_OFFSET_LIFE; exports.PARTICLE_OFFSET_ORIGIN_X = PARTICLE_OFFSET_ORIGIN_X; exports.PARTICLE_OFFSET_ORIGIN_Y = PARTICLE_OFFSET_ORIGIN_Y; exports.PARTICLE_OFFSET_POSITION_X = PARTICLE_OFFSET_POSITION_X; exports.PARTICLE_OFFSET_POSITION_Y = PARTICLE_OFFSET_POSITION_Y; exports.PARTICLE_OFFSET_SIZE = PARTICLE_OFFSET_SIZE; exports.PARTICLE_OFFSET_VELOCITY_X = PARTICLE_OFFSET_VELOCITY_X; exports.PARTICLE_OFFSET_VELOCITY_Y = PARTICLE_OFFSET_VELOCITY_Y; exports.PARTICLE_STRIDE_FLOATS = PARTICLE_STRIDE_FLOATS; exports.REDUCED_MOTION_FPS = REDUCED_MOTION_FPS; exports.Rect = Rect; exports.SVGEntity = _chunkAGP4VLF4js.SVGEntity; exports.SVGRenderer = _chunkKEBYJVD6js.SVGRenderer; exports.Scene = Scene; exports.SplineEntity = SplineEntity; exports.TextEntity = TextEntity; exports.TextRasterCache = _chunkKEBYJVD6js.TextRasterCache; exports.VECTO_USER_TIMING = VECTO_USER_TIMING; exports.VectoJSEvent = _chunkAGP4VLF4js.VectoJSEvent; exports.WebGPUParticleSystemManager = _chunkKEBYJVD6js.WebGPUParticleSystemManager; exports.beginVectoUserTiming = beginVectoUserTiming; exports.createWebGLPointRenderer = _chunkKEBYJVD6js.createWebGLPointRenderer; exports.endVectoUserTiming = endVectoUserTiming; exports.isSafeUrl = _chunkKEBYJVD6js.isSafeUrl; exports.loadSpline = loadSpline; exports.measureVectoUserTiming = measureVectoUserTiming; exports.parseColorToRGBA = _chunkKEBYJVD6js.parseColorToRGBA; exports.polySegmentToBezier = polySegmentToBezier; exports.sanitizeUrl = _chunkKEBYJVD6js.sanitizeUrl;