@vectojs/core 1.29.0 → 1.31.0

package/dist/index.mjs

@@ -16,8 +16,9 @@ import {
   Entity,
   MSDFTextEntity,
   SVGEntity,
-  VectoJSEvent
-} from "./chunk-MVFPN4Y5.mjs";
+  VectoJSEvent,
+  contentLineInHint
+} from "./chunk-RWN3ITBD.mjs";
 
 // src/tree/Scene.ts
 import { SpringDriver, TweenDriver } from "@vectojs/animation";
@@ -1378,6 +1379,7 @@ var SCENE_OPTION_KEYS = [
   "autoThrottle",
   "contentProjection",
   "contentProjectionMargin",
+  "contentSemanticMargin",
   "debugA11y",
   "disableWindowResize",
   "maxDPR",
@@ -1430,6 +1432,45 @@ function parseInlinePx(value) {
   const n = parseFloat(value);
   return Number.isFinite(n) && n > 0 ? n : null;
 }
+function projectionGridLineWindow(grid, projectionLines, band) {
+  const count = grid.lines.length;
+  const all = { start: 0, end: count, gated: false };
+  if (!band || count === 0) return all;
+  const lines = [];
+  for (let i = 0; i < count; i++) {
+    const projected = projectionLines?.[i];
+    lines.push({
+      y: projected?.y ?? i * grid.lineHeight,
+      lineHeight: projected?.lineHeight ?? grid.lineHeight
+    });
+  }
+  return projectionLineWindow(lines, band, grid.lineHeight);
+}
+function projectionLineWindow(lines, band, fallbackLineHeight) {
+  const all = {
+    start: 0,
+    end: lines.length,
+    gated: false
+  };
+  if (!band || lines.length === 0) return all;
+  let start = -1;
+  let end = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const h = line.lineHeight ?? fallbackLineHeight;
+    if (line.y + h >= band.minY && line.y <= band.maxY) {
+      if (start === -1) start = i;
+      end = i + 1;
+    } else if (start !== -1 && line.y > band.maxY) {
+      break;
+    }
+  }
+  if (start === -1) {
+    return { start: 0, end: Math.min(1, lines.length), gated: true };
+  }
+  if (start === 0 && end === lines.length) return all;
+  return { start, end, gated: true };
+}
 function collectTextNodes(root) {
   const out = [];
   const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
@@ -1916,6 +1957,15 @@ var Scene = class _Scene {
   a11yElements = /* @__PURE__ */ new Map();
   /** DOM nodes mirroring static text content, keyed by entity id. */
   contentElements = /* @__PURE__ */ new Map();
+  /**
+   * What the last completed content-projection sync was built from, per entity.
+   *
+   * Compared at the top of {@link syncContentProjection} to skip a block whose
+   * content AND geometry are both unchanged, before the O(glyphs) projection
+   * build. Only populated for entities that opt in via
+   * {@link Entity.getContentEpoch}. (carryctx CTX-0199)
+   */
+  contentSyncState = /* @__PURE__ */ new Map();
   /** Pending cold font-calibration frame per projected grid entity. */
   contentGridCalibrationFrames = /* @__PURE__ */ new Map();
   /** Detached, untransformed font probes used by the cold calibration pass. */
@@ -1949,9 +1999,14 @@ var Scene = class _Scene {
   contentMetricScaleEpoch = -1;
   contentMetricScaleX = 1;
   contentProjectionEnabled = true;
-  // Virtualization margin (px) for content projection; `undefined` → one
-  // viewport height, resolved at sync time. `Infinity` = materialize everything.
+  // Virtualization margin (px) for the content-projection CARRIER band;
+  // `undefined` → one viewport height, resolved at sync time. `Infinity` is
+  // unsupported here: it unwindows every carrier, which is O(total glyphs).
   contentProjectionMargin = void 0;
+  // Virtualization margin (px) for the SEMANTIC tier — whether a block has
+  // any projected DOM. `undefined` → falls back to contentProjectionMargin, so
+  // the default keeps one gate. `Infinity` = every block keeps resident text.
+  contentSemanticMargin = 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
@@ -1988,6 +2043,14 @@ var Scene = class _Scene {
    *  mid-hover synthesize the `pointerleave` the browser never sends for a
    *  detached element, so the entity doesn't keep its hover state. */
   hoveredA11yElements = /* @__PURE__ */ new WeakSet();
+  /**
+   * Entity ids the application has pinned via {@link requestA11yProjection}.
+   *
+   * Ids rather than entities so a removed entity cannot be retained by this set;
+   * a stale id simply never matches. Cleared per-entity by
+   * {@link releaseA11yProjection}.
+   */
+  a11yProjectionRequests = /* @__PURE__ */ new Set();
   /** 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
@@ -2941,7 +3004,9 @@ var Scene = class _Scene {
         const el = this.contentElements?.get(node.id);
         if (el) {
           const projectedText = el.textContent || "";
-          if (projectedText !== "" && projectedText !== proj.text) {
+          const windowed = el.dataset.vectoProjectionWindow !== void 0;
+          const mismatched = windowed ? !proj.text.includes(projectedText) : projectedText !== proj.text;
+          if (projectedText !== "" && mismatched) {
             this._devWarn(
               `Content projection mismatch for entity "${node.id}": projection says "${proj.text.slice(0, 60)}" but DOM shows "${projectedText.slice(0, 60)}". Ensure getContentProjection() output matches what drawSelf renders.`
             );
@@ -2977,6 +3042,7 @@ var Scene = class _Scene {
     this.a11ySyncInterval = options.a11ySyncInterval ?? 0;
     this.contentProjectionEnabled = options.contentProjection ?? true;
     this.contentProjectionMargin = options.contentProjectionMargin;
+    this.contentSemanticMargin = options.contentSemanticMargin;
     this.readingDirection = options.readingDirection ?? "ltr";
     this.renderMode = options.renderMode ?? "always";
     this._devActive = _Scene._devModeDetected();
@@ -3399,6 +3465,7 @@ var Scene = class _Scene {
       this.clearContentGridState(node.id, contentEl);
       contentEl.remove();
       this.contentElements.delete(node.id);
+      this.contentSyncState.delete(node.id);
       this.a11yNeedsReorder = true;
     }
     const el = this.a11yElements.get(node.id);
@@ -3543,6 +3610,7 @@ var Scene = class _Scene {
     this.a11yElements.clear();
     for (const el of this.contentElements.values()) el.remove();
     this.contentElements.clear();
+    this.contentSyncState.clear();
     if (typeof cancelAnimationFrame === "function") {
       for (const frame of this.contentGridCalibrationFrames.values()) {
         cancelAnimationFrame(frame);
@@ -3885,7 +3953,92 @@ var Scene = class _Scene {
    * predicate, which is only tractable while it has one home.
    */
   shouldProjectA11y(node) {
-    return node.interactive && (node.width > 0 || node.a11yFullViewport);
+    if (!node.interactive) return false;
+    if (!(node.width > 0 || node.a11yFullViewport)) return false;
+    switch (node.a11yProjection) {
+      case "never":
+        return false;
+      case "onDemand":
+        return this.a11yEngaged(node);
+      default:
+        return true;
+    }
+  }
+  /**
+   * Whether an `a11yProjection: 'onDemand'` entity is currently engaged enough to
+   * deserve a shadow node.
+   *
+   * Deliberately **not** hover alone. A keyboard or assistive-technology user
+   * generates no pointer events, so a hover-only trigger would withhold the
+   * semantic node from precisely the users it exists for. Three signals, any of
+   * which counts:
+   *
+   * - **Focus.** Covers keyboard traversal and AT-driven focus. Checked against
+   *   the live element so a node keeps its own focus rather than being pruned out
+   *   from under the user mid-interaction.
+   * - **Pointer target.** The entity under the pointer, so a mouse user gets the
+   *   same node a hover-gated design would have given them.
+   * - **Explicit request.** {@link Scene.requestA11yProjection}, for anything the
+   *   app knows is significant — the selected item, a search hit, a
+   *   just-announced element. This is the escape hatch that keeps the mode usable
+   *   when neither focus nor pointer applies.
+   *
+   * The entity stays hit-testable on canvas regardless, so a click always reaches
+   * it and promotes it on the next sync.
+   */
+  a11yEngaged(node) {
+    if (this.a11yProjectionRequests.has(node.id)) return true;
+    if (this.mouseX > -9e3 && !this.projectsSelectableText(node)) {
+      if (node.isPointInside(this.mouseX, this.mouseY)) return true;
+    }
+    const existing = this.a11yElements?.get(node.id);
+    if (existing && typeof document !== "undefined" && document.activeElement === existing) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Whether `node` mirrors selectable text of its own.
+   *
+   * Such an entity must not be promoted by the pointer: its interactive a11y node
+   * would sit above the text mirror and eat the mousedown that starts a native
+   * selection.
+   */
+  projectsSelectableText(node) {
+    const projection = node.getContentProjection?.();
+    return !!projection?.text && projection.selectable !== false;
+  }
+  /**
+   * Keep `entity`'s a11y shadow node projected while it has
+   * `a11yProjection: 'onDemand'`.
+   *
+   * For anything the application knows matters but the engine cannot infer — the
+   * selected danmaku, a search hit, a node just announced in a live region.
+   * Without this, `'onDemand'` would be reachable only by focus or pointer, and
+   * an app-driven selection change would leave the selected entity semantically
+   * invisible.
+   *
+   * Idempotent. Has no effect on an `'eager'` entity, which is always projected.
+   */
+  requestA11yProjection(entity) {
+    const id = typeof entity === "string" ? entity : entity.id;
+    if (this.a11yProjectionRequests.has(id)) return;
+    this.a11yProjectionRequests.add(id);
+    this.a11yNeedsReorder = true;
+    this.markDirty({ entity: id, reason: "a11y-reorder" });
+  }
+  /**
+   * Drop a projection request made by {@link requestA11yProjection}.
+   *
+   * The node is not removed immediately: it survives while it is focused or under
+   * the pointer, and is pruned on the next sync that finds it unengaged. Releasing
+   * a request the scene does not hold is a no-op.
+   */
+  releaseA11yProjection(entity) {
+    const id = typeof entity === "string" ? entity : entity.id;
+    if (!this.a11yProjectionRequests.delete(id)) return;
+    this.a11yNeedsReorder = true;
+    this.markDirty({ entity: id, reason: "a11y-reorder" });
   }
   syncA11y(node, container = null) {
     if (!this.a11yRoot) return;
@@ -4359,6 +4512,57 @@ var Scene = class _Scene {
     }
     return true;
   }
+  /**
+   * The band of an entity's own y coordinates that is worth projecting, or
+   * `null` to project everything.
+   *
+   * {@link projectionBoxVisible} answers "is this entity near the viewport",
+   * which frees whole blocks that scroll away. It cannot help a single entity
+   * *taller* than the viewport: that entity's box always intersects, so every
+   * one of its visual lines was materialized — a `<span>` per line and, on the
+   * grid path, a `<span>` per glyph cluster. That is where "14.8k elements for a
+   * 346KB Markdown doc" comes from, and it is O(document) rather than
+   * O(viewport) in both element count and per-frame walk cost.
+   *
+   * Measured on one entity scrolled to its middle, real headed browsers
+   * (`benchmarks/projection-per-line/`): at 4000 lines, materializing every line
+   * costs 6.28 ms/frame on Chrome and 6.51 ms on Firefox with 36,000 child
+   * elements, against 0.28/0.16 ms and 963 elements when only the visible band
+   * is emitted. The gated cost is *flat* across a 20x document-size range, so
+   * this converts an asymptote rather than shaving a constant.
+   *
+   * Returns local-y bounds in the entity's own coordinate space, already
+   * expanded by `margin` and intersected with every `clipChildren` ancestor, so
+   * a line inside a scrolled container is measured against the container rather
+   * than the window. `null` means "no useful bound" — a degenerate transform, a
+   * rotation/skew that makes a y-band meaningless, or a boundless entity — and
+   * the caller must then project every line, because emitting nothing would
+   * silently drop text from selection, find-in-page and screen readers.
+   */
+  projectionVisibleLocalYBand(node, tf, margin) {
+    const { b, d, f } = tf;
+    if (b !== 0 || d === 0 || !Number.isFinite(d) || !Number.isFinite(f)) return null;
+    const top = (-margin - f) / d;
+    const bottom = (this.height + margin - f) / d;
+    let minY = Math.min(top, bottom);
+    let maxY = Math.max(top, bottom);
+    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+      if (!ancestor.clipChildren || ancestor.width <= 0 || ancestor.height <= 0) continue;
+      const originWorldY = f;
+      const unitWorldY = d + f;
+      const originLocal = ancestor.worldToLocal(tf.e, originWorldY);
+      const unitLocal = ancestor.worldToLocal(tf.e + tf.c, unitWorldY);
+      if (!originLocal || !unitLocal) return null;
+      const slope = unitLocal.y - originLocal.y;
+      if (slope === 0 || !Number.isFinite(slope)) return null;
+      const a1 = (-margin - originLocal.y) / slope;
+      const a2 = (ancestor.height + margin - originLocal.y) / slope;
+      minY = Math.max(minY, Math.min(a1, a2));
+      maxY = Math.min(maxY, Math.max(a1, a2));
+    }
+    if (!Number.isFinite(minY) || !Number.isFinite(maxY) || maxY < minY) return null;
+    return { minY, maxY };
+  }
   syncContentProjection(node) {
     if (!this.contentProjectionEnabled || !this.a11yRoot) return;
     let el = this.contentElements.get(node.id);
@@ -4369,14 +4573,30 @@ var Scene = class _Scene {
         this.contentElements.delete(node.id);
         this.a11yNeedsReorder = true;
       }
+      this.contentSyncState.delete(node.id);
     };
     const worldTf = node.getWorldTransform();
-    const margin = this.contentProjectionMargin ?? this.height;
-    if (Number.isFinite(margin) && !this.projectionBoxVisible(node, worldTf, margin)) {
+    const interactionMargin = this.contentProjectionMargin ?? this.height;
+    const semanticMargin = this.contentSemanticMargin ?? interactionMargin;
+    if (Number.isFinite(semanticMargin) && !this.projectionBoxVisible(node, worldTf, semanticMargin)) {
       releaseProjectionEl();
       return;
     }
-    const projection = node.getContentProjection();
+    const inInteractionBand = !Number.isFinite(interactionMargin) || this.projectionBoxVisible(node, worldTf, interactionMargin);
+    const tier = inInteractionBand ? "fine" : "coarse";
+    const lineBand = tier === "coarse" ? null : Number.isFinite(interactionMargin) ? this.projectionVisibleLocalYBand(node, worldTf, interactionMargin) : null;
+    const visible = this.projectionBoxVisible(node, worldTf, 0);
+    const epoch = node.getContentEpoch();
+    const prior = this.contentSyncState.get(node.id);
+    if (epoch !== null && el && prior !== void 0) {
+      const { a: a2, b: b2, c: c2, d: d2, e: e2, f: f2 } = worldTf;
+      if (prior.epoch === epoch && prior.fontEpoch === this.contentFontEpoch && prior.a === a2 && prior.b === b2 && prior.c === c2 && prior.d === d2 && prior.e === e2 && prior.f === f2 && prior.tier === tier && prior.hasBand === (lineBand !== null) && (lineBand === null || prior.bandMin === lineBand.minY && prior.bandMax === lineBand.maxY) && prior.visible === visible && prior.width === node.width && prior.height === node.height && prior.interactive === node.interactive) {
+        return;
+      }
+    }
+    const projection = node.getContentProjection(
+      lineBand ? { minY: lineBand.minY, maxY: lineBand.maxY } : void 0
+    );
     if (!projection || !projection.text) {
       releaseProjectionEl();
       return;
@@ -4406,23 +4626,30 @@ var Scene = class _Scene {
       this.a11yNeedsReorder = true;
     }
     const lines = projection.lines;
-    if (!projection.grid && el.dataset.vectoContentGrid !== void 0) {
+    const useCarriers = tier === "fine";
+    if ((!projection.grid || !useCarriers) && el.dataset.vectoContentGrid !== void 0) {
       this.clearContentGridState(node.id, el);
     }
-    if (projection.grid) {
+    if (projection.grid && useCarriers) {
       const gridSyncStart = this._phaseTiming ? performance.now() : 0;
-      this.syncContentGridProjection(node, el, projection, projection.grid);
+      this.syncContentGridProjection(node, el, projection, projection.grid, lineBand);
       if (this._phaseTiming) this._recordPhase("gridSync", performance.now() - gridSyncStart);
-    } else if (lines && lines.length > 0) {
+    } else if (useCarriers && lines && lines.length > 0) {
+      const lineWindow = projectionLineWindow(lines, lineBand, projection.lineHeight ?? 16);
       const signature = JSON.stringify({
         lines,
         fallbackFont: projection.font ?? "",
-        fallbackLineHeight: projection.lineHeight ?? 16
+        fallbackLineHeight: projection.lineHeight ?? 16,
+        // Part of the signature, or scrolling would not rebuild the carriers and
+        // the window would stay frozen where it was first built. Quantized to
+        // whole line indices by construction, so a sub-pixel scroll inside one
+        // line does not churn the DOM.
+        window: lineWindow.gated ? `${lineWindow.start}-${lineWindow.end}` : "all"
       });
       if (el.dataset.vectoProjectionLines !== signature) {
         this.preserveContentSelectionAcrossRebuild(el, () => {
           el.replaceChildren();
-          for (let index = 0; index < lines.length; index++) {
+          for (let index = lineWindow.start; index < lineWindow.end; index++) {
             const line = lines[index];
             const lineElement = document.createElement("span");
             const lineFont = line.font ?? projection.font ?? "";
@@ -4463,13 +4690,20 @@ var Scene = class _Scene {
           }
         });
         el.dataset.vectoProjectionLines = signature;
+        if (lineWindow.gated) {
+          el.dataset.vectoProjectionWindow = `${lineWindow.start}-${lineWindow.end}/${lines.length}`;
+        } else {
+          delete el.dataset.vectoProjectionWindow;
+        }
       }
     } else {
-      if (el.textContent !== projection.text) {
+      const demoted = tier === "coarse" && el.children.length > 0;
+      if (el.textContent !== projection.text || demoted) {
         this.releaseContentSelectionForRebuild(el);
         el.textContent = projection.text;
       }
       delete el.dataset.vectoProjectionLines;
+      if (tier === "coarse") delete el.dataset.vectoProjectionWindow;
     }
     const font = projection.font ?? "";
     if (el.style.font !== font) el.style.font = font;
@@ -4502,20 +4736,41 @@ var Scene = class _Scene {
     if (node.width > 0) el.style.width = `${node.width}px`;
     if (node.height > 0) el.style.height = `${node.height}px`;
     el.style.transform = `matrix(${a}, ${b}, ${c}, ${d}, 0, 0)`;
-    const visible = this.projectionBoxVisible(node, worldTf, 0);
     const display = visible ? "" : "none";
     if (el.style.display !== display) el.style.display = display;
+    if (epoch !== null) {
+      const { a: a2, b: b2, c: c2, d: d2, e: e2, f: f2 } = worldTf;
+      const next = prior ?? {};
+      next.epoch = epoch;
+      next.fontEpoch = this.contentFontEpoch;
+      next.a = a2;
+      next.b = b2;
+      next.c = c2;
+      next.d = d2;
+      next.e = e2;
+      next.f = f2;
+      next.tier = tier;
+      next.hasBand = lineBand !== null;
+      next.bandMin = lineBand?.minY ?? 0;
+      next.bandMax = lineBand?.maxY ?? 0;
+      next.visible = visible;
+      next.width = node.width;
+      next.height = node.height;
+      next.interactive = node.interactive;
+      if (prior === void 0) this.contentSyncState.set(node.id, next);
+    }
   }
   /**
    * Materialize a prepared grid in logical source order while positioning each
    * carrier from the shared canvas geometry. Browser font measurement happens
    * later in one cold read/write batch, never inside projection synchronization.
    */
-  syncContentGridProjection(node, el, projection, grid) {
+  syncContentGridProjection(node, el, projection, grid, lineBand) {
     if (grid.source !== projection.text) {
       throw new Error("ContentProjection.grid.source must equal ContentProjection.text");
     }
-    const signature = `${grid.revision}`;
+    const gridWindow = projectionGridLineWindow(grid, projection.lines, lineBand);
+    const signature = gridWindow.gated ? `${grid.revision}:${gridWindow.start}-${gridWindow.end}` : `${grid.revision}`;
     if (el.dataset.vectoContentGrid !== signature) {
       const materializeStart = typeof performance !== "undefined" ? performance.now() : 0;
       this.clearContentGridState(node.id, el, false);
@@ -4523,7 +4778,8 @@ var Scene = class _Scene {
       const selectionLine = this.contentGridSelectionLine(el);
       let rebuiltSelectionLine = false;
       const existingLines = el.children;
-      for (let lineIndex = 0; lineIndex < grid.lines.length; lineIndex++) {
+      for (let lineIndex = gridWindow.start; lineIndex < gridWindow.end; lineIndex++) {
+        const domIndex = lineIndex - gridWindow.start;
         const gridLine = grid.lines[lineIndex];
         const projectedLine = projectionLines[lineIndex];
         const lineHeight = projectedLine?.lineHeight ?? grid.lineHeight;
@@ -4538,7 +4794,7 @@ var Scene = class _Scene {
           lineFont,
           lineIndex === 0
         );
-        const reusable = existingLines[lineIndex];
+        const reusable = existingLines[domIndex];
         if (reusable !== void 0 && reusable.dataset.vectoGridLineSig === lineSignature && reusable.dataset.vectoGridLine === `${lineIndex}`) {
           continue;
         }
@@ -4611,12 +4867,13 @@ var Scene = class _Scene {
             lineElement.appendChild(marker);
           }
         }
-        const occupant = el.children[lineIndex];
+        const occupant = el.children[domIndex];
         if (occupant) el.replaceChild(lineElement, occupant);
         else el.appendChild(lineElement);
       }
-      while (el.children.length > grid.lines.length) {
-        if (selectionLine !== null && selectionLine >= grid.lines.length) {
+      const windowLength = gridWindow.end - gridWindow.start;
+      while (el.children.length > windowLength) {
+        if (selectionLine !== null && selectionLine >= gridWindow.end) {
           rebuiltSelectionLine = true;
         }
         el.lastElementChild?.remove();
@@ -4624,6 +4881,11 @@ var Scene = class _Scene {
       if (rebuiltSelectionLine) this.releaseContentSelectionForRebuild(el);
       el.dataset.vectoProjectionLines = signature;
       el.dataset.vectoContentGrid = signature;
+      if (gridWindow.gated) {
+        el.dataset.vectoProjectionWindow = `${gridWindow.start}-${gridWindow.end}/${grid.lines.length}`;
+      } else {
+        delete el.dataset.vectoProjectionWindow;
+      }
       el.dataset.vectoGridCarriers = `${el.querySelectorAll("[data-vecto-grid-cell]").length}`;
       if (typeof performance !== "undefined") {
         const materializeMs = performance.now() - materializeStart;
@@ -5899,6 +6161,8 @@ var TextEntity = class extends Entity {
   hoveredFillStyle = "#ffffff";
   lineWidth = 1;
   isHovered = false;
+  /** Bumped by {@link applyLayout}; read by `Scene` to skip an unchanged sync. */
+  contentEpoch = 0;
   constructor(text, atlas, maxWidth, fontSize = 24) {
     super();
     this.text = text;
@@ -5919,6 +6183,9 @@ var TextEntity = class extends Entity {
     if (!this.text) return null;
     return { text: this.text, font: `${this.fontSize}px sans-serif` };
   }
+  getContentEpoch() {
+    return this.contentEpoch;
+  }
   /**
    * Replace the text content. Runs the **cold** measurement pass (re-segment +
    * re-measure) since the glyphs changed, then re-lays out.
@@ -5965,6 +6232,7 @@ var TextEntity = class extends Entity {
   }
   /** Hot pass: place the cached {@link PreparedText} and refresh the a11y box. */
   applyLayout() {
+    this.contentEpoch++;
     const result = this.layout.layoutPrepared(this.prepared);
     this.nodes = result.nodes;
     this.width = result.totalWidth;
@@ -6670,6 +6938,7 @@ export {
   VectoJSEvent,
   WebGPUParticleSystemManager,
   beginVectoUserTiming,
+  contentLineInHint,
   createWebGLPointRenderer,
   endVectoUserTiming,
   installRendererDevTraps,

package/dist/text/MSDFTextEntity.d.ts

@@ -34,6 +34,8 @@ export declare class MSDFTextEntity extends Entity {
     private layoutText;
     private text;
     private lastRenderedSeqId;
+    /** Bumped by {@link queueLayout}; read by `Scene` to skip an unchanged sync. */
+    private contentEpoch;
     private atlasDecodeTarget;
     private atlasDecodeHandler;
     private rgbColorCache;
@@ -91,6 +93,7 @@ export declare class MSDFTextEntity extends Entity {
      * readers, crawlers, and translation see the same string the canvas draws.
      */
     getContentProjection(): ContentProjection | null;
+    getContentEpoch(): number;
     isPointInside(globalX: number, globalY: number): boolean;
     render(renderer: any): void;
     destroy(): void;

package/dist/text.js

@@ -2,11 +2,11 @@
 
 
 
-var _chunkZ3HFY75Rjs = require('./chunk-Z3HFY75R.js');
+var _chunkTRT2TRCWjs = require('./chunk-TRT2TRCW.js');
 
 // src/text/index.ts
 var _text = require('@vectojs/text'); _createStarExport(_text);
 
 
 
-exports.MSDFTextEntity = _chunkZ3HFY75Rjs.MSDFTextEntity; exports.SVGEntity = _chunkZ3HFY75Rjs.SVGEntity;
+exports.MSDFTextEntity = _chunkTRT2TRCWjs.MSDFTextEntity; exports.SVGEntity = _chunkTRT2TRCWjs.SVGEntity;

package/dist/text.mjs

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