@vectojs/core 1.19.0 → 1.21.0

package/dist/index.js

@@ -8,13 +8,14 @@
 
 
 
-var _chunkL4SWVP2Hjs = require('./chunk-L4SWVP2H.js');
 
+var _chunkGKSCJ6AFjs = require('./chunk-GKSCJ6AF.js');
 
 
 
 
-var _chunkIA3KW4CGjs = require('./chunk-IA3KW4CG.js');
+
+var _chunkAGP4VLF4js = require('./chunk-AGP4VLF4.js');
 
 // src/tree/Scene.ts
 var _animation = require('@vectojs/animation'); _createStarExport(_animation);
@@ -29,7 +30,7 @@ var PARTICLE_OFFSET_ORIGIN_X = 4;
 var PARTICLE_OFFSET_ORIGIN_Y = 5;
 var PARTICLE_OFFSET_SIZE = 6;
 var PARTICLE_OFFSET_LIFE = 7;
-var ComputeParticleEntity = (_class = class extends _chunkIA3KW4CGjs.Entity {
+var ComputeParticleEntity = (_class = class extends _chunkAGP4VLF4js.Entity {
   
   
   
@@ -1539,32 +1540,96 @@ var Scene = (_class7 = class _Scene {
   __init29() {this.renderMode = "always"}
   /** Cap on distinct recorded dirty reasons (see `recordDirtyReason`). */
   static __initStatic4() {this.MAX_DIRTY_REASONS = 200}
-  __init30() {this._dirtyTracking = false}
-  __init31() {this._dirtyReasons = /* @__PURE__ */ new Map()}
-  __init32() {this.dirty = true}
+  __init30() {this._phaseTiming = false}
+  __init31() {this._phaseTotals = /* @__PURE__ */ new Map()}
+  /**
+   * Start or stop per-phase render timing.
+   *
+   * Off by default, and the probes compile to a single boolean test when off:
+   * these sit on the frame path, so the disabled cost has to be nothing. Enable,
+   * run the scene, then read {@link renderPhases}.
+   *
+   * Exists because a frame total cannot tell you where the time went. The
+   * markdown streaming benchmark put render at 85-99% of an append's cost, and
+   * there was no way to decompose that number further — which is exactly the
+   * position that led to two wrong optimisation guesses earlier
+   * (`CodeBlock` reuse, hit-grid fusion), both of which measured as no change.
+   */
+  setPhaseTiming(enabled) {
+    this._phaseTiming = enabled;
+    if (!enabled) this.clearRenderPhases();
+  }
+  /** Whether per-phase render timing is being recorded. */
+  get phaseTiming() {
+    return this._phaseTiming;
+  }
+  /**
+   * Accumulate one phase sample.
+   *
+   * Totals rather than a per-frame log: the question is always "which phase owns
+   * the frame", and a log of thousands of samples answers it less directly while
+   * costing far more memory. `maxMs` is kept because a phase that is cheap on
+   * average but spikes is a different problem from one that is uniformly slow.
+   */
+  _recordPhase(phase, ms) {
+    const existing = this._phaseTotals.get(phase);
+    if (existing) {
+      existing.totalMs += ms;
+      existing.calls++;
+      if (ms > existing.maxMs) existing.maxMs = ms;
+      return;
+    }
+    this._phaseTotals.set(phase, { totalMs: ms, calls: 1, maxMs: ms });
+  }
+  /**
+   * Recorded phase timings, most expensive first, with each phase's share of the
+   * measured total.
+   *
+   * `share` is the number that matters: a phase at 4% cannot be worth optimising
+   * however inefficient it looks in isolation.
+   */
+  get renderPhases() {
+    const entries = [...this._phaseTotals.entries()];
+    const denominator = entries.filter(([phase]) => phase !== "render").reduce((sum, [, v]) => sum + v.totalMs, 0);
+    return entries.map(([phase, v]) => ({
+      phase,
+      totalMs: +v.totalMs.toFixed(3),
+      calls: v.calls,
+      avgMs: +(v.totalMs / Math.max(1, v.calls)).toFixed(4),
+      maxMs: +v.maxMs.toFixed(3),
+      share: phase === "render" ? null : +(100 * v.totalMs / Math.max(1e-9, denominator)).toFixed(1)
+    })).sort((a, b) => b.totalMs - a.totalMs);
+  }
+  /** Drop recorded phase timings, keeping timing enabled. */
+  clearRenderPhases() {
+    this._phaseTotals.clear();
+  }
+  __init32() {this._dirtyTracking = false}
+  __init33() {this._dirtyReasons = /* @__PURE__ */ new Map()}
+  __init34() {this.dirty = true}
   /** Whether to throttle rendering to 2 FPS when the scene is static to save power. */
-  __init33() {this.autoThrottle = true}
+  __init35() {this.autoThrottle = true}
   // --- Frame telemetry (read via `frameStats`) ---------------------------
   /** Wall-clock ms spent inside the last `render()` call. */
-  __init34() {this._lastFrameMs = 0}
+  __init36() {this._lastFrameMs = 0}
   /** Rolling exponential average of rendered-frame intervals, in ms. */
-  __init35() {this._avgFrameIntervalMs = 0}
+  __init37() {this._avgFrameIntervalMs = 0}
   /** dt (ms) handed to the last rendered frame. */
-  __init36() {this._lastDt = 0}
+  __init38() {this._lastDt = 0}
   /** Count of frames actually rendered since the loop started. */
-  __init37() {this._renderedFrames = 0}
+  __init39() {this._renderedFrames = 0}
   /** Count of rAF ticks skipped (idle / capped) since the loop started. */
-  __init38() {this._skippedFrames = 0}
+  __init40() {this._skippedFrames = 0}
   /** `time` of the previous *rendered* frame, for interval measurement. */
-  __init39() {this._lastRenderTick = 0}
+  __init41() {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}.
    */
-  __init40() {this.maxFPS = 60}
+  __init42() {this.maxFPS = 60}
   /** Whether the OS prefers-reduced-motion setting auto-caps the loop. */
-  __init41() {this.respectReducedMotion = true}
+  __init43() {this.respectReducedMotion = true}
   /**
    * Reading direction for accessibility tab/traversal order (`'ltr'` default,
    * `'rtl'`). Controls the inline sort within a visual row in
@@ -1580,15 +1645,15 @@ var Scene = (_class7 = class _Scene {
       this.a11yNeedsReorder = true;
     }
   }
-  __init42() {this._readingDirection = "ltr"}
+  __init44() {this._readingDirection = "ltr"}
   /** Cached media-query list; `.matches` is read live each frame. */
-  __init43() {this.reducedMotionQuery = null}
+  __init45() {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. */
-  __init44() {this.forcedColorsQuery = null}
-  __init45() {this.forcedColorsChangeHandler = null}
+  __init46() {this.forcedColorsQuery = null}
+  __init47() {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]);
@@ -1608,82 +1673,105 @@ var Scene = (_class7 = class _Scene {
    * Throttle interval (ms) for the a11y/automation shadow sync. `0` = every
    * frame. See {@link SceneOptions.a11ySyncInterval}.
    */
-  __init46() {this.a11ySyncInterval = 0}
+  __init48() {this.a11ySyncInterval = 0}
   /** Timestamp of the last a11y sync, for throttling. */
-  __init47() {this.lastA11ySync = -Infinity}
+  __init49() {this.lastA11ySync = -Infinity}
   /** True if we skipped an a11y sync during animation and need to sync when at rest. */
-  __init48() {this.a11yPendingSyncAfterAnimation = false}
+  __init50() {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.
   
-  __init49() {this.a11yElements = /* @__PURE__ */ new Map()}
+  __init51() {this.a11yElements = /* @__PURE__ */ new Map()}
   /** DOM nodes mirroring static text content, keyed by entity id. */
-  __init50() {this.contentElements = /* @__PURE__ */ new Map()}
+  __init52() {this.contentElements = /* @__PURE__ */ new Map()}
   /** Pending cold font-calibration frame per projected grid entity. */
-  __init51() {this.contentGridCalibrationFrames = /* @__PURE__ */ new Map()}
+  __init53() {this.contentGridCalibrationFrames = /* @__PURE__ */ new Map()}
   /** Detached, untransformed font probes used by the cold calibration pass. */
-  __init52() {this.contentGridCalibrationProbes = /* @__PURE__ */ new Map()}
+  __init54() {this.contentGridCalibrationProbes = /* @__PURE__ */ new Map()}
+  /**
+   * Monotonic stamp identifying the conditions grid cells were calibrated under.
+   *
+   * Calibration measures the difference between the advance the canvas grid assigns
+   * a cluster and the width the browser lays it out at, then writes a per-cell
+   * `scaleX`. That result stays valid until the font or the page scale changes, and
+   * it lives on the cell element — so a cell carrying this stamp needs no further
+   * work.
+   *
+   * The scan that feeds calibration was O(cells) on every revision bump: for a
+   * streaming code block it re-derived a measurement key for every cell in the
+   * block each frame in order to produce only ~20 distinct keys, costing about
+   * 2.5 ms/frame after the `style.font` fix and still over half of `a11ySync`. Since
+   * carrier reuse (#244) leaves untouched lines — and therefore their calibrated
+   * transforms — in place, cells stamped with the current generation can simply be
+   * skipped, making the scan O(new cells) instead.
+   *
+   * 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}
+  /** The `(fontEpoch, pageScale)` pair the current generation corresponds to. */
+  __init56() {this.contentGridCalibrationStamp = ""}
   /** Invalidates grid font calibration after browser font availability changes. */
-  __init53() {this.contentFontEpoch = 0}
+  __init57() {this.contentFontEpoch = 0}
   /** Cached Canvas-to-client scale for the current font/viewport epoch. */
-  __init54() {this.contentMetricScaleEpoch = -1}
-  __init55() {this.contentMetricScaleX = 1}
-  __init56() {this.contentProjectionEnabled = true}
+  __init58() {this.contentMetricScaleEpoch = -1}
+  __init59() {this.contentMetricScaleX = 1}
+  __init60() {this.contentProjectionEnabled = true}
   // Virtualization margin (px) for content projection; `undefined` → one
   // viewport height, resolved at sync time. `Infinity` = materialize everything.
-  __init57() {this.contentProjectionMargin = void 0}
+  __init61() {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.
    */
-  __init58() {this.blankRegionSelectionDrag = false}
-  __init59() {this.contentSelectionAnchor = null}
-  __init60() {this.contentSelectionEndListener = null}
+  __init62() {this.blankRegionSelectionDrag = false}
+  __init63() {this.contentSelectionAnchor = null}
+  __init64() {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.
-  __init61() {this.frameHadAnimation = true}
-  __init62() {this.frameHadInteractive = true}
+  __init65() {this.frameHadAnimation = true}
+  __init66() {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. */
-  __init63() {this.dprMediaQuery = null}
+  __init67() {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. */
-  __init64() {this.canvasResizeObserver = null}
-  __init65() {this.dprChangeHandler = null}
-  __init66() {this.focusedA11yElement = null}
+  __init68() {this.canvasResizeObserver = null}
+  __init69() {this.dprChangeHandler = null}
+  __init70() {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). */
-  __init67() {this._overlayGeometry = null}
+  __init71() {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. */
-  __init68() {this.hoveredA11yElements = /* @__PURE__ */ new WeakSet()}
+  __init72() {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. */
-  __init69() {this.focusSentinel = null}
-  __init70() {this.caretBlinkTimer = null}
-  __init71() {this.a11yNeedsReorder = true}
-  __init72() {this.portalRoot = null}
-  __init73() {this.fullViewportElements = []}
-  __init74() {this.normalElements = []}
-  __init75() {this.activeIds = /* @__PURE__ */ new Set()}
-  __init76() {this.activePortalsThisFrame = /* @__PURE__ */ new Set()}
-  __init77() {this.activePortalsPrevFrame = /* @__PURE__ */ new Set()}
-  __init78() {this.portalEntities = /* @__PURE__ */ new Map()}
-  __init79() {this.renderOrderCounter = 0}
+  __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}
   /**
    * Monotonic render-frame counter, bumped once per authoritative `render()`
    * pass. Entities stamp their per-frame world-matrix cache with this value and
@@ -1692,7 +1780,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.
    */
-  __init80() {this.currentFrame = 0}
+  __init84() {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
@@ -1700,24 +1788,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.
-  __init81() {this._wasm = null}
-  __init82() {this._transformBackend = "js"}
+  __init85() {this._wasm = null}
+  __init86() {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.
-  __init83() {this._treeStore = null}
-  __init84() {this._slotEntity = []}
+  __init87() {this._treeStore = null}
+  __init88() {this._slotEntity = []}
   // store slot -> entity (also validates slots)
-  __init85() {this._wasmInputs = null}
-  __init86() {this._wasmWorld = null}
-  __init87() {this._structureVersion = 0}
-  __init88() {this._storeStructureVersion = -1}
+  __init89() {this._wasmInputs = null}
+  __init90() {this._wasmWorld = null}
+  __init91() {this._structureVersion = 0}
+  __init92() {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.
-  __init89() {this._computeEntities = []}
-  __init90() {this._computeEntitiesVersion = -1}
+  __init93() {this._computeEntities = []}
+  __init94() {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() {
@@ -1799,7 +1887,7 @@ var Scene = (_class7 = class _Scene {
    * cached globally; the instance is per-Scene, which is the isolation that
    * actually matters.
    */
-  __init91() {this._wasmRuntime = null}
+  __init95() {this._wasmRuntime = null}
   /**
    * Load (or reuse) this Scene's shared WASM runtime.
    *
@@ -1827,30 +1915,30 @@ var Scene = (_class7 = class _Scene {
   get wasmRuntime() {
     return this._wasmRuntime;
   }
-  __init92() {this._hitWasm = null}
+  __init96() {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.
-  __init93() {this._hitGridFrame = -1}
-  __init94() {this._hitGridOk = false}
-  __init95() {this._hitSlotEntity = []}
-  __init96() {this._hitBoundless = []}
+  __init97() {this._hitGridFrame = -1}
+  __init98() {this._hitGridOk = false}
+  __init99() {this._hitSlotEntity = []}
+  __init100() {this._hitBoundless = []}
   /** Reused buffer for the fused gather, so a pointer query allocates nothing. */
-  __init97() {this._hitGatherBuffer = null}
+  __init101() {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.
    */
-  __init98() {this._hitFusedGather = false}
+  __init102() {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.
    */
-  __init99() {this._wasmAabbsFresh = false}
+  __init103() {this._wasmAabbsFresh = false}
   /** Did the last hit-grid build use the fused (WASM-store) gather? */
   get hitGatherPath() {
     return this._hitFusedGather ? "fused" : "js";
@@ -1964,25 +2052,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.
-  __init100() {this._animWasm = null}
+  __init104() {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.
-  __init101() {this._activeDriverEntities = /* @__PURE__ */ new Set()}
+  __init105() {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.
-  __init102() {this._springEntities = []}
-  __init103() {this._springProps = []}
-  __init104() {this._springDrivers = []}
-  __init105() {this._tweenEntities = []}
-  __init106() {this._tweenProps = []}
-  __init107() {this._tweenDrivers = []}
+  __init106() {this._springEntities = []}
+  __init107() {this._springProps = []}
+  __init108() {this._springDrivers = []}
+  __init109() {this._tweenEntities = []}
+  __init110() {this._tweenProps = []}
+  __init111() {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
@@ -2054,7 +2142,7 @@ var Scene = (_class7 = class _Scene {
    * Setting {@link animDriverGateCount} overwrites all three, so existing code
    * that tuned the single knob keeps working unchanged.
    */
-  __init108() {this._animBatchedLastFrame = false}
+  __init112() {this._animBatchedLastFrame = false}
   /**
    * Whether the WASM batch path actually ran on the most recent frame.
    *
@@ -2066,7 +2154,7 @@ var Scene = (_class7 = class _Scene {
   get animBatchedLastFrame() {
     return this._animBatchedLastFrame;
   }
-  __init109() {this.animGate = {
+  __init113() {this.animGate = {
     spring: 128,
     tween: 256,
     mixed: 128
@@ -2104,7 +2192,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.
-  __init110() {this._particleWasm = null}
+  __init114() {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). */
@@ -2354,46 +2442,46 @@ var Scene = (_class7 = class _Scene {
    * sync, so retaining the order prevents a newly opened overlay from spending
    * its first frame below previously projected controls.
    */
-  __init111() {this.a11yRenderOrders = /* @__PURE__ */ new Map()}
+  __init115() {this.a11yRenderOrders = /* @__PURE__ */ new Map()}
   // Optional WebGL point-cloud layer (see SceneOptions.pointBackend).
-  __init112() {this.pointRenderer = null}
-  __init113() {this.glCanvas = null}
-  __init114() {this.glContextLostHandler = null}
-  __init115() {this.glContextRestoredHandler = null}
+  __init116() {this.pointRenderer = null}
+  __init117() {this.glCanvas = null}
+  __init118() {this.glContextLostHandler = null}
+  __init119() {this.glContextRestoredHandler = null}
   
   
   
-  __init116() {this.disableWindowResize = false}
+  __init120() {this.disableWindowResize = false}
   /** See {@link SceneOptions.maxDPR}. `undefined` = uncapped (real DPR). */
   
   // WebGPU properties
-  __init117() {this.destroyed = false}
-  __init118() {this.device = null}
-  __init119() {this.deviceLost = false}
-  __init120() {this.particleBackend = "auto"}
-  __init121() {this._webgpuDisabled = false}
+  __init121() {this.destroyed = false}
+  __init122() {this.device = null}
+  __init123() {this.deviceLost = false}
+  __init124() {this.particleBackend = "auto"}
+  __init125() {this._webgpuDisabled = false}
   get webgpuDisabled() {
     return this._webgpuDisabled || this.particleBackend === "cpu";
   }
   set webgpuDisabled(value) {
     this._webgpuDisabled = value;
   }
-  __init122() {this.recoveryTimerId = null}
-  __init123() {this.manager = null}
-  __init124() {this.initializingWebGPU = false}
-  __init125() {this.gpuCanvas = null}
-  __init126() {this.gpuContext = null}
+  __init126() {this.recoveryTimerId = null}
+  __init127() {this.manager = null}
+  __init128() {this.initializingWebGPU = false}
+  __init129() {this.gpuCanvas = null}
+  __init130() {this.gpuContext = null}
   /** True while the GPU canvas holds a presented particle frame (needs clearing when they leave). */
-  __init127() {this.gpuHasContent = false}
-  __init128() {this.mouseX = -9999}
-  __init129() {this.mouseY = -9999}
-  __init130() {this.pointerMoveListener = null}
-  __init131() {this.pointerLeaveListener = null}
+  __init131() {this.gpuHasContent = false}
+  __init132() {this.mouseX = -9999}
+  __init133() {this.mouseY = -9999}
+  __init134() {this.pointerMoveListener = null}
+  __init135() {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. */
-  __init132() {this.pointerEventTarget = null}
-  __init133() {this.hasWarnedZeroSize = false}
-  __init134() {this.fontLoadHandler = null}
+  __init136() {this.pointerEventTarget = null}
+  __init137() {this.hasWarnedZeroSize = false}
+  __init138() {this.fontLoadHandler = null}
   // ── Dev-mode warning infrastructure ──────────────────────────────
   //
   // Enable with `Scene.devMode = true` or by setting `globalThis.__DEV__`.
@@ -2411,7 +2499,7 @@ var Scene = (_class7 = class _Scene {
     return false;
   }
   
-  __init135() {this._devFrameCount = 0}
+  __init139() {this._devFrameCount = 0}
   _devWarn(message) {
     if (!this._devActive) return;
     console.warn(`[vectojs/dev] ${message}`);
@@ -2455,7 +2543,7 @@ 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);
+  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);
     this.canvas = canvas;
     this.debugA11y = _nullishCoalesce(options.debugA11y, () => ( false));
     this.disableWindowResize = _nullishCoalesce(options.disableWindowResize, () => ( false));
@@ -2486,7 +2574,7 @@ var Scene = (_class7 = class _Scene {
       this.forcedColorsChangeHandler = () => this.markDirty();
       _optionalChain([this, 'access', _45 => _45.forcedColorsQuery, 'access', _46 => _46.addEventListener, 'optionalCall', _47 => _47("change", this.forcedColorsChangeHandler)]);
     }
-    this.root = new class RootEntity extends _chunkIA3KW4CGjs.Entity {
+    this.root = new class RootEntity extends _chunkAGP4VLF4js.Entity {
       isPointInside() {
         return false;
       }
@@ -2495,7 +2583,7 @@ var Scene = (_class7 = class _Scene {
       }
     }("root");
     this.root._scene = this;
-    this.overlayRoot = new class OverlayRoot extends _chunkIA3KW4CGjs.Entity {
+    this.overlayRoot = new class OverlayRoot extends _chunkAGP4VLF4js.Entity {
       isPointInside() {
         return false;
       }
@@ -2506,7 +2594,7 @@ var Scene = (_class7 = class _Scene {
     if (options.renderer) {
       this.renderer = options.renderer;
     } else {
-      this.renderer = new (0, _chunkL4SWVP2Hjs.CanvasRenderer)(
+      this.renderer = new (0, _chunkGKSCJ6AFjs.CanvasRenderer)(
         canvas,
         this.disableWindowResize ? { width: this.width, height: this.height } : void 0,
         this.maxDPR
@@ -2732,12 +2820,35 @@ var Scene = (_class7 = class _Scene {
     this.contentSelectionAnchor = null;
     if (this.a11yRoot) this.a11yRoot.style.pointerEvents = "none";
   }
+  /**
+   * Index of the carrier line currently holding a selection inside `el`, or
+   * `null`.
+   *
+   * Lets a partial re-materialization decide whether the user's selection is even
+   * affected. Checks the tracked anchor first (it survives a drag) and falls back
+   * to the live DOM selection.
+   */
+  contentGridSelectionLine(el) {
+    const candidates = [_optionalChain([this, 'access', _62 => _62.contentSelectionAnchor, 'optionalAccess', _63 => _63.node])];
+    if (typeof window !== "undefined" && typeof window.getSelection === "function") {
+      const selection = window.getSelection();
+      candidates.push(_optionalChain([selection, 'optionalAccess', _64 => _64.anchorNode]), _optionalChain([selection, 'optionalAccess', _65 => _65.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', _66 => _66.dataset, 'optionalAccess', _67 => _67.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', _62 => _62.anchorNode]) ? el.contains(selection.anchorNode) : false) || (_optionalChain([selection, 'optionalAccess', _63 => _63.focusNode]) ? el.contains(selection.focusNode) : false);
+    const ownsSelection = this.contentSelectionAnchor && el.contains(this.contentSelectionAnchor.node) || (_optionalChain([selection, 'optionalAccess', _68 => _68.anchorNode]) ? el.contains(selection.anchorNode) : false) || (_optionalChain([selection, 'optionalAccess', _69 => _69.focusNode]) ? el.contains(selection.focusNode) : false);
     if (!ownsSelection) return;
     this.endContentSelectionDrag();
-    _optionalChain([selection, 'optionalAccess', _64 => _64.removeAllRanges, 'call', _65 => _65()]);
+    _optionalChain([selection, 'optionalAccess', _70 => _70.removeAllRanges, 'call', _71 => _71()]);
   }
   /**
    * Rebuild a content-projection element's DOM (`rebuild`) while preserving a
@@ -2796,7 +2907,7 @@ var Scene = (_class7 = class _Scene {
   }
   /** Convert browser viewport coordinates into this Scene's logical coordinates. */
   clientToScene(clientX, clientY) {
-    const rect = _optionalChain([this, 'access', _66 => _66.canvas, 'access', _67 => _67.getBoundingClientRect, 'optionalCall', _68 => _68()]);
+    const rect = _optionalChain([this, 'access', _72 => _72.canvas, 'access', _73 => _73.getBoundingClientRect, 'optionalCall', _74 => _74()]);
     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;
@@ -2817,13 +2928,24 @@ var Scene = (_class7 = class _Scene {
     this.registerActiveDriverSubtree(entity);
     return this;
   }
-  clearContentGridState(entityId, el) {
+  /**
+   * Reset per-grid calibration and bookkeeping before a (re)materialization.
+   *
+   * @param entityId - Owning entity, keyed into the calibration maps.
+   * @param el - The projection element.
+   * @param releaseSelection - Whether to drop a selection this element owns.
+   *   Pass `false` when carrier lines are being reused: the selection's DOM nodes
+   *   survive the pass, so tearing it down would wipe a user's selection on every
+   *   streamed chunk — the exact bug `preserveContentSelectionAcrossRebuild`
+   *   exists to prevent on the non-grid path.
+   */
+  clearContentGridState(entityId, el, releaseSelection = true) {
     const calibrationFrame = this.contentGridCalibrationFrames.get(entityId);
     if (calibrationFrame !== void 0 && typeof cancelAnimationFrame === "function") {
       cancelAnimationFrame(calibrationFrame);
     }
     this.contentGridCalibrationFrames.delete(entityId);
-    _optionalChain([this, 'access', _69 => _69.contentGridCalibrationProbes, 'access', _70 => _70.get, 'call', _71 => _71(entityId), 'optionalAccess', _72 => _72.remove, 'call', _73 => _73()]);
+    _optionalChain([this, 'access', _75 => _75.contentGridCalibrationProbes, 'access', _76 => _76.get, 'call', _77 => _77(entityId), 'optionalAccess', _78 => _78.remove, 'call', _79 => _79()]);
     this.contentGridCalibrationProbes.delete(entityId);
     delete el.dataset.vectoGridCalibrationPending;
     delete el.dataset.vectoGridCalibration;
@@ -2833,7 +2955,21 @@ var Scene = (_class7 = class _Scene {
     delete el.dataset.vectoGridMaterializeMs;
     delete el.dataset.vectoGridCalibrationSamples;
     delete el.dataset.vectoGridCalibrationMs;
-    this.releaseContentSelectionForRebuild(el);
+    if (releaseSelection) this.releaseContentSelectionForRebuild(el);
+  }
+  /**
+   * Drop any projected elements under `node` without touching the entity tree.
+   *
+   * Used when the walk reaches an invisible subtree: the entities stay put (a
+   * later `show()` re-projects them), but nothing under here may remain
+   * focusable or announced while hidden.
+   */
+  pruneA11ySubtree(node) {
+    if (this.a11yElements.has(node.id) || this.contentElements.has(node.id)) {
+      this.removeA11yRecursively(node);
+      return;
+    }
+    for (const child of node.children) this.pruneA11ySubtree(child);
   }
   removeA11yRecursively(node) {
     if (node.isDOMPortal) {
@@ -2861,7 +2997,7 @@ var Scene = (_class7 = class _Scene {
       }
       if (this.hoveredA11yElements.has(el)) {
         this.hoveredA11yElements.delete(el);
-        node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("pointerleave", node, void 0, false));
+        node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("pointerleave", node, void 0, false));
       }
       this.preserveFocusOnRemoval(el);
       el.remove();
@@ -2963,12 +3099,12 @@ var Scene = (_class7 = class _Scene {
       this.canvasResizeObserver = null;
     }
     if (this.dprMediaQuery && this.dprChangeHandler) {
-      _optionalChain([this, 'access', _74 => _74.dprMediaQuery, 'access', _75 => _75.removeEventListener, 'optionalCall', _76 => _76("change", this.dprChangeHandler)]);
+      _optionalChain([this, 'access', _80 => _80.dprMediaQuery, 'access', _81 => _81.removeEventListener, 'optionalCall', _82 => _82("change", this.dprChangeHandler)]);
       this.dprMediaQuery = null;
       this.dprChangeHandler = null;
     }
     if (this.forcedColorsQuery && this.forcedColorsChangeHandler) {
-      _optionalChain([this, 'access', _77 => _77.forcedColorsQuery, 'access', _78 => _78.removeEventListener, 'optionalCall', _79 => _79("change", this.forcedColorsChangeHandler)]);
+      _optionalChain([this, 'access', _83 => _83.forcedColorsQuery, 'access', _84 => _84.removeEventListener, 'optionalCall', _85 => _85("change", this.forcedColorsChangeHandler)]);
       this.forcedColorsQuery = null;
       this.forcedColorsChangeHandler = null;
     }
@@ -2986,9 +3122,9 @@ var Scene = (_class7 = class _Scene {
       }
       this.pointerEventTarget = null;
     }
-    _optionalChain([this, 'access', _80 => _80.a11yRoot, 'optionalAccess', _81 => _81.remove, 'call', _82 => _82()]);
+    _optionalChain([this, 'access', _86 => _86.a11yRoot, 'optionalAccess', _87 => _87.remove, 'call', _88 => _88()]);
     this.focusSentinel = null;
-    _optionalChain([this, 'access', _83 => _83.portalRoot, 'optionalAccess', _84 => _84.remove, 'call', _85 => _85()]);
+    _optionalChain([this, 'access', _89 => _89.portalRoot, 'optionalAccess', _90 => _90.remove, 'call', _91 => _91()]);
     this.a11yElements.clear();
     for (const el of this.contentElements.values()) el.remove();
     this.contentElements.clear();
@@ -3011,10 +3147,10 @@ var Scene = (_class7 = class _Scene {
     }
     this.glContextLostHandler = null;
     this.glContextRestoredHandler = null;
-    _optionalChain([this, 'access', _86 => _86.pointRenderer, 'optionalAccess', _87 => _87.destroy, 'call', _88 => _88()]);
-    _optionalChain([this, 'access', _89 => _89.renderer, 'access', _90 => _90.dispose, 'optionalCall', _91 => _91()]);
-    _optionalChain([this, 'access', _92 => _92.glCanvas, 'optionalAccess', _93 => _93.remove, 'call', _94 => _94()]);
-    _optionalChain([this, 'access', _95 => _95.gpuCanvas, 'optionalAccess', _96 => _96.remove, 'call', _97 => _97()]);
+    _optionalChain([this, 'access', _92 => _92.pointRenderer, 'optionalAccess', _93 => _93.destroy, 'call', _94 => _94()]);
+    _optionalChain([this, 'access', _95 => _95.renderer, 'access', _96 => _96.dispose, 'optionalCall', _97 => _97()]);
+    _optionalChain([this, 'access', _98 => _98.glCanvas, 'optionalAccess', _99 => _99.remove, 'call', _100 => _100()]);
+    _optionalChain([this, 'access', _101 => _101.gpuCanvas, 'optionalAccess', _102 => _102.remove, 'call', _103 => _103()]);
     this.gpuCanvas = null;
     this.gpuContext = null;
     if (this.recoveryTimerId) {
@@ -3026,7 +3162,7 @@ var Scene = (_class7 = class _Scene {
       this.manager = null;
     }
     if (this.device) {
-      _optionalChain([this, 'access', _98 => _98.device, 'access', _99 => _99.destroy, 'optionalCall', _100 => _100()]);
+      _optionalChain([this, 'access', _104 => _104.device, 'access', _105 => _105.destroy, 'optionalCall', _106 => _106()]);
       this.device = null;
     }
   }
@@ -3149,10 +3285,32 @@ var Scene = (_class7 = class _Scene {
   get overlayRootEntity() {
     return this.overlayRoot;
   }
+  /**
+   * Advance and render exactly one frame, synchronously.
+   *
+   * This renders UNCONDITIONALLY: it consults neither {@link renderMode} nor
+   * {@link dirty}, and it does not apply the `always`-mode idle auto-throttle.
+   * That is deliberate — a deterministic driver (video export, a test, a
+   * fixed-step benchmark) asks for a frame because it wants that frame, not a
+   * scheduler opinion about whether it is needed.
+   *
+   * The consequence is a measurement footgun worth stating explicitly: a
+   * benchmark that drives frames through `step()` CANNOT observe frame skipping,
+   * so `always` and `onDemand` produce byte-identical draw counts through this
+   * path. An investigation into whether `onDemand` skips redundant repaints once
+   * concluded "it does not" on exactly that basis; on the real rAF loop the same
+   * workload rendered ~1.0 frames per content change. To measure anything about
+   * scheduling, use {@link start} and let `requestAnimationFrame` drive.
+   *
+   * @param dt Seconds to advance. Not clamped by `MAX_FRAME_DT` — the caller
+   *   chooses the step, since determinism is the point.
+   */
   step(dt) {
     const time = this.lastTime + dt;
     this.lastTime = time;
+    const t0 = this._phaseTiming ? performance.now() : 0;
     this.render(this.renderer, dt, time);
+    if (this._phaseTiming) this._recordPhase("render", performance.now() - t0);
     this.dirty = false;
   }
   /**
@@ -3165,6 +3323,24 @@ var Scene = (_class7 = class _Scene {
     this.dirty = true;
     if (this._dirtyTracking && source) this.recordDirtyReason(source);
   }
+  /**
+   * Increments whenever the tree's shape changes: add, remove or reparent.
+   *
+   * Already maintained for the resident WASM transform store (see
+   * {@link markStructureChanged}, called from `Entity.add`/`remove`), and exposed
+   * here because a cache of the tree's shape — a DevTools tree model, a serialized
+   * snapshot — is valid exactly as long as this value is unchanged. Comparing it is
+   * O(1) against re-walking the tree, which is what it replaces: DevTools rebuilt
+   * both trees on a fixed 500 ms interval, a constant cost proportional to entity
+   * count, purely because it had no way to ask whether the shape had changed.
+   *
+   * Property changes do NOT bump it. Moving or restyling an entity leaves the
+   * shape intact, so a consumer that also cares about values must read those
+   * directly rather than rebuilding a tree.
+   */
+  get structureVersion() {
+    return this._structureVersion;
+  }
   /**
    * Record who marked the scene dirty and why.
    *
@@ -3287,6 +3463,11 @@ var Scene = (_class7 = class _Scene {
     if (node.isDOMPortal) {
       return;
     }
+    if (node.a11yHidden) {
+      this.pruneA11ySubtree(node);
+      return;
+    }
+    const nodeStart = this._phaseTiming ? performance.now() : 0;
     if (this.shouldProjectA11y(node)) {
       let el = this.a11yElements.get(node.id);
       const attrs = node.getA11yAttributes();
@@ -3328,20 +3509,20 @@ var Scene = (_class7 = class _Scene {
           el.style.background = "transparent";
         }
         el.addEventListener("click", (e) => {
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("click", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("click", node, e));
         });
         el.addEventListener("dblclick", (e) => {
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("dblclick", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("dblclick", node, e));
         });
         el.addEventListener("mouseenter", (e) => {
           if (this.debugA11y) el.style.backgroundColor = "rgba(56, 189, 248, 0.2)";
           this.hoveredA11yElements.add(el);
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("hover", node, e, false));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("hover", node, e, false));
         });
         el.addEventListener("mouseleave", (e) => {
           if (this.debugA11y) el.style.backgroundColor = "rgba(56, 189, 248, 0.05)";
           this.hoveredA11yElements.delete(el);
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("pointerleave", node, e, false));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("pointerleave", node, e, false));
         });
         const capEl = el;
         const releasePointer = (event) => {
@@ -3357,32 +3538,32 @@ var Scene = (_class7 = class _Scene {
         };
         el.addEventListener("pointerdown", (e) => {
           if (typeof capEl.setPointerCapture === "function") capEl.setPointerCapture(e.pointerId);
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("pointerdown", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("pointerdown", node, e));
         });
         el.addEventListener("pointerup", (e) => {
           releasePointer(e);
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("pointerup", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("pointerup", node, e));
         });
         el.addEventListener("pointercancel", (e) => {
           releasePointer(e);
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("pointercancel", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("pointercancel", node, e));
         });
         el.addEventListener(
           "pointermove",
-          (e) => node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("pointermove", node, e))
+          (e) => node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("pointermove", node, e))
         );
         el.addEventListener(
           "wheel",
           (e) => {
-            node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("wheel", node, e));
+            node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("wheel", node, e));
           },
           { passive: false }
         );
         el.addEventListener("keydown", (e) => {
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("keydown", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("keydown", node, e));
         });
         el.addEventListener("keyup", (e) => {
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("keyup", node, e));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("keyup", node, e));
         });
         if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
           const input = el;
@@ -3413,7 +3594,7 @@ var Scene = (_class7 = class _Scene {
           el.addEventListener("compositionupdate", (e) => {
             const data = _nullishCoalesce(e.data, () => ( ""));
             composition = {
-              start: _nullishCoalesce(_optionalChain([composition, 'optionalAccess', _101 => _101.start]), () => ( 0)),
+              start: _nullishCoalesce(_optionalChain([composition, 'optionalAccess', _107 => _107.start]), () => ( 0)),
               length: data.length
             };
             forward();
@@ -3448,7 +3629,7 @@ var Scene = (_class7 = class _Scene {
           el.addEventListener("keydown", (e) => {
             if (e.key === "Enter" || e.key === " ") {
               e.preventDefault();
-              node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("click", node, e));
+              node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("click", node, e));
             }
           });
         }
@@ -3486,7 +3667,7 @@ var Scene = (_class7 = class _Scene {
         this.syncOptionalAttribute(
           el,
           "href",
-          attrs.href === void 0 ? void 0 : _chunkL4SWVP2Hjs.sanitizeUrl.call(void 0, attrs.href)
+          attrs.href === void 0 ? void 0 : _chunkGKSCJ6AFjs.sanitizeUrl.call(void 0, attrs.href)
         );
         this.syncOptionalAttribute(el, "target", attrs.target);
       }
@@ -3629,7 +3810,14 @@ var Scene = (_class7 = class _Scene {
         if (el.style.display !== display) el.style.display = display;
       }
     }
-    this.syncContentProjection(node);
+    if (this._phaseTiming) {
+      const projectionStart = performance.now();
+      this.syncContentProjection(node);
+      this._recordPhase("contentProjection", performance.now() - projectionStart);
+      this._recordPhase("a11yNodes", projectionStart - nodeStart);
+    } else {
+      this.syncContentProjection(node);
+    }
     for (const child of node.children) this.syncA11y(child);
     if (node === this.root) {
       for (const overlay of this.overlayRoot.children) this.syncA11y(overlay);
@@ -3730,7 +3918,7 @@ var Scene = (_class7 = class _Scene {
       el.addEventListener(
         "wheel",
         (e2) => {
-          node.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)("wheel", node, e2));
+          node.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)("wheel", node, e2));
         },
         { passive: false }
       );
@@ -3743,7 +3931,9 @@ var Scene = (_class7 = class _Scene {
       this.clearContentGridState(node.id, el);
     }
     if (projection.grid) {
+      const gridSyncStart = this._phaseTiming ? performance.now() : 0;
       this.syncContentGridProjection(node, el, projection, projection.grid);
+      if (this._phaseTiming) this._recordPhase("gridSync", performance.now() - gridSyncStart);
     } else if (lines && lines.length > 0) {
       const signature = JSON.stringify({
         lines,
@@ -3849,21 +4039,38 @@ var Scene = (_class7 = class _Scene {
     const signature = `${grid.revision}`;
     if (el.dataset.vectoContentGrid !== signature) {
       const materializeStart = typeof performance !== "undefined" ? performance.now() : 0;
-      this.clearContentGridState(node.id, el);
-      el.replaceChildren();
+      this.clearContentGridState(node.id, el, false);
       const projectionLines = _nullishCoalesce(projection.lines, () => ( []));
+      const selectionLine = this.contentGridSelectionLine(el);
+      let rebuiltSelectionLine = false;
+      const existingLines = el.children;
       for (let lineIndex = 0; lineIndex < grid.lines.length; lineIndex++) {
         const gridLine = grid.lines[lineIndex];
         const projectedLine = projectionLines[lineIndex];
-        const lineHeight = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _102 => _102.lineHeight]), () => ( grid.lineHeight));
-        const baseline = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _103 => _103.baseline]), () => ( grid.baseline));
-        const lineFont = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _104 => _104.font]), () => ( grid.font));
+        const lineHeight = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _108 => _108.lineHeight]), () => ( grid.lineHeight));
+        const baseline = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _109 => _109.baseline]), () => ( grid.baseline));
+        const lineFont = _nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _110 => _110.font]), () => ( grid.font));
+        const lineSignature = contentGridLineSignature(
+          grid,
+          gridLine,
+          projectedLine,
+          lineHeight,
+          baseline,
+          lineFont,
+          lineIndex === 0
+        );
+        const reusable = existingLines[lineIndex];
+        if (reusable !== void 0 && reusable.dataset.vectoGridLineSig === lineSignature && reusable.dataset.vectoGridLine === `${lineIndex}`) {
+          continue;
+        }
+        if (selectionLine !== null && selectionLine === lineIndex) rebuiltSelectionLine = true;
         const lineElement = document.createElement("span");
+        lineElement.dataset.vectoGridLineSig = lineSignature;
         lineElement.dir = "ltr";
         lineElement.dataset.vectoGridLine = `${lineIndex}`;
         lineElement.style.position = "absolute";
-        lineElement.style.left = `${_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _105 => _105.x]), () => ( 0))}px`;
-        lineElement.style.top = `${(_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _106 => _106.y]), () => ( lineIndex * grid.lineHeight))) + baseline - _text.cssLineBoxBaseline.call(void 0, lineFont, lineHeight)}px`;
+        lineElement.style.left = `${_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _111 => _111.x]), () => ( 0))}px`;
+        lineElement.style.top = `${(_nullishCoalesce(_optionalChain([projectedLine, 'optionalAccess', _112 => _112.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";
@@ -3900,6 +4107,8 @@ var Scene = (_class7 = class _Scene {
             cellElement.style.font = lineFont;
             cellElement.style.lineHeight = `${lineHeight}px`;
             cellElement.style.transformOrigin = "0 50%";
+            cellElement.dataset.vectoGridFont = lineFont;
+            cellElement.dataset.vectoGridLineHeight = `${lineHeight}px`;
             lineElement.appendChild(cellElement);
             logicalX += cell.advance;
           }
@@ -3923,13 +4132,24 @@ var Scene = (_class7 = class _Scene {
             lineElement.appendChild(marker);
           }
         }
-        el.appendChild(lineElement);
+        const occupant = el.children[lineIndex];
+        if (occupant) el.replaceChild(lineElement, occupant);
+        else el.appendChild(lineElement);
+      }
+      while (el.children.length > grid.lines.length) {
+        if (selectionLine !== null && selectionLine >= grid.lines.length) {
+          rebuiltSelectionLine = true;
+        }
+        _optionalChain([el, 'access', _113 => _113.lastElementChild, 'optionalAccess', _114 => _114.remove, 'call', _115 => _115()]);
       }
+      if (rebuiltSelectionLine) this.releaseContentSelectionForRebuild(el);
       el.dataset.vectoProjectionLines = signature;
       el.dataset.vectoContentGrid = signature;
       el.dataset.vectoGridCarriers = `${el.querySelectorAll("[data-vecto-grid-cell]").length}`;
       if (typeof performance !== "undefined") {
-        el.dataset.vectoGridMaterializeMs = `${performance.now() - materializeStart}`;
+        const materializeMs = performance.now() - materializeStart;
+        el.dataset.vectoGridMaterializeMs = `${materializeMs}`;
+        if (this._phaseTiming) this._recordPhase("gridMaterialize", materializeMs);
       }
       delete el.dataset.vectoGridCalibration;
       delete el.dataset.vectoGridReady;
@@ -3937,7 +4157,11 @@ var Scene = (_class7 = class _Scene {
     const pageScaleX = this.getContentMetricScaleX();
     const calibrationKey = `${signature}:${this.contentFontEpoch}:${pageScaleX.toFixed(4)}`;
     if (el.dataset.vectoGridCalibration !== calibrationKey) {
+      const calibStart = this._phaseTiming ? performance.now() : 0;
       this.scheduleContentGridCalibration(node.id, el, calibrationKey, pageScaleX);
+      if (this._phaseTiming) {
+        this._recordPhase("gridCalibrateSchedule", performance.now() - calibStart);
+      }
     }
   }
   getContentMetricScaleX() {
@@ -3955,11 +4179,32 @@ var Scene = (_class7 = class _Scene {
   scheduleContentGridCalibration(entityId, el, calibrationKey, pageScaleX) {
     if (typeof requestAnimationFrame !== "function") return;
     if (el.dataset.vectoGridCalibrationPending === calibrationKey) return;
+    const stamp = `${this.contentFontEpoch}:${pageScaleX.toFixed(4)}`;
+    if (this.contentGridCalibrationStamp !== stamp) {
+      this.contentGridCalibrationStamp = stamp;
+      this.contentGridCalibrationGeneration++;
+    }
+    const generation = `${this.contentGridCalibrationGeneration}`;
+    const pendingCells = el.querySelectorAll(
+      `[data-vecto-grid-cell]:not([data-vecto-grid-calib="${generation}"])`
+    );
+    if (pendingCells.length === 0) {
+      el.dataset.vectoGridCalibrationSamples = "0";
+      delete el.dataset.vectoGridCalibrationPending;
+      const readyFrame = requestAnimationFrame(() => {
+        this.contentGridCalibrationFrames.delete(entityId);
+        if (!el.isConnected) return;
+        el.dataset.vectoGridCalibration = calibrationKey;
+        el.dataset.vectoGridReady = "true";
+      });
+      this.contentGridCalibrationFrames.set(entityId, readyFrame);
+      return;
+    }
     const previous = this.contentGridCalibrationFrames.get(entityId);
     if (previous !== void 0 && typeof cancelAnimationFrame === "function") {
       cancelAnimationFrame(previous);
     }
-    _optionalChain([this, 'access', _107 => _107.contentGridCalibrationProbes, 'access', _108 => _108.get, 'call', _109 => _109(entityId), 'optionalAccess', _110 => _110.remove, 'call', _111 => _111()]);
+    _optionalChain([this, 'access', _116 => _116.contentGridCalibrationProbes, 'access', _117 => _117.get, 'call', _118 => _118(entityId), 'optionalAccess', _119 => _119.remove, 'call', _120 => _120()]);
     this.contentGridCalibrationProbes.delete(entityId);
     const calibrationStart = typeof performance !== "undefined" ? performance.now() : 0;
     const probe = document.createElement("div");
@@ -3985,18 +4230,22 @@ var Scene = (_class7 = class _Scene {
     probe.append(probeOrigin, probeX);
     const measurements = [];
     const measurementsByKey = /* @__PURE__ */ new Map();
-    for (const target of el.querySelectorAll("[data-vecto-grid-cell]")) {
+    const scanStart = this._phaseTiming ? performance.now() : 0;
+    for (const target of pendingCells) {
       const sourceLength = Number(_nullishCoalesce(target.dataset.vectoGridSourceLength, () => ( 0)));
       const targetWidth = Number(_nullishCoalesce(target.dataset.vectoGridAdvance, () => ( 0)));
-      if (sourceLength <= 0 || targetWidth <= 0) continue;
-      const sourceText = _nullishCoalesce(_optionalChain([target, 'access', _112 => _112.textContent, 'optionalAccess', _113 => _113.slice, 'call', _114 => _114(0, sourceLength)]), () => ( ""));
-      if (!sourceText) continue;
-      const measurementKey = JSON.stringify([
-        target.style.font,
-        target.style.lineHeight,
-        targetWidth,
-        sourceText
-      ]);
+      if (sourceLength <= 0 || targetWidth <= 0) {
+        target.dataset.vectoGridCalib = generation;
+        continue;
+      }
+      const sourceText = _nullishCoalesce(_optionalChain([target, 'access', _121 => _121.textContent, 'optionalAccess', _122 => _122.slice, 'call', _123 => _123(0, sourceLength)]), () => ( ""));
+      if (!sourceText) {
+        target.dataset.vectoGridCalib = generation;
+        continue;
+      }
+      const cellFont = _nullishCoalesce(target.dataset.vectoGridFont, () => ( ""));
+      const cellLineHeight = _nullishCoalesce(target.dataset.vectoGridLineHeight, () => ( ""));
+      const measurementKey = JSON.stringify([cellFont, cellLineHeight, targetWidth, sourceText]);
       const shared = measurementsByKey.get(measurementKey);
       if (shared) {
         shared.targets.push(target);
@@ -4008,8 +4257,8 @@ var Scene = (_class7 = class _Scene {
       carrier.style.left = "0";
       carrier.style.top = "0";
       carrier.style.whiteSpace = "pre";
-      carrier.style.font = target.style.font;
-      carrier.style.lineHeight = target.style.lineHeight;
+      carrier.style.font = cellFont;
+      carrier.style.lineHeight = cellLineHeight;
       carrier.style.fontVariantLigatures = "none";
       carrier.style.fontKerning = "none";
       const source = document.createTextNode(sourceText);
@@ -4024,7 +4273,17 @@ var Scene = (_class7 = class _Scene {
       measurements.push(measurement);
       measurementsByKey.set(measurementKey, measurement);
     }
+    if (this._phaseTiming) this._recordPhase("calibScan", performance.now() - scanStart);
+    if (measurements.length === 0) {
+      el.dataset.vectoGridCalibration = calibrationKey;
+      el.dataset.vectoGridReady = "true";
+      el.dataset.vectoGridCalibrationSamples = "0";
+      delete el.dataset.vectoGridCalibrationPending;
+      return;
+    }
+    const appendStart = this._phaseTiming ? performance.now() : 0;
     (_nullishCoalesce(_nullishCoalesce(this.a11yRoot, () => ( document.body)), () => ( document.documentElement))).appendChild(probe);
+    if (this._phaseTiming) this._recordPhase("calibProbeBuild", performance.now() - appendStart);
     el.dataset.vectoGridCalibrationSamples = `${measurements.length}`;
     this.contentGridCalibrationProbes.set(entityId, probe);
     el.dataset.vectoGridCalibrationPending = calibrationKey;
@@ -4068,6 +4327,7 @@ var Scene = (_class7 = class _Scene {
         }
         for (const { element, scale } of updates) {
           element.style.transform = Math.abs(scale - 1) <= 1e-3 ? "" : `scaleX(${scale})`;
+          element.dataset.vectoGridCalib = generation;
         }
         el.dataset.vectoGridCalibration = calibrationKey;
         el.dataset.vectoGridReady = "true";
@@ -4189,12 +4449,12 @@ var Scene = (_class7 = class _Scene {
   syncOverlayGeometry() {
     const parent = this.canvas.parentElement;
     if (!parent) return;
-    const canvasRect = _optionalChain([this, 'access', _115 => _115.canvas, 'access', _116 => _116.getBoundingClientRect, 'optionalCall', _117 => _117()]);
-    const parentRect = _optionalChain([parent, 'access', _118 => _118.getBoundingClientRect, 'optionalCall', _119 => _119()]);
-    const cssWidth = _optionalChain([canvasRect, 'optionalAccess', _120 => _120.width]) || this.canvas.clientWidth || this.width;
-    const cssHeight = _optionalChain([canvasRect, 'optionalAccess', _121 => _121.height]) || this.canvas.clientHeight || this.height;
-    const left = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _122 => _122.left]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _123 => _123.left]), () => ( 0))) - (parent.clientLeft || 0) + parent.scrollLeft;
-    const top = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _124 => _124.top]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _125 => _125.top]), () => ( 0))) - (parent.clientTop || 0) + parent.scrollTop;
+    const canvasRect = _optionalChain([this, 'access', _124 => _124.canvas, 'access', _125 => _125.getBoundingClientRect, 'optionalCall', _126 => _126()]);
+    const parentRect = _optionalChain([parent, 'access', _127 => _127.getBoundingClientRect, 'optionalCall', _128 => _128()]);
+    const cssWidth = _optionalChain([canvasRect, 'optionalAccess', _129 => _129.width]) || this.canvas.clientWidth || this.width;
+    const cssHeight = _optionalChain([canvasRect, 'optionalAccess', _130 => _130.height]) || this.canvas.clientHeight || this.height;
+    const left = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _131 => _131.left]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _132 => _132.left]), () => ( 0))) - (parent.clientLeft || 0) + parent.scrollLeft;
+    const top = (_nullishCoalesce(_optionalChain([canvasRect, 'optionalAccess', _133 => _133.top]), () => ( 0))) - (_nullishCoalesce(_optionalChain([parentRect, 'optionalAccess', _134 => _134.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;
@@ -4333,7 +4593,7 @@ var Scene = (_class7 = class _Scene {
    * (and {@link respectReducedMotion} is on). `0` means uncapped.
    */
   effectiveMaxFPS() {
-    const reduced = this.respectReducedMotion && !!_optionalChain([this, 'access', _126 => _126.reducedMotionQuery, 'optionalAccess', _127 => _127.matches]);
+    const reduced = this.respectReducedMotion && !!_optionalChain([this, 'access', _135 => _135.reducedMotionQuery, 'optionalAccess', _136 => _136.matches]);
     if (reduced)
       return this.maxFPS > 0 ? Math.min(this.maxFPS, REDUCED_MOTION_FPS) : REDUCED_MOTION_FPS;
     return this.maxFPS;
@@ -4373,7 +4633,9 @@ var Scene = (_class7 = class _Scene {
     }
     this._lastRenderTick = time;
     this._lastDt = dt;
+    const phaseClock = this._phaseTiming ? performance.now() : 0;
     this.render(this.renderer, dt, time);
+    if (this._phaseTiming) this._recordPhase("render", performance.now() - phaseClock);
     this._lastFrameMs = (typeof performance !== "undefined" ? performance.now() : time) - now;
     this._renderedFrames++;
     const hasActiveAnimation = this.frameHadAnimation;
@@ -4383,9 +4645,13 @@ var Scene = (_class7 = class _Scene {
     if ((hasInteractive || this.a11yElements.size > 0 || wantsContentSync) && (shouldSyncInterval || this.a11yPendingSyncAfterAnimation)) {
       this.lastA11ySync = time;
       if (hasInteractive || wantsContentSync) {
+        const t0 = this._phaseTiming ? performance.now() : 0;
         this.syncA11y(this.root);
+        if (this._phaseTiming) this._recordPhase("a11ySync", performance.now() - t0);
       }
+      const t1 = this._phaseTiming ? performance.now() : 0;
       this.enforceA11yDomOrder();
+      if (this._phaseTiming) this._recordPhase("a11yOrder", performance.now() - t1);
       this.a11yPendingSyncAfterAnimation = hasActiveAnimation;
     } else if (hasActiveAnimation) {
       this.a11yPendingSyncAfterAnimation = true;
@@ -4400,7 +4666,7 @@ var Scene = (_class7 = class _Scene {
    * @param time - Current absolute time in milliseconds (default 0).
    */
   render(renderer, dt = 0, time = 0) {
-    if (_optionalChain([renderer, 'access', _128 => _128.isContextLost, 'optionalCall', _129 => _129()])) return;
+    if (_optionalChain([renderer, 'access', _137 => _137.isContextLost, 'optionalCall', _138 => _138()])) return;
     const isMainRenderer = renderer === this.renderer;
     if (isMainRenderer && this.a11yRoot && this.canvas.parentElement) {
       const parentStyle = this.canvas.parentElement.style;
@@ -4526,14 +4792,14 @@ var Scene = (_class7 = class _Scene {
     }
     renderer.clear();
     if (isMainRenderer) {
-      _optionalChain([this, 'access', _130 => _130.pointRenderer, 'optionalAccess', _131 => _131.begin, 'call', _132 => _132()]);
+      _optionalChain([this, 'access', _139 => _139.pointRenderer, 'optionalAccess', _140 => _140.begin, 'call', _141 => _141()]);
     }
     const vw = this.width;
     const vh = this.height;
     let walkHadAnimation = false;
     let walkHadInteractive = false;
     const runUpdate = (node) => {
-      const overridesUpdate = node.update !== _chunkIA3KW4CGjs.Entity.prototype.update;
+      const overridesUpdate = node.update !== _chunkAGP4VLF4js.Entity.prototype.update;
       let pending = node.hasPendingAnimations();
       if (pending || overridesUpdate) {
         node.update(dt, time);
@@ -4542,7 +4808,7 @@ var Scene = (_class7 = class _Scene {
       if (pending) walkHadAnimation = true;
       if (!walkHadInteractive && node.interactive) walkHadInteractive = true;
       if (this._devActive && this._devFrameCount % 120 === 0) {
-        if (overridesUpdate && node.hasPendingAnimations === _chunkIA3KW4CGjs.Entity.prototype.hasPendingAnimations) {
+        if (overridesUpdate && node.hasPendingAnimations === _chunkAGP4VLF4js.Entity.prototype.hasPendingAnimations) {
           this._devWarn(
             `Entity "${node.id}" overrides update() but not hasPendingAnimations(). Custom motion in update() without overriding hasPendingAnimations() causes the idle throttle to drop the animation to ~2fps. Override hasPendingAnimations() to return true while motion is in flight.`
           );
@@ -4559,7 +4825,9 @@ var Scene = (_class7 = class _Scene {
       updateWalk(this.root);
       for (const overlay of this.overlayRoot.children) updateWalk(overlay);
     }
+    const wasmT0 = this._phaseTiming ? performance.now() : 0;
     const wasmWorld = wasmMain ? this._syncWasmStore() : null;
+    if (this._phaseTiming) this._recordPhase("transform", performance.now() - wasmT0);
     const wasmSlotEntity = this._slotEntity;
     const renderNode = (node, pa, pb, pc, pd, pe, pf, parentOpacity) => {
       if (isMainRenderer && !wasmMain) {
@@ -4689,7 +4957,13 @@ var Scene = (_class7 = class _Scene {
             );
           }
         } else {
-          node.render(renderer);
+          if (this._phaseTiming) {
+            const t0 = performance.now();
+            node.render(renderer);
+            this._recordPhase("entityPaint", performance.now() - t0);
+          } else {
+            node.render(renderer);
+          }
         }
       }
       if (node.clipChildren) {
@@ -4701,20 +4975,24 @@ var Scene = (_class7 = class _Scene {
       renderer.flush();
       renderer.restore();
     };
+    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 (isMainRenderer) {
       this.frameHadAnimation = walkHadAnimation;
       this.frameHadInteractive = walkHadInteractive;
       this.reconcilePortals();
     }
+    const flushT0 = this._phaseTiming ? performance.now() : 0;
     renderer.flush();
     if (isMainRenderer) {
-      _optionalChain([this, 'access', _133 => _133.pointRenderer, 'optionalAccess', _134 => _134.flush, 'call', _135 => _135()]);
+      _optionalChain([this, 'access', _142 => _142.pointRenderer, 'optionalAccess', _143 => _143.flush, 'call', _144 => _144()]);
     }
-    _optionalChain([renderer, 'access', _136 => _136.present, 'optionalCall', _137 => _137()]);
+    _optionalChain([renderer, 'access', _145 => _145.present, 'optionalCall', _146 => _146()]);
+    if (this._phaseTiming) this._recordPhase("flush", performance.now() - flushT0);
     if (this._devActive) {
       this._devFrameCount++;
       this._devRunChecks();
@@ -4724,7 +5002,7 @@ var Scene = (_class7 = class _Scene {
    * Export the current scene state to a lightweight, flat SVG XML string.
    */
   toSVG() {
-    const renderer = new (0, _chunkL4SWVP2Hjs.SVGRenderer)(this.width, this.height);
+    const renderer = new (0, _chunkGKSCJ6AFjs.SVGRenderer)(this.width, this.height);
     this.render(renderer, 0, 0);
     return renderer.toXMLString();
   }
@@ -4990,6 +5268,41 @@ function intersectBounds(a, b) {
 function pointInBounds(b, x, y) {
   return x >= b.x && x <= b.x + b.width && y >= b.y && y <= b.y + b.height;
 }
+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', _147 => _147.x]), () => ( 0))}`,
+    `${_nullishCoalesce(_optionalChain([projected, 'optionalAccess', _148 => _148.y]), () => ( ""))}`,
+    `${lineHeight}`,
+    `${baseline}`,
+    font,
+    `${line.width}`,
+    // The trailing hard break belongs to this line and lands in the DOM text.
+    grid.source.slice(line.sourceEnd, line.nextSourceStart),
+    // The basis markers are appended only to line 0, so a line moving to or from
+    // index 0 changes its DOM even when nothing else does.
+    isFirstLine ? "1" : "0"
+  ];
+  if (line.cells.length === 0) {
+    parts.push("empty");
+  } else {
+    for (const cell of line.cells) {
+      parts.push(
+        `${cell.sourceStart}`,
+        `${cell.sourceEnd}`,
+        `${cell.x}`,
+        `${cell.advance}`,
+        `${cell.level}`,
+        cell.sourceCaretOffsets.join("."),
+        // Source text, not `cell.glyph`: the carrier holds the original characters
+        // (the shaped glyph is the canvas's business), so a change in shaping alone
+        // must not invalidate a carrier, and a change in source must.
+        grid.source.slice(cell.sourceStart, cell.sourceEnd)
+      );
+    }
+  }
+  return parts.join("
");
+}
 
 // src/components/TextEntity.ts
 
@@ -5001,20 +5314,20 @@ function defaultMeasurer() {
   if (sharedMeasurer === void 0) sharedMeasurer = _layout.createCanvasMeasurer.call(void 0, "sans-serif");
   return sharedMeasurer;
 }
-var TextEntity = (_class8 = class extends _chunkIA3KW4CGjs.Entity {
+var TextEntity = (_class8 = class extends _chunkAGP4VLF4js.Entity {
   
   
   
   
-  __init136() {this.nodes = []}
+  __init140() {this.nodes = []}
   
-  __init137() {this.fillStyle = "#94a3b8"}
-  __init138() {this.strokeStyle = null}
-  __init139() {this.hoveredFillStyle = "#ffffff"}
-  __init140() {this.lineWidth = 1}
-  __init141() {this.isHovered = false}
+  __init141() {this.fillStyle = "#94a3b8"}
+  __init142() {this.strokeStyle = null}
+  __init143() {this.hoveredFillStyle = "#ffffff"}
+  __init144() {this.lineWidth = 1}
+  __init145() {this.isHovered = false}
   constructor(text, atlas, maxWidth, fontSize = 24) {
-    super();_class8.prototype.__init136.call(this);_class8.prototype.__init137.call(this);_class8.prototype.__init138.call(this);_class8.prototype.__init139.call(this);_class8.prototype.__init140.call(this);_class8.prototype.__init141.call(this);;
+    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);;
     this.text = text;
     this.atlas = atlas;
     this.fontSize = fontSize;
@@ -5127,17 +5440,17 @@ var TextEntity = (_class8 = class extends _chunkIA3KW4CGjs.Entity {
 }, _class8);
 
 // src/components/GridTextEntity.ts
-var GridTextEntity = (_class9 = class extends _chunkIA3KW4CGjs.Entity {
+var GridTextEntity = (_class9 = class extends _chunkAGP4VLF4js.Entity {
   
-  __init142() {this.fillStyle = "#ffffff"}
-  __init143() {this.grid = []}
+  __init146() {this.fillStyle = "#ffffff"}
+  __init147() {this.grid = []}
   // Array of rows
-  __init144() {this.cols = 0}
-  __init145() {this.rows = 0}
+  __init148() {this.cols = 0}
+  __init149() {this.rows = 0}
   
   
   constructor(_atlas, fontSize = 10) {
-    super();_class9.prototype.__init142.call(this);_class9.prototype.__init143.call(this);_class9.prototype.__init144.call(this);_class9.prototype.__init145.call(this);;
+    super();_class9.prototype.__init146.call(this);_class9.prototype.__init147.call(this);_class9.prototype.__init148.call(this);_class9.prototype.__init149.call(this);;
     this.fontSize = fontSize;
     this.charWidth = fontSize * 1;
     this.charHeight = fontSize * 1.1;
@@ -5146,7 +5459,7 @@ var GridTextEntity = (_class9 = class extends _chunkIA3KW4CGjs.Entity {
   updateGrid(ascii) {
     this.grid = ascii;
     this.rows = ascii.length;
-    this.cols = _optionalChain([ascii, 'access', _138 => _138[0], 'optionalAccess', _139 => _139.length]) || 0;
+    this.cols = _optionalChain([ascii, 'access', _149 => _149[0], 'optionalAccess', _150 => _150.length]) || 0;
   }
   isPointInside(_globalX, _globalY) {
     return false;
@@ -5221,7 +5534,7 @@ function distSqToSegment(px, py, x1, y1, x2, y2) {
   const ey = py - cy;
   return ex * ex + ey * ey;
 }
-var SplineEntity = (_class10 = class extends _chunkIA3KW4CGjs.Entity {
+var SplineEntity = (_class10 = class extends _chunkAGP4VLF4js.Entity {
   
   
   
@@ -5229,23 +5542,23 @@ var SplineEntity = (_class10 = class extends _chunkIA3KW4CGjs.Entity {
   
   
   
-  __init146() {this.offscreen = null}
-  __init147() {this.baked = false}
+  __init150() {this.offscreen = null}
+  __init151() {this.baked = false}
   /** Logical (CSS-pixel) size of the baked bitmap — the blit destination size. */
-  __init148() {this.bakedWidth = 0}
-  __init149() {this.bakedHeight = 0}
+  __init152() {this.bakedWidth = 0}
+  __init153() {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. */
-  __init150() {this.polylines = null}
+  __init154() {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`.
    */
-  __init151() {this.showBounds = false}
+  __init155() {this.showBounds = false}
   constructor(doc, opts = {}) {
-    super();_class10.prototype.__init146.call(this);_class10.prototype.__init147.call(this);_class10.prototype.__init148.call(this);_class10.prototype.__init149.call(this);_class10.prototype.__init150.call(this);_class10.prototype.__init151.call(this);;
+    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);;
     this.doc = doc;
     this.lineWidth = _nullishCoalesce(opts.lineWidth, () => ( 2));
     this.cache = _nullishCoalesce(opts.cache, () => ( true));
@@ -5256,7 +5569,7 @@ var SplineEntity = (_class10 = class extends _chunkIA3KW4CGjs.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', _140 => _140.doc, 'access', _141 => _141.equations, 'optionalAccess', _142 => _142.some, 'call', _143 => _143((eq) => isGradient(eq.color_rgb))]), () => ( false))) || (_nullishCoalesce(_optionalChain([this, 'access', _144 => _144.doc, 'access', _145 => _145.paths, 'optionalAccess', _146 => _146.some, 'call', _147 => _147((p) => isGradient(p.color_rgb))]), () => ( false)));
+    this.containsGradient = (_nullishCoalesce(_optionalChain([this, 'access', _151 => _151.doc, 'access', _152 => _152.equations, 'optionalAccess', _153 => _153.some, 'call', _154 => _154((eq) => isGradient(eq.color_rgb))]), () => ( false))) || (_nullishCoalesce(_optionalChain([this, 'access', _155 => _155.doc, 'access', _156 => _156.paths, 'optionalAccess', _157 => _157.some, 'call', _158 => _158((p) => isGradient(p.color_rgb))]), () => ( false)));
     this.interactive = true;
   }
   computeBounds() {
@@ -5496,7 +5809,7 @@ async function loadSpline(url) {
 }
 
 // src/components/Rect.ts
-var Rect = class extends _chunkIA3KW4CGjs.Entity {
+var Rect = class extends _chunkAGP4VLF4js.Entity {
   
   
   
@@ -5545,7 +5858,7 @@ var Rect = class extends _chunkIA3KW4CGjs.Entity {
 };
 
 // src/components/Circle.ts
-var Circle = class extends _chunkIA3KW4CGjs.Entity {
+var Circle = class extends _chunkAGP4VLF4js.Entity {
   
   
   
@@ -5605,7 +5918,7 @@ var Circle = class extends _chunkIA3KW4CGjs.Entity {
 };
 
 // src/components/Group.ts
-var Group = class extends _chunkIA3KW4CGjs.Entity {
+var Group = class extends _chunkAGP4VLF4js.Entity {
   constructor(...children) {
     super();
     if (children.length > 0) this.add(...children);
@@ -5624,21 +5937,21 @@ var _math = require('@vectojs/math'); _createStarExport(_math);
 
 
 // src/tree/DOMPortalEntity.ts
-var DOMPortalEntity = (_class11 = class extends _chunkIA3KW4CGjs.Entity {
+var DOMPortalEntity = (_class11 = class extends _chunkAGP4VLF4js.Entity {
   
-  __init152() {this.isDOMPortal = true}
-  __init153() {this.domListeners = []}
-  __init154() {this.resizeObserver = null}
-  __init155() {this.domBound = false}
-  __init156() {this.cachedWidth = 100}
-  __init157() {this.cachedHeight = 100}
-  __init158() {this.lastWidth = ""}
-  __init159() {this.lastHeight = ""}
-  __init160() {this.lastTransform = ""}
-  __init161() {this.lastZIndex = ""}
-  __init162() {this.lastOpacity = ""}
+  __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 = ""}
   constructor(domElement, width, height, id) {
-    super(id);_class11.prototype.__init152.call(this);_class11.prototype.__init153.call(this);_class11.prototype.__init154.call(this);_class11.prototype.__init155.call(this);_class11.prototype.__init156.call(this);_class11.prototype.__init157.call(this);_class11.prototype.__init158.call(this);_class11.prototype.__init159.call(this);_class11.prototype.__init160.call(this);_class11.prototype.__init161.call(this);_class11.prototype.__init162.call(this);;
+    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);;
     this.domElement = domElement;
     this.width = _nullishCoalesce(width, () => ( 0));
     this.height = _nullishCoalesce(height, () => ( 0));
@@ -5680,7 +5993,7 @@ var DOMPortalEntity = (_class11 = class extends _chunkIA3KW4CGjs.Entity {
     ];
     for (const type of events) {
       const handler = (e) => {
-        this.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)(type, this, e));
+        this.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)(type, this, e));
       };
       this.domElement.addEventListener(type, handler);
       this.domListeners.push({ type, handler, capture: false });
@@ -5691,7 +6004,7 @@ var DOMPortalEntity = (_class11 = class extends _chunkIA3KW4CGjs.Entity {
     ];
     for (const { native, vecto } of hoverEvents) {
       const handler = (e) => {
-        this.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)(vecto, this, e, false));
+        this.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)(vecto, this, e, false));
       };
       this.domElement.addEventListener(native, handler);
       this.domListeners.push({ type: native, handler, capture: false });
@@ -5699,7 +6012,7 @@ var DOMPortalEntity = (_class11 = class extends _chunkIA3KW4CGjs.Entity {
     const focusEvents = ["focus", "blur"];
     for (const type of focusEvents) {
       const handler = (e) => {
-        this.dispatchEvent(new (0, _chunkIA3KW4CGjs.VectoJSEvent)(type, this, e, true));
+        this.dispatchEvent(new (0, _chunkAGP4VLF4js.VectoJSEvent)(type, this, e, true));
       };
       this.domElement.addEventListener(type, handler, true);
       this.domListeners.push({ type, handler, capture: true });
@@ -5750,8 +6063,9 @@ var DOMPortalEntity = (_class11 = class extends _chunkIA3KW4CGjs.Entity {
 }, _class11);
 
 // src/index.ts
-Scene.registerWebGLPointRendererCreator(_chunkL4SWVP2Hjs.createWebGLPointRenderer);
-Scene.registerWebGPUParticleSystemManager(_chunkL4SWVP2Hjs.WebGPUParticleSystemManager);
+Scene.registerWebGLPointRendererCreator(_chunkGKSCJ6AFjs.createWebGLPointRenderer);
+Scene.registerWebGPUParticleSystemManager(_chunkGKSCJ6AFjs.WebGPUParticleSystemManager);
+
 
 
 
@@ -5786,4 +6100,4 @@ Scene.registerWebGPUParticleSystemManager(_chunkL4SWVP2Hjs.WebGPUParticleSystemM
 
 
 
-exports.CanvasRenderer = _chunkL4SWVP2Hjs.CanvasRenderer; exports.Circle = Circle; exports.ComputeParticleEntity = ComputeParticleEntity; exports.DOMPortalEntity = DOMPortalEntity; exports.Entity = _chunkIA3KW4CGjs.Entity; exports.GridTextEntity = GridTextEntity; exports.Group = Group; exports.MSDFTextEntity = _chunkIA3KW4CGjs.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 = _chunkIA3KW4CGjs.SVGEntity; exports.SVGRenderer = _chunkL4SWVP2Hjs.SVGRenderer; exports.Scene = Scene; exports.SplineEntity = SplineEntity; exports.TextEntity = TextEntity; exports.TextRasterCache = _chunkL4SWVP2Hjs.TextRasterCache; exports.VectoJSEvent = _chunkIA3KW4CGjs.VectoJSEvent; exports.WebGPUParticleSystemManager = _chunkL4SWVP2Hjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkL4SWVP2Hjs.createWebGLPointRenderer; exports.isSafeUrl = _chunkL4SWVP2Hjs.isSafeUrl; exports.loadSpline = loadSpline; exports.parseColorToRGBA = _chunkL4SWVP2Hjs.parseColorToRGBA; exports.polySegmentToBezier = polySegmentToBezier; exports.sanitizeUrl = _chunkL4SWVP2Hjs.sanitizeUrl;
+exports.CanvasRenderer = _chunkGKSCJ6AFjs.CanvasRenderer; exports.Circle = Circle; exports.ComputeParticleEntity = ComputeParticleEntity; exports.DOMPortalEntity = DOMPortalEntity; exports.Entity = _chunkAGP4VLF4js.Entity; exports.GlyphRasterAtlas = _chunkGKSCJ6AFjs.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 = _chunkGKSCJ6AFjs.SVGRenderer; exports.Scene = Scene; exports.SplineEntity = SplineEntity; exports.TextEntity = TextEntity; exports.TextRasterCache = _chunkGKSCJ6AFjs.TextRasterCache; exports.VectoJSEvent = _chunkAGP4VLF4js.VectoJSEvent; exports.WebGPUParticleSystemManager = _chunkGKSCJ6AFjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkGKSCJ6AFjs.createWebGLPointRenderer; exports.isSafeUrl = _chunkGKSCJ6AFjs.isSafeUrl; exports.loadSpline = loadSpline; exports.parseColorToRGBA = _chunkGKSCJ6AFjs.parseColorToRGBA; exports.polySegmentToBezier = polySegmentToBezier; exports.sanitizeUrl = _chunkGKSCJ6AFjs.sanitizeUrl;