@vectojs/core 1.38.0 → 1.39.0

package/dist/renderer/CanvasRenderer.d.ts

@@ -39,6 +39,12 @@ export declare class CanvasRenderer implements IRenderer {
     private batchCount;
     private _cachedFont;
     private _cachedFill;
+    private _cachedStroke;
+    private _cachedLineWidth;
+    private _cachedLineCap;
+    private _cachedLineJoin;
+    private _onContextLost?;
+    private _onContextRestored?;
     /** Backend discriminator; see {@link IRenderer.kind}. */
     readonly kind = "canvas2d";
     /**

package/dist/renderer/SVGRenderer.d.ts

@@ -39,7 +39,11 @@ export declare class SVGRenderer implements IRenderer {
     private batchActive;
     private gradientCounter;
     private gradientCache;
-    constructor(width: number, height: number);
+    /** Root font size used to resolve `em`/`rem` font sizes (default 16px). */
+    private rootFontSize;
+    constructor(width: number, height: number, options?: {
+        rootFontSize?: number;
+    });
     clear(): void;
     save(): void;
     restore(): void;
@@ -56,6 +60,16 @@ export declare class SVGRenderer implements IRenderer {
     roundRect(x: number, y: number, w: number, h: number, radii: number | number[]): void;
     fill(colorOrGradient: string | SVGLinearGradient): void;
     stroke(colorOrGradient: string | SVGLinearGradient, lineWidth?: number): void;
+    /**
+     * Emit a `<text>` element for a text run.
+     *
+     * Font-size unit handling: `px` sizes pass through; `em` and `rem` are both
+     * scaled against the renderer's `rootFontSize` (constructor option, default
+     * 16 — matching the browser default, not necessarily the host page's root,
+     * so pass `{ rootFontSize }` when exporting against a non-default root).
+     * A percentage size (`'100% Inter'`) has no absolute meaning in this
+     * context and silently falls back to the default 16px font size.
+     */
     fillText(text: string, x: number, y: number, font: string, color: string | SVGLinearGradient): void;
     fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
     drawImage(source: any, dx: number, dy: number, dw: number, dh: number): void;
@@ -79,7 +93,8 @@ export declare class SVGRenderer implements IRenderer {
     private isSafeRasterDataUrl;
     /**
      * SVGRenderer accumulates strings in memory; nothing external is allocated.
-     * Drop the buffers for GC and become idempotent.
+     * Drop the buffers for GC and become idempotent. `clear()` already empties
+     * the gradient cache, so no second clear is needed here.
      */
     dispose(): void;
 }

package/dist/renderer/WebGPUParticleSystemManager.d.ts

@@ -3,6 +3,8 @@ export declare class WebGPUParticleSystemManager {
     private device;
     private computePipeline;
     private renderPipeline;
+    private computeModule;
+    private renderModule;
     private computeBindGroupLayout;
     private renderBindGroupLayout;
     constructor(device: GPUDevice);

package/dist/renderer.js

@@ -10,7 +10,7 @@
 
 
 
-var _chunkZYYP2M5Djs = require('./chunk-ZYYP2M5D.js');
+var _chunkKRUDTGNRjs = require('./chunk-KRUDTGNR.js');
 
 
 
@@ -22,4 +22,4 @@ var _chunkZYYP2M5Djs = require('./chunk-ZYYP2M5D.js');
 
 
 
-exports.CanvasRenderer = _chunkZYYP2M5Djs.CanvasRenderer; exports.GlyphRasterAtlas = _chunkZYYP2M5Djs.GlyphRasterAtlas; exports.SVGRenderer = _chunkZYYP2M5Djs.SVGRenderer; exports.TextRasterCache = _chunkZYYP2M5Djs.TextRasterCache; exports.WebGPUParticleSystemManager = _chunkZYYP2M5Djs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkZYYP2M5Djs.createWebGLPointRenderer; exports.installRendererDevTraps = _chunkZYYP2M5Djs.installRendererDevTraps; exports.isRendererDevMode = _chunkZYYP2M5Djs.isRendererDevMode; exports.parseColorToRGBA = _chunkZYYP2M5Djs.parseColorToRGBA; exports.setRendererDevMode = _chunkZYYP2M5Djs.setRendererDevMode;
+exports.CanvasRenderer = _chunkKRUDTGNRjs.CanvasRenderer; exports.GlyphRasterAtlas = _chunkKRUDTGNRjs.GlyphRasterAtlas; exports.SVGRenderer = _chunkKRUDTGNRjs.SVGRenderer; exports.TextRasterCache = _chunkKRUDTGNRjs.TextRasterCache; exports.WebGPUParticleSystemManager = _chunkKRUDTGNRjs.WebGPUParticleSystemManager; exports.createWebGLPointRenderer = _chunkKRUDTGNRjs.createWebGLPointRenderer; exports.installRendererDevTraps = _chunkKRUDTGNRjs.installRendererDevTraps; exports.isRendererDevMode = _chunkKRUDTGNRjs.isRendererDevMode; exports.parseColorToRGBA = _chunkKRUDTGNRjs.parseColorToRGBA; exports.setRendererDevMode = _chunkKRUDTGNRjs.setRendererDevMode;

package/dist/renderer.mjs

@@ -9,7 +9,7 @@ import {
   isRendererDevMode,
   parseColorToRGBA,
   setRendererDevMode
-} from "./chunk-LWEMD34D.mjs";
+} from "./chunk-RUM2KEDI.mjs";
 export {
   CanvasRenderer,
   GlyphRasterAtlas,

package/dist/text/MSDFTextEntity.d.ts

@@ -38,7 +38,6 @@ export declare class MSDFTextEntity extends Entity {
     private contentEpoch;
     private atlasDecodeTarget;
     private atlasDecodeHandler;
-    private rgbColorCache;
     private fontStringCache;
     private layoutResult;
     /**

package/dist/text.js

@@ -2,11 +2,11 @@
 
 
 
-var _chunkSRXU3ZXKjs = require('./chunk-SRXU3ZXK.js');
+var _chunkPOPXUPKRjs = require('./chunk-POPXUPKR.js');
 
 // src/text/index.ts
 var _text = require('@vectojs/text'); _createStarExport(_text);
 
 
 
-exports.MSDFTextEntity = _chunkSRXU3ZXKjs.MSDFTextEntity; exports.SVGEntity = _chunkSRXU3ZXKjs.SVGEntity;
+exports.MSDFTextEntity = _chunkPOPXUPKRjs.MSDFTextEntity; exports.SVGEntity = _chunkPOPXUPKRjs.SVGEntity;

package/dist/text.mjs

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

package/dist/tree/Entity.d.ts

@@ -856,8 +856,6 @@ export declare abstract class Entity {
      * only by Scene, never application code.
      */
     _applyDriverTick(prop: AnimatableProp, driver: PropertyDriver): void;
-    /** Internal: true if this entity currently has any active property driver. */
-    _hasActiveDrivers(): boolean;
     /**
      * Advance the entity's internal state for one frame.
      *
@@ -1011,6 +1009,14 @@ export declare abstract class Entity {
      * Accumulated world rotation: this entity's own `rotation` plus
      * that of every ancestor.
      *
+     * Valid only under positive scales: the sum models the composed matrix
+     * `T*S*R` correctly while every ancestor's `scaleX`/`scaleY` is positive,
+     * but a mirrored (negative-scale) ancestor flips handedness, which an
+     * additive sum cannot represent — the result is then off by the mirror.
+     * For mirror-safe rotation, derive the angle from
+     * {@link getWorldTransform}'s matrix (e.g. `atan2(b, a)`), as SVGEntity's
+     * signed-scale handling already does.
+     *
      * @returns The accumulated world rotation in radians.
      */
     getWorldRotation(): number;

package/dist/tree/Scene.d.ts

@@ -22,7 +22,31 @@ import { type OverlayGeometry } from './scene/CanvasGeometry';
 import { type DirtyReasonEntry, type DirtySource } from './scene/DirtyTracker';
 import { type RenderPhase, type RenderPhaseEntry } from './scene/PhaseTimer';
 import { type AcceleratorReason, type AcceleratorReport, type AcceleratorStatus } from './scene/WasmBackendFacade';
+import { type SceneKeyEvent, type SceneShortcutSpec } from './scene/keyboard';
 export type { RenderPhase, RenderPhaseEntry };
+export { normalizeChord } from './scene/keyboard';
+export type { SceneKeyEvent, SceneShortcutSpec } from './scene/keyboard';
+/**
+ * Roles whose focused element is considered to own the keyboard, so the
+ * scene-level keydown/keyup channel stays silent while one of them holds
+ * focus (arrow keys must move a slider, typing must reach a textbox, …).
+ *
+ * {@link INTERACTIVE_A11Y_ROLES} plus the text-selection/list roles that are
+ * keyboard-first but not "interactive" in the pointer sense.
+ */
+export declare const KEYBOARD_OWNING_ROLES: ReadonlySet<string>;
+/**
+ * Whether `el` (typically `document.activeElement`) currently owns the
+ * keyboard and should suppress the scene-level keyboard channel.
+ *
+ * Never owning: `null`, `document.body`, `document.documentElement`, and the
+ * scene's own a11y root. Always owning: `INPUT`/`TEXTAREA`/`SELECT` elements
+ * and anything `contentEditable`. Otherwise owning iff its `role` attribute
+ * is in {@link KEYBOARD_OWNING_ROLES}. The gate is unconditional by design —
+ * even modifier chords (`ctrl+s`) are suppressed while an owner holds focus,
+ * because the page behind the canvas expects to keep them.
+ */
+export declare function ownsKeyboard(el: Element | null): boolean;
 export type { DirtyReasonEntry, DirtySource };
 /**
  * Options for {@link Scene}.
@@ -489,6 +513,9 @@ export declare class Scene {
     private a11yPendingSyncAfterAnimation;
     private a11yRoot;
     private a11yElements;
+    /** Elements that already have the synthetic Enter/Space activation handler
+     *  (see the syncA11y refresh pass) — install-once bookkeeping (#694). */
+    private readonly keyboardActivatedA11y;
     /** DOM nodes mirroring static text content, keyed by entity id. */
     private contentElements;
     /**
@@ -973,6 +1000,15 @@ export declare class Scene {
      * entity).
      */
     _registerActiveDriverSubtree(entity: Entity): void;
+    /**
+     * The `dt` of the frame currently executing its update walk (the WASM-mode
+     * pre-pass or the JS-mode interleaved render walk), or `null` outside it.
+     * Read by `Entity._spawnDriver`: a driver spawned mid-walk onto an entity the
+     * batched pass already claimed this frame must be advanced once here, or
+     * `tickDrivers()`'s per-frame stamp would skip it a full frame — a one-frame
+     * JS/WASM divergence. Written in {@link render} next to `_tickBatchedDrivers`.
+     */
+    _updateWalkDt: number | null;
     /**
      * Advance every registered entity's active drivers for this frame, batching
      * whichever are batchable (`SpringDriver`; `TweenDriver` with a named
@@ -1045,6 +1081,12 @@ export declare class Scene {
     /** Element the pointer listeners are bound to (parent container if present,
      *  else the canvas). Stored so `destroy()` detaches from the same element. */
     private pointerEventTarget;
+    private keydownHandlers;
+    private keyupHandlers;
+    /** Chord-normalized shortcut table, matched on keydown only. */
+    private shortcuts;
+    private windowKeyDownHandler;
+    private windowKeyUpHandler;
     private hasWarnedZeroSize;
     /**
      * Latch for {@link Scene.resize}'s invalid-dimension warning.
@@ -1239,6 +1281,70 @@ export declare class Scene {
      * Call {@link start} again to resume rendering.
      */
     stop(): void;
+    /**
+     * Register a listener on the scene-level keyboard channel.
+     *
+     * Mirrors {@link Entity.on} minus the options parameter (bubble-only, and
+     * there is no capture phase for a single window tap). Handlers fire only
+     * when ALL of these hold:
+     *
+     * 1. the native event was not already `defaultPrevented`,
+     * 2. it is not an auto-repeat (`e.repeat`),
+     * 3. `document.activeElement` does not own the keyboard
+     *    (see {@link ownsKeyboard}) — typing in an `<input>` or focusing a
+     *    slider-role element suppresses the scene channel, unconditionally,
+     *    including modifier chords.
+     *
+     * The listeners are window-level BUBBLE-phase taps, so an entity handler
+     * that calls `nativeEvent.stopPropagation()` keeps the key from ever
+     * reaching this channel. Deliberately not registered in the capture phase:
+     * a window-capture listener would preempt Modal's document-capture trap.
+     *
+     * Listeners attach at `start()` and survive `stop()`; only `destroy()`
+     * removes them.
+     *
+     * @param event - `'keydown'` or `'keyup'`; anything else is rejected with a
+     *   dev warning (guards JS callers — TypeScript already narrows this).
+     * @param callback - Handler invoked with a {@link SceneKeyEvent}.
+     * @returns `this` for method chaining.
+     */
+    on(event: 'keydown' | 'keyup', callback: (e: SceneKeyEvent) => void): this;
+    /**
+     * Remove a listener previously registered with {@link Scene.on}. Silent
+     * no-op for unknown handlers, unsupported event names, or after
+     * {@link Scene.destroy}.
+     *
+     * @returns `this` for method chaining.
+     */
+    off(event: 'keydown' | 'keyup', callback: (e: SceneKeyEvent) => void): this;
+    /**
+     * Sugar over the keyboard channel: invoke `spec.handler` whenever a
+     * non-repeat `keydown` whose normalized chord matches `spec.chord`
+     * (via {@link normalizeChord}) passes the same gates as {@link Scene.on} —
+     * including the unconditional `ownsKeyboard(activeElement)` suppression.
+     *
+     * @param spec - `{ chord, handler }`; the chord is normalized once at
+     *   registration, so `'ctrl+n'`, `'Control+n'` and `'Ctrl+N'` are aliases.
+     * @returns `this` for method chaining.
+     */
+    registerShortcut(spec: SceneShortcutSpec): this;
+    /**
+     * Remove a shortcut previously registered with {@link Scene.registerShortcut}.
+     * Matches on normalized chord + exact handler reference; silent no-op when
+     * nothing matches.
+     *
+     * @param spec - The same spec object (chord spelling may differ; it is
+     *   re-normalized before matching).
+     * @returns `this` for method chaining.
+     */
+    unregisterShortcut(spec: SceneShortcutSpec): this;
+    /** Attach the window bubble-phase keyboard listeners exactly once. */
+    private attachWindowKeyListeners;
+    /**
+     * Gate a native keyboard event and fan it out to scene handlers +
+     * chord-matched shortcuts. See {@link Scene.on} for the gate contract.
+     */
+    private dispatchKeyboard;
     /**
      * Manually advance the scene clock by `dt` milliseconds and render synchronously.
      * Essential for deterministic rendering (e.g. video export).

package/dist/tree/scene/A11yProjectionManager.d.ts

@@ -89,6 +89,18 @@ export declare class A11yProjectionManager {
      * implicit root region. See {@link sortNormalElementsVisually}.
      */
     private readonly orderRegions;
+    /**
+     * Decoration records for {@link sortNormalElementsVisually}: one per ordered
+     * element, pooled across passes and rewritten in place — the sort runs on
+     * structure-change frames, where the module's zero-GC policy applies.
+     */
+    private readonly orderDecorated;
+    /** Region → decorated elements, reused by {@link sortNormalElementsVisually}. */
+    private readonly orderBucketByRegion;
+    /** Pool of bucket arrays backing {@link orderBucketByRegion} across passes. */
+    private readonly orderBuckets;
+    /** Scratch for one visual row inside {@link sortNormalElementsVisually}. */
+    private readonly orderRowScratch;
     /** Mark the projected DOM as needing a reorder on the next pass. */
     markNeedsReorder(): void;
     /** Reset the per-pass collections. Zero-GC: length/clear, never reallocate. */

package/dist/tree/scene/HitTester.d.ts

@@ -23,7 +23,8 @@
  * ## What this owns
  *
  * The hit-grid *contents* — the slot→entity table, the boundless list, and the
- * reused fused-gather buffer. The cache *key* (`hitGridFrame`, `hitGridOk`) stays
+ * reused fused-gather buffer. The cache *key* (`hitGridFrame`,
+ * `hitGridStructureVersion`, `hitGridOk`) stays
  * on {@link WasmBackendFacade}, because installing a backend has to invalidate
  * it and that is the facade's business.
  *
@@ -46,7 +47,8 @@
  * `root` and `overlayRoot` are held: `Scene` assigns both once in its constructor
  * and never reassigns them. The facade is held because the hit backend is reached
  * only through its public surface (`hit`, `hitReason`, `hitGridFrame`,
- * `hitGridOk`, `ensureAabbs()`, `slotEntity`, `hitFusedGather`, `transform`).
+ * `hitGridStructureVersion`, `hitGridOk`, `ensureAabbs()`, `slotEntity`,
+ * `hitFusedGather`, `transform`).
  *
  * The frame counter and the viewport size are **per-call arguments** (`DEC-0019`
  * rule 5): `currentFrame` belongs to the render scheduler (extraction 6) and
@@ -100,6 +102,16 @@ export declare class HitTester {
      *  or an explicit `pointerEvents: 'none'` in its a11y attributes. Its children
      *  are still walked (a transparent container can hold hittable descendants). */
     private isPointerTransparent;
+    /**
+     * Exact rotation-aware `clipChildren` test shared by BOTH hit paths: the
+     * point must lie inside every clipChildren ancestor's local rect — the same
+     * shape rendering clips to — not merely inside the ancestor's world AABB.
+     * For a rotated clipper those disagree, and until both paths used the exact
+     * rect a query's answer depended on which backend was active (#680). The
+     * clip-stack AABB intersection in {@link findHitRecursively} remains purely
+     * as a subtree-pruning pre-filter; this is the authoritative gate.
+     */
+    private isInsideAllClippers;
     /**
      * Whether a confirmed geometric hit on `node` at world `(x, y)` is a REAL hit,
      * applying the same visibility/input gating as {@link findHitRecursively} but

package/dist/tree/scene/WasmBackendFacade.d.ts

@@ -73,6 +73,16 @@ export type AcceleratorReason =
  | 'below-gate'
 /** Installed and gated in, but the kernel rejected the call and wrote nothing. */
  | 'rejected'
+/**
+ * The spring kernel rejected this frame's call (JS fallback for springs) but
+ * tweens stepped through the kernel — a partial acceleration, not fully-JS.
+ */
+ | 'springs-rejected'
+/**
+ * The tween kernel rejected this frame's call (JS fallback for tweens) but
+ * springs stepped through the kernel — a partial acceleration, not fully-JS.
+ */
+ | 'tweens-rejected'
 /** Not applicable to this pass (e.g. a non-main renderer, or nothing to do). */
  | 'not-applicable';
 /**
@@ -239,6 +249,13 @@ export declare class WasmBackendFacade {
     animBatchedLastFrame: boolean;
     /** Frame the hit grid was last built for; `-1` forces a rebuild. */
     hitGridFrame: number;
+    /**
+     * Structure version the hit grid was built for; `-1` forces a rebuild.
+     * Half of the cache key the comment above promises: without it, a pointer
+     * query in the same frame as a structural mutation would resolve against
+     * pre-mutation geometry while the JS walk sees live state.
+     */
+    hitGridStructureVersion: number;
     /** Whether that build succeeded (did not overflow its item budget). */
     hitGridOk: boolean;
     /**

package/dist/tree/scene/keyboard.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Scene-level keyboard channel primitives shared by @vectojs/core and
+ * @vectojs/desktop.
+ *
+ * `normalizeChord` was promoted verbatim from @vectojs/desktop's
+ * ShortcutRouter so both packages share one chord-normalization
+ * implementation; desktop re-imports it from core.
+ */
+/**
+ * Normalize a keyboard chord to a stable key used in shortcut maps.
+ * Order: Ctrl/Control, Alt, Shift, Meta, then the uppercased key.
+ *
+ * Accepts either a {@link KeyboardEvent} or a pre-written string like
+ * `Control+Shift+N`.
+ */
+export declare function normalizeChord(input: KeyboardEvent | string): string;
+/**
+ * Payload delivered to scene-level `keydown`/`keyup` listeners registered via
+ * {@link Scene.on} and to {@link Scene.registerShortcut} handlers.
+ *
+ * Deliberately NOT a {@link VectoJSEvent}: this channel has no entity target
+ * and no tree propagation — it is a single scene-wide window-bubble tap.
+ * `stopPropagation()`/`preventDefault()` forward to the native event so
+ * handlers written against raw DOM semantics keep working.
+ */
+export interface SceneKeyEvent {
+    /** Which phase of the key produced this event. */
+    type: 'keydown' | 'keyup';
+    /** Native `KeyboardEvent.key` (e.g. `'a'`, `'ArrowLeft'`, `'Enter'`). */
+    key: string;
+    /** Native `KeyboardEvent.code` (physical key, e.g. `'KeyA'`). */
+    code: string;
+    /** True while the key is auto-repeating; suppressed by the scene channel gate. */
+    repeat: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    /** The DOM event target (`window` when dispatched directly at the window). */
+    target: EventTarget | null;
+    /** The originating browser event. */
+    nativeEvent: KeyboardEvent;
+    /** Forward to `nativeEvent.stopPropagation()`. */
+    stopPropagation(): void;
+    /** Forward to `nativeEvent.preventDefault()`. */
+    preventDefault(): void;
+}
+/** Spec for {@link Scene.registerShortcut} / {@link Scene.unregisterShortcut}. */
+export interface SceneShortcutSpec {
+    /**
+     * Chord string like `'ctrl+shift+n'`, matched after normalization via
+     * {@link normalizeChord} (`'Control+Shift+N'`), or a live `KeyboardEvent`.
+     */
+    chord: string;
+    handler: (e: SceneKeyEvent) => void;
+}

package/dist/wasm/backend.d.ts

@@ -132,19 +132,19 @@ export declare class WasmTransformBackend {
     /**
      * Compute world-space AABBs for `store` in WASM (G1+), writing back into its
      * `aminx/aminy/amaxx/amaxy` arrays. Uploads the local bounds, runs the AABB
-     * pass, reads results back. Result is bit-identical to `computeAabbsJS(store)`.
-     * `compose` (or `runKernel`) must have populated the world matrices first —
-     * this pass reads them. For the resident (no-copy) integration, write bounds
-     * via {@link boundsView} and read via {@link aabbView} + call
-     * {@link runAabbs} instead.
+     * pass, reads results back. Result is bit-identical to `computeAabbsJS(store)`
+     * for both kernels. `compose` (or `runKernel`) must have populated the world
+     * matrices first — this pass reads them. For the resident (no-copy)
+     * integration, write bounds via {@link boundsView} and read via
+     * {@link aabbView} + call {@link runAabbs} instead.
      */
-    computeAabbs(store: TransformStore): void;
+    computeAabbs(store: TransformStore, kernel?: Kernel): void;
     /** Run the AABB pass only, over `count` entities already resident in wasm
      *  memory (bounds written via {@link boundsView}, world matrices already
      *  composed). No upload/readback — the per-frame resident path. Returns
      *  `false` if the kernel rejected `count` (beyond capacity, or uninitialized),
      *  in which case {@link aabbView} still holds the previous frame's bounds. */
-    runAabbs(count: number): boolean;
+    runAabbs(count: number, kernel?: Kernel): boolean;
     /** Resident wasm local-bounds input views (`bx,by,bw,bh`) for the AABB pass. */
     boundsView(): {
         bx: Float64Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/core",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "publishConfig": {
     "access": "public"
   },
@@ -64,17 +64,17 @@
     "test:e2e": "bun e2e/hidpi.e2e.ts && bun e2e/text-projection.e2e.ts && bun e2e/svg-fallback.e2e.ts && bun e2e/msdf-atlas-decode.e2e.ts && bun e2e/layout-worker-fallback.e2e.ts"
   },
   "dependencies": {
-    "@vectojs/animation": "^0.1.2",
-    "@vectojs/layout": "^0.9.3",
-    "@vectojs/math": "^0.1.1",
-    "@vectojs/text": "^0.4.1"
+    "@vectojs/animation": "^0.1.3",
+    "@vectojs/layout": "^0.10.0",
+    "@vectojs/math": "^0.1.2",
+    "@vectojs/text": "^0.4.2"
   },
   "devDependencies": {
     "@guidepup/virtual-screen-reader": "0.32.1",
     "@vitest/coverage-v8": "^4.1.10",
     "esbuild": "^0.28.1",
     "jsdom": "^30.0.1",
-    "puppeteer-core": "^25.4.0",
+    "puppeteer-core": "^25.7.0",
     "tsup": "^8.3.5",
     "vitest": "^4.1.10"
   }