@vectojs/core 0.2.7 → 0.2.9

package/dist/{chunk-GTQRCY6W.js → chunk-BPMNCGU7.js}

@@ -701,6 +701,7 @@ var SVGRenderer = (_class2 = class {
 }, _class2);
 
 // src/renderer/colorParse.ts
+var CACHE_MAX = 1e3;
 var cache = /* @__PURE__ */ new Map();
 var fallbackCtx;
 function fromHex(hex) {
@@ -744,10 +745,17 @@ function fromCanvas(css) {
 }
 function parseColorToRGBA(css) {
   const hit = cache.get(css);
-  if (hit) return hit;
+  if (hit) {
+    cache.delete(css);
+    cache.set(css, hit);
+    return hit;
+  }
   const trimmed = css.trim();
   const rgba = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce((trimmed[0] === "#" ? fromHex(trimmed) : null), () => ( fromRgbFunc(trimmed))), () => ( fromCanvas(trimmed))), () => ( [0, 0, 0, 1]));
   cache.set(css, rgba);
+  if (cache.size > CACHE_MAX) {
+    cache.delete(cache.keys().next().value);
+  }
   return rgba;
 }
 
@@ -825,6 +833,19 @@ void main() {
   vec4 t = texture(u_tex, v_uv);
   outColor = vec4(t.rgb * v_tint.rgb, t.a * v_tint.a);
 }`;
+var CIRCLE_QUAD_FRAG = `#version 300 es
+precision mediump float;
+in vec2 v_uv;
+in vec4 v_tint;
+out vec4 outColor;
+void main() {
+  vec2 c = v_uv - 0.5;
+  float d = length(c);
+  float aa = fwidth(d);
+  float alpha = 1.0 - smoothstep(0.5 - aa, 0.5, d);
+  if (alpha <= 0.0) discard;
+  outColor = vec4(v_tint.rgb, v_tint.a * alpha);
+}`;
 var MSDF_FRAG = `#version 300 es
 precision mediump float;
 uniform sampler2D u_tex;
@@ -891,7 +912,9 @@ function createWebGLPointRenderer(canvas) {
   const rectProgram = link(gl, RECT_VERT, RECT_FRAG);
   const spriteProgram = link(gl, SPRITE_VERT, SPRITE_FRAG);
   const msdfProgram = link(gl, SPRITE_VERT, MSDF_FRAG);
-  if (!pointProgram || !rectProgram || !spriteProgram || !msdfProgram) return null;
+  const circleQuadProgram = link(gl, SPRITE_VERT, CIRCLE_QUAD_FRAG);
+  if (!pointProgram || !rectProgram || !spriteProgram || !msdfProgram || !circleQuadProgram)
+    return null;
   gl.enable(gl.BLEND);
   gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
   const pAPos = gl.getAttribLocation(pointProgram, "a_pos");
@@ -951,6 +974,20 @@ function createWebGLPointRenderer(canvas) {
   gl.vertexAttribPointer(gAUv, 2, gl.FLOAT, false, SPRITE_VERT_STRIDE, 8);
   gl.enableVertexAttribArray(gATint);
   gl.vertexAttribPointer(gATint, 4, gl.FLOAT, false, SPRITE_VERT_STRIDE, 16);
+  const cAPos = gl.getAttribLocation(circleQuadProgram, "a_pos");
+  const cAUv = gl.getAttribLocation(circleQuadProgram, "a_uv");
+  const cATint = gl.getAttribLocation(circleQuadProgram, "a_tint");
+  const cURes = gl.getUniformLocation(circleQuadProgram, "u_resolution");
+  const circleQuadBuffer = gl.createBuffer();
+  const circleQuadVAO = gl.createVertexArray();
+  gl.bindVertexArray(circleQuadVAO);
+  gl.bindBuffer(gl.ARRAY_BUFFER, circleQuadBuffer);
+  gl.enableVertexAttribArray(cAPos);
+  gl.vertexAttribPointer(cAPos, 2, gl.FLOAT, false, SPRITE_VERT_STRIDE, 0);
+  gl.enableVertexAttribArray(cAUv);
+  gl.vertexAttribPointer(cAUv, 2, gl.FLOAT, false, SPRITE_VERT_STRIDE, 8);
+  gl.enableVertexAttribArray(cATint);
+  gl.vertexAttribPointer(cATint, 4, gl.FLOAT, false, SPRITE_VERT_STRIDE, 16);
   gl.bindVertexArray(null);
   let texture = null;
   let textureSource = null;
@@ -965,10 +1002,16 @@ function createWebGLPointRenderer(canvas) {
   let spriteCount = 0;
   let glyphData = new Float32Array(FLOATS_PER_SPRITE_VERT * VERTS_PER_SPRITE * 1024);
   let glyphCount = 0;
+  let circleQuadData = new Float32Array(
+    FLOATS_PER_SPRITE_VERT * VERTS_PER_SPRITE * 64
+  );
+  let circleQuadCount = 0;
   let logicalW = 0;
   let logicalH = 0;
   let dpr = 1;
   let destroyed = false;
+  const pointSizeRange = typeof gl.getParameter === "function" ? gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE) : null;
+  const maxPointSize = pointSizeRange ? pointSizeRange[1] : Infinity;
   const drawGlyphs = () => {
     if (glyphCount === 0 || !msdfTexture) return;
     const floats = glyphCount * VERTS_PER_SPRITE * FLOATS_PER_SPRITE_VERT;
@@ -1001,6 +1044,7 @@ function createWebGLPointRenderer(canvas) {
       rectCount = 0;
       spriteCount = 0;
       glyphCount = 0;
+      circleQuadCount = 0;
       gl.clearColor(0, 0, 0, 0);
       gl.clear(gl.COLOR_BUFFER_BIT);
     },
@@ -1108,6 +1152,35 @@ function createWebGLPointRenderer(canvas) {
       glyphCount++;
     },
     addCircle(x, y, radius, color, alpha = 1) {
+      const needsQuad = logicalW > 0 && (x < radius || y < radius || x > logicalW - radius || y > logicalH - radius) || radius * 2 * dpr > maxPointSize;
+      if (needsQuad) {
+        const stride = FLOATS_PER_SPRITE_VERT * VERTS_PER_SPRITE;
+        circleQuadData = grow(circleQuadData, (circleQuadCount + 1) * stride);
+        const [qr, qg, qb, qa] = parseColorToRGBA(color);
+        const al = qa * alpha;
+        const quad = [
+          [x - radius, y - radius, 0, 0],
+          [x + radius, y - radius, 1, 0],
+          [x + radius, y + radius, 1, 1],
+          [x - radius, y + radius, 0, 1]
+        ];
+        const order = [0, 1, 2, 0, 2, 3];
+        let o2 = circleQuadCount * stride;
+        for (const i of order) {
+          const [vx, vy, vu, vv] = quad[i];
+          circleQuadData[o2] = vx;
+          circleQuadData[o2 + 1] = vy;
+          circleQuadData[o2 + 2] = vu;
+          circleQuadData[o2 + 3] = vv;
+          circleQuadData[o2 + 4] = qr;
+          circleQuadData[o2 + 5] = qg;
+          circleQuadData[o2 + 6] = qb;
+          circleQuadData[o2 + 7] = al;
+          o2 += FLOATS_PER_SPRITE_VERT;
+        }
+        circleQuadCount++;
+        return;
+      }
       pointData = grow(pointData, (pointCount + 1) * FLOATS_PER_POINT);
       const [r, g, b, a] = parseColorToRGBA(color);
       const o = pointCount * FLOATS_PER_POINT;
@@ -1171,6 +1244,15 @@ function createWebGLPointRenderer(canvas) {
         gl.uniform1f(pUDpr, dpr);
         gl.drawArrays(gl.POINTS, 0, pointCount);
       }
+      if (circleQuadCount > 0) {
+        const floats = circleQuadCount * VERTS_PER_SPRITE * FLOATS_PER_SPRITE_VERT;
+        gl.useProgram(circleQuadProgram);
+        gl.bindVertexArray(circleQuadVAO);
+        gl.bindBuffer(gl.ARRAY_BUFFER, circleQuadBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, circleQuadData.subarray(0, floats), gl.DYNAMIC_DRAW);
+        gl.uniform2f(cURes, logicalW, logicalH);
+        gl.drawArrays(gl.TRIANGLES, 0, circleQuadCount * VERTS_PER_SPRITE);
+      }
       if (spriteCount > 0 && texture) {
         const floats = spriteCount * VERTS_PER_SPRITE * FLOATS_PER_SPRITE_VERT;
         gl.useProgram(spriteProgram);
@@ -1193,14 +1275,17 @@ function createWebGLPointRenderer(canvas) {
       gl.deleteBuffer(rectBuffer);
       gl.deleteBuffer(spriteBuffer);
       gl.deleteBuffer(glyphBuffer);
+      gl.deleteBuffer(circleQuadBuffer);
       gl.deleteVertexArray(pointVAO);
       gl.deleteVertexArray(rectVAO);
       gl.deleteVertexArray(spriteVAO);
       gl.deleteVertexArray(glyphVAO);
+      gl.deleteVertexArray(circleQuadVAO);
       gl.deleteProgram(pointProgram);
       gl.deleteProgram(rectProgram);
       gl.deleteProgram(spriteProgram);
       gl.deleteProgram(msdfProgram);
+      gl.deleteProgram(circleQuadProgram);
       if (texture) gl.deleteTexture(texture);
       if (msdfTexture) gl.deleteTexture(msdfTexture);
     }

package/dist/{chunk-SSOP3F5F.mjs → chunk-FNXOS7IA.mjs}

@@ -32,6 +32,13 @@ function computeLineSegments(top, bottom, maxWidth, exclusions) {
 }
 var LayoutEngine = class {
   maxWidth;
+  /**
+   * Horizontal alignment. `'justify'` stretches inter-word spaces (or, for
+   * space-less CJK lines, inter-character gaps) so wrapped lines end flush at
+   * `maxWidth`; the last line of each paragraph stays ragged. Only applies to
+   * the object layout path without exclusion shapes.
+   */
+  textAlign = "left";
   maxHeight;
   preserveLeadingSpaces = false;
   wordSegmenter;
@@ -50,6 +57,22 @@ var LayoutEngine = class {
   richParagraphCache = /* @__PURE__ */ new Map();
   lastAtlas = null;
   measurer;
+  _hyphenate = null;
+  /**
+   * Optional hyphenator: given a word, return its break parts (e.g.
+   * `['hyphen', 'ation']`). Used at wrap time when a word doesn't fit; a
+   * visible '-' is drawn at the chosen break. Soft hyphens (U+00AD) in the
+   * source work without any hyphenator. Setting this clears the prepared
+   * caches (break opportunities are baked in during prepare()).
+   */
+  get hyphenate() {
+    return this._hyphenate;
+  }
+  set hyphenate(fn) {
+    this._hyphenate = fn;
+    this.paragraphCache.clear();
+    this.richParagraphCache.clear();
+  }
   constructor(maxWidth, maxHeight, measurer) {
     this.maxWidth = maxWidth;
     this.maxHeight = maxHeight;
@@ -157,7 +180,13 @@ var LayoutEngine = class {
         const word = segment.segment;
         const glyphs = [];
         let width = 0;
+        let breakPoints;
         for (const char of this.getGraphemes(word)) {
+          if (char === "\xAD") {
+            (breakPoints ??= []).push(glyphs.length);
+            shapedCharIdx += char.length;
+            continue;
+          }
           const visualStart = shapedCharIdx;
           const visualEnd = shapedCharIdx + char.length;
           const rawStart = indexMap[visualStart];
@@ -182,11 +211,23 @@ var LayoutEngine = class {
           width += w;
           shapedCharIdx += char.length;
         }
+        if (!breakPoints && this._hyphenate && segment.isWordLike && glyphs.length > 3) {
+          const parts = this._hyphenate(word);
+          if (parts.length > 1) {
+            breakPoints = [];
+            let count = 0;
+            for (let pi = 0; pi < parts.length - 1; pi++) {
+              for (const _g of this.getGraphemes(parts[pi])) count++;
+              breakPoints.push(count);
+            }
+          }
+        }
         words.push({
           glyphs,
           width,
           isWordLike: segment.isWordLike,
-          isWhitespace: word.trim().length === 0
+          isWhitespace: word.trim().length === 0,
+          breakPoints
         });
       }
       const prepared = {
@@ -200,7 +241,12 @@ var LayoutEngine = class {
       paragraphs.push(prepared);
       offset += paragraph.length + 1;
     }
-    return { paragraphs, fontSize, fallbackToCanvas: fallbackToCanvas || void 0 };
+    return {
+      paragraphs,
+      fontSize,
+      fallbackToCanvas: fallbackToCanvas || void 0,
+      hyphenWidth: this.glyphWidth(this.glyphKeyFor("-", fontAtlas), fontAtlas, fontSize)
+    };
   }
   /**
    * **Cold pass for rich text.** Like {@link prepare}, but takes an array of
@@ -274,7 +320,13 @@ var LayoutEngine = class {
         const word = segment.segment;
         const glyphs = [];
         let width = 0;
+        let breakPoints;
         for (const char of this.getGraphemes(word)) {
+          if (char === "\xAD") {
+            (breakPoints ??= []).push(glyphs.length);
+            shapedCharIdx += char.length;
+            continue;
+          }
           const visualStart = shapedCharIdx;
           const visualEnd = shapedCharIdx + char.length;
           const rawStart = indexMap[visualStart];
@@ -302,11 +354,23 @@ var LayoutEngine = class {
           width += w;
           shapedCharIdx += char.length;
         }
+        if (!breakPoints && this._hyphenate && segment.isWordLike && glyphs.length > 3) {
+          const parts = this._hyphenate(word);
+          if (parts.length > 1) {
+            breakPoints = [];
+            let count = 0;
+            for (let pi = 0; pi < parts.length - 1; pi++) {
+              for (const _g of this.getGraphemes(parts[pi])) count++;
+              breakPoints.push(count);
+            }
+          }
+        }
         words.push({
           glyphs,
           width,
           isWordLike: segment.isWordLike,
-          isWhitespace: word.trim().length === 0
+          isWhitespace: word.trim().length === 0,
+          breakPoints
         });
       }
       const prepared = {
@@ -350,7 +414,7 @@ var LayoutEngine = class {
     let si = 0;
     let currentLineNodes = [];
     let paragraphBaseLevel = 0;
-    const commitLine = () => {
+    const commitLine = (justifyTo) => {
       if (currentLineNodes.length === 0) return;
       const runs = [];
       let currentRun = [];
@@ -375,6 +439,37 @@ var LayoutEngine = class {
           node.isRTL = node.level % 2 === 1;
           x += node.width;
         }
+        if (justifyTo !== void 0 && runs.length === 1) {
+          let lastContent = run.length - 1;
+          while (lastContent >= 0 && run[lastContent].char.trim() === "") lastContent--;
+          if (lastContent > 0) {
+            const contentEnd = run[lastContent].x + run[lastContent].width;
+            const slack = justifyTo - contentEnd;
+            if (slack > 0 && slack <= (justifyTo - runStartX) * 0.5) {
+              const spaceIdx = [];
+              for (let k = 1; k < lastContent; k++) {
+                if (run[k].char.trim() === "") spaceIdx.push(k);
+              }
+              if (spaceIdx.length > 0) {
+                const extra = slack / spaceIdx.length;
+                let shift = 0;
+                let nextSpace = 0;
+                for (let k = 0; k <= lastContent; k++) {
+                  run[k].x += shift;
+                  if (nextSpace < spaceIdx.length && k === spaceIdx[nextSpace]) {
+                    run[k].width += extra;
+                    shift += extra;
+                    nextSpace++;
+                  }
+                }
+              } else {
+                const extra = slack / lastContent;
+                for (let k = 1; k <= lastContent; k++) run[k].x += extra * k;
+              }
+              if (justifyTo > maxLineWidth) maxLineWidth = justifyTo;
+            }
+          }
+        }
         for (const node of run) {
           layoutNodes.push(node);
         }
@@ -394,6 +489,8 @@ var LayoutEngine = class {
       }
       return false;
     };
+    const justifyTarget = this.textAlign === "justify" && !hasEx ? this.maxWidth : void 0;
+    const hyphenWidth = prepared.hyphenWidth ?? fontSize * 0.3;
     for (const paragraph of prepared.paragraphs) {
       if (paragraph.isEmpty) {
         commitLine();
@@ -411,16 +508,65 @@ var LayoutEngine = class {
       }
       const lineHeight = pMax * 1.5;
       if (!startLine(lineHeight)) break;
-      for (const word of paragraph.words) {
-        if (currentX + word.width > segs[si].x1 && currentX > segs[si].x0) {
-          if (word.isWordLike === false && word.isWhitespace) continue;
-          if (si < segs.length - 1) {
-            si++;
-            currentX = segs[si].x0;
-          } else {
-            commitLine();
-            currentY += lineHeight;
-            if (!startLine(lineHeight)) break;
+      const wordQueue = paragraph.words.slice();
+      for (let qi = 0; qi < wordQueue.length; qi++) {
+        const word = wordQueue[qi];
+        if (currentX + word.width > segs[si].x1) {
+          if (!hasEx && word.breakPoints && word.breakPoints.length > 0) {
+            const avail = segs[si].x1 - currentX;
+            let chosen = -1;
+            let prefixWidth = 0;
+            let acc = 0;
+            let bpIdx = 0;
+            for (let g = 0; g < word.glyphs.length && bpIdx < word.breakPoints.length; g++) {
+              acc += word.glyphs[g].width;
+              if (g + 1 === word.breakPoints[bpIdx]) {
+                if (acc + hyphenWidth <= avail) {
+                  chosen = word.breakPoints[bpIdx];
+                  prefixWidth = acc;
+                }
+                bpIdx++;
+              }
+            }
+            if (chosen > 0) {
+              const anchorGlyph = word.glyphs[chosen - 1];
+              const prefix = {
+                glyphs: [
+                  ...word.glyphs.slice(0, chosen),
+                  {
+                    char: "-",
+                    width: hyphenWidth,
+                    level: anchorGlyph.level,
+                    sourceIndex: anchorGlyph.sourceIndex,
+                    sourceLength: 0
+                  }
+                ],
+                width: prefixWidth + hyphenWidth,
+                isWordLike: true,
+                isWhitespace: false
+              };
+              const rest = {
+                glyphs: word.glyphs.slice(chosen),
+                width: word.width - prefixWidth,
+                isWordLike: true,
+                isWhitespace: false,
+                breakPoints: word.breakPoints.filter((bp) => bp > chosen).map((bp) => bp - chosen)
+              };
+              wordQueue.splice(qi, 1, prefix, rest);
+              qi--;
+              continue;
+            }
+          }
+          if (currentX > segs[si].x0) {
+            if (word.isWordLike === false && word.isWhitespace) continue;
+            if (si < segs.length - 1) {
+              si++;
+              currentX = segs[si].x0;
+            } else {
+              commitLine(justifyTarget);
+              currentY += lineHeight;
+              if (!startLine(lineHeight)) break;
+            }
           }
         }
         for (const glyph of word.glyphs) {
@@ -433,7 +579,7 @@ var LayoutEngine = class {
                 si++;
                 currentX = segs[si].x0;
               } else {
-                commitLine();
+                commitLine(justifyTarget);
                 currentY += lineHeight;
                 if (!startLine(lineHeight)) break;
               }

package/dist/{chunk-YVN3PJRC.mjs → chunk-PY4KGL5Y.mjs}

@@ -360,10 +360,21 @@ var Entity = class {
   /**
    * Append a child entity to this node's children array.
    *
+   * If `child` already has a parent (including `this`), it's detached from it
+   * first — otherwise re-adding an already-added child duplicates it in
+   * `children[]` (one `remove()` call only strips the first occurrence,
+   * leaving a stale entry that keeps rendering/updating despite
+   * `child.parent` reporting `null`), and re-parenting to a different entity
+   * without an explicit `remove()` first leaves the old parent holding a
+   * stale reference whose own `.parent` disagrees with where it now lives.
+   * `child.parent` is only ever `null` or `this`'s ultimate owner, so this
+   * check is O(1) for the overwhelming common case (a brand-new entity).
+   *
    * @param child - The entity to add as a child.
    * @returns `this` for method chaining.
    */
   add(child) {
+    if (child.parent) child.parent.remove(child);
     child.parent = this;
     this.children.push(child);
     const s = this.scene;
@@ -434,6 +445,7 @@ var Entity = class {
       startTime: -1,
       startProps: {}
     });
+    this.scene?.markDirty();
     return this;
   }
   /** Write a driver-computed value to a backing field without re-triggering the setter. */
@@ -715,9 +727,9 @@ var Entity = class {
    * Return the exact accumulated Canvas `T * S * R` transform for this entity.
    */
   getWorldTransform() {
-    const path = this.id === "root" ? [] : [this];
+    const path = [this];
     let ancestor = this.parent;
-    while (ancestor && ancestor.id !== "root") {
+    while (ancestor) {
       path.push(ancestor);
       ancestor = ancestor.parent;
     }
@@ -801,8 +813,8 @@ var Entity = class {
   }
   /**
    * Accumulated world scale factors: this entity's own `scaleX`/`scaleY` times
-   * those of every ancestor (excluding the scene root). Useful for mapping a
-   * world-space point back into local space for hit-testing.
+   * those of every ancestor. Useful for mapping a world-space point back into
+   * local space for hit-testing.
    *
    * @returns The world scale `{ x, y }`.
    */
@@ -810,7 +822,7 @@ var Entity = class {
     let sx = this.scaleX;
     let sy = this.scaleY;
     let curr = this.parent;
-    while (curr && curr.id !== "root") {
+    while (curr) {
       sx *= curr.scaleX;
       sy *= curr.scaleY;
       curr = curr.parent;
@@ -819,14 +831,14 @@ var Entity = class {
   }
   /**
    * Accumulated world rotation: this entity's own `rotation` plus
-   * that of every ancestor (excluding the scene root).
+   * that of every ancestor.
    *
    * @returns The accumulated world rotation in radians.
    */
   getWorldRotation() {
     let rot = this.rotation;
     let curr = this.parent;
-    while (curr && curr.id !== "root") {
+    while (curr) {
       rot += curr.rotation;
       curr = curr.parent;
     }

package/dist/{chunk-DWMQYHNC.js → chunk-U4UYRERW.js}

@@ -360,10 +360,21 @@ var Entity = (_class4 = class {
   /**
    * Append a child entity to this node's children array.
    *
+   * If `child` already has a parent (including `this`), it's detached from it
+   * first — otherwise re-adding an already-added child duplicates it in
+   * `children[]` (one `remove()` call only strips the first occurrence,
+   * leaving a stale entry that keeps rendering/updating despite
+   * `child.parent` reporting `null`), and re-parenting to a different entity
+   * without an explicit `remove()` first leaves the old parent holding a
+   * stale reference whose own `.parent` disagrees with where it now lives.
+   * `child.parent` is only ever `null` or `this`'s ultimate owner, so this
+   * check is O(1) for the overwhelming common case (a brand-new entity).
+   *
    * @param child - The entity to add as a child.
    * @returns `this` for method chaining.
    */
   add(child) {
+    if (child.parent) child.parent.remove(child);
     child.parent = this;
     this.children.push(child);
     const s = this.scene;
@@ -434,6 +445,7 @@ var Entity = (_class4 = class {
       startTime: -1,
       startProps: {}
     });
+    _optionalChain([this, 'access', _40 => _40.scene, 'optionalAccess', _41 => _41.markDirty, 'call', _42 => _42()]);
     return this;
   }
   /** Write a driver-computed value to a backing field without re-triggering the setter. */
@@ -489,10 +501,10 @@ var Entity = (_class4 = class {
     const active = driver;
     const onDone = active.onDone;
     active.onDone = void 0;
-    _optionalChain([onDone, 'optionalCall', _40 => _40()]);
+    _optionalChain([onDone, 'optionalCall', _43 => _43()]);
   }
   _spawnDriver(prop, to, cfg) {
-    if (prop !== "opacity" && _optionalChain([this, 'access', _41 => _41.scene, 'optionalAccess', _42 => _42.prefersReducedMotion])) {
+    if (prop !== "opacity" && _optionalChain([this, 'access', _44 => _44.scene, 'optionalAccess', _45 => _45.prefersReducedMotion])) {
       const existing2 = this._drivers.get(prop);
       if (existing2) this._settleDriver(existing2);
       this._drivers.delete(prop);
@@ -508,11 +520,11 @@ var Entity = (_class4 = class {
     const from = this._currentOf(prop);
     const driver = isTweenConfig(cfg) ? new TweenDriver(from, to, cfg) : new SpringDriver(from, to, cfg === "spring" ? {} : cfg);
     this._drivers.set(prop, driver);
-    _optionalChain([this, 'access', _43 => _43.scene, 'optionalAccess', _44 => _44.markDirty, 'call', _45 => _45()]);
+    _optionalChain([this, 'access', _46 => _46.scene, 'optionalAccess', _47 => _47.markDirty, 'call', _48 => _48()]);
   }
   /** Assignment path when a declarative transition is configured for `prop`. */
   _animateProp(prop, to) {
-    const cfg = _optionalChain([this, 'access', _46 => _46._transitions, 'optionalAccess', _47 => _47.get, 'call', _48 => _48(prop)]);
+    const cfg = _optionalChain([this, 'access', _49 => _49._transitions, 'optionalAccess', _50 => _50.get, 'call', _51 => _51(prop)]);
     if (!cfg) {
       this._applyAnimated(prop, to);
       return;
@@ -562,7 +574,7 @@ var Entity = (_class4 = class {
         this._applyAnimated(prop, driver.value);
       }
     }
-    _optionalChain([this, 'access', _49 => _49.scene, 'optionalAccess', _50 => _50.markDirty, 'call', _51 => _51()]);
+    _optionalChain([this, 'access', _52 => _52.scene, 'optionalAccess', _53 => _53.markDirty, 'call', _54 => _54()]);
   }
   /**
    * Advance the entity's internal state for one frame.
@@ -616,7 +628,7 @@ var Entity = (_class4 = class {
    * @example entity.on('click', (e) => console.log('clicked', e));
    */
   on(event, callback, options) {
-    const map = _optionalChain([options, 'optionalAccess', _52 => _52.capture]) ? this.captureListeners : this.listeners;
+    const map = _optionalChain([options, 'optionalAccess', _55 => _55.capture]) ? this.captureListeners : this.listeners;
     if (!map.has(event)) {
       map.set(event, []);
     }
@@ -632,7 +644,7 @@ var Entity = (_class4 = class {
    * @returns `this` for method chaining.
    */
   off(event, callback, options) {
-    const handlers = (_optionalChain([options, 'optionalAccess', _53 => _53.capture]) ? this.captureListeners : this.listeners).get(event);
+    const handlers = (_optionalChain([options, 'optionalAccess', _56 => _56.capture]) ? this.captureListeners : this.listeners).get(event);
     if (handlers) {
       const idx = handlers.indexOf(callback);
       if (idx !== -1) handlers.splice(idx, 1);
@@ -715,9 +727,9 @@ var Entity = (_class4 = class {
    * Return the exact accumulated Canvas `T * S * R` transform for this entity.
    */
   getWorldTransform() {
-    const path = this.id === "root" ? [] : [this];
+    const path = [this];
     let ancestor = this.parent;
-    while (ancestor && ancestor.id !== "root") {
+    while (ancestor) {
       path.push(ancestor);
       ancestor = ancestor.parent;
     }
@@ -801,8 +813,8 @@ var Entity = (_class4 = class {
   }
   /**
    * Accumulated world scale factors: this entity's own `scaleX`/`scaleY` times
-   * those of every ancestor (excluding the scene root). Useful for mapping a
-   * world-space point back into local space for hit-testing.
+   * those of every ancestor. Useful for mapping a world-space point back into
+   * local space for hit-testing.
    *
    * @returns The world scale `{ x, y }`.
    */
@@ -810,7 +822,7 @@ var Entity = (_class4 = class {
     let sx = this.scaleX;
     let sy = this.scaleY;
     let curr = this.parent;
-    while (curr && curr.id !== "root") {
+    while (curr) {
       sx *= curr.scaleX;
       sy *= curr.scaleY;
       curr = curr.parent;
@@ -819,14 +831,14 @@ var Entity = (_class4 = class {
   }
   /**
    * Accumulated world rotation: this entity's own `rotation` plus
-   * that of every ancestor (excluding the scene root).
+   * that of every ancestor.
    *
    * @returns The accumulated world rotation in radians.
    */
   getWorldRotation() {
     let rot = this.rotation;
     let curr = this.parent;
-    while (curr && curr.id !== "root") {
+    while (curr) {
       rot += curr.rotation;
       curr = curr.parent;
     }
@@ -1076,7 +1088,7 @@ var MSDFTextEntity = (_class6 = class extends Entity {
         if (res.seqId < this.lastRenderedSeqId) return;
         this.lastRenderedSeqId = res.seqId;
         this.layoutResult = res;
-        _optionalChain([this, 'access', _54 => _54.scene, 'optionalAccess', _55 => _55.markDirty, 'call', _56 => _56()]);
+        _optionalChain([this, 'access', _57 => _57.scene, 'optionalAccess', _58 => _58.markDirty, 'call', _59 => _59()]);
       }
     });
   }