@vectojs/core 0.1.0 → 0.2.0

package/dist/{Entity-D-rfAFCf.d.mts → tree/Entity.d.ts}

@@ -1,186 +1,10 @@
-/**
- * Renderer abstraction consumed by every {@link Entity}.
- *
- * Implementations wrap a concrete drawing backend (Canvas 2D, WebGL, …) and
- * expose a path-based drawing API.  Entities must only depend on `IRenderer`
- * so they remain backend-agnostic.
- *
- * @example
- * // Inside an Entity.render() implementation:
- * render(r: IRenderer) {
- *   r.beginPath();
- *   r.fill('#38bdf8');
- * }
- */
-interface IRenderer {
-    /** Clear the entire drawing surface to transparent / background color. */
-    clear(): void;
-    /** Push the current transform + state onto the renderer's stack. */
-    save(): void;
-    /** Pop the last saved transform + state from the renderer's stack. */
-    restore(): void;
-    /**
-     * Apply a translation to the current transform matrix.
-     *
-     * @param x - Horizontal offset in pixels.
-     * @param y - Vertical offset in pixels.
-     */
-    translate(x: number, y: number): void;
-    /**
-     * Apply a scale to the current transform matrix.
-     *
-     * @param x - Horizontal scale factor.
-     * @param y - Vertical scale factor.
-     */
-    scale(x: number, y: number): void;
-    /**
-     * Apply a clockwise rotation to the current transform matrix.
-     *
-     * @param angle - Rotation angle in radians.
-     */
-    rotate(angle: number): void;
-    /**
-     * Set the global opacity applied to all subsequent draw calls.
-     *
-     * @param alpha - Opacity in the range `[0, 1]`.
-     */
-    setGlobalAlpha(alpha: number): void;
-    /**
-     * Intersect the current clip region with a rectangle. Affects all subsequent
-     * draws until the next {@link restore}; wrap in {@link save}/{@link restore}.
-     *
-     * @param x - Left edge.
-     * @param y - Top edge.
-     * @param width - Rectangle width.
-     * @param height - Rectangle height.
-     */
-    clip(x: number, y: number, width: number, height: number): void;
-    /** Begin a new sub-path, discarding the current path. */
-    beginPath(): void;
-    /**
-     * Move the pen to the given point without drawing a line.
-     *
-     * @param x - Target X coordinate.
-     * @param y - Target Y coordinate.
-     */
-    moveTo(x: number, y: number): void;
-    /**
-     * Add a straight line segment from the current pen position to the given point.
-     *
-     * @param x - Target X coordinate.
-     * @param y - Target Y coordinate.
-     */
-    lineTo(x: number, y: number): void;
-    /**
-     * Add a cubic Bézier curve to the current path.
-     *
-     * @param cp1x - X of the first control point.
-     * @param cp1y - Y of the first control point.
-     * @param cp2x - X of the second control point.
-     * @param cp2y - Y of the second control point.
-     * @param x - X of the end point.
-     * @param y - Y of the end point.
-     */
-    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
-    /** Close the current sub-path by drawing a line back to its starting point. */
-    closePath(): void;
-    /**
-     * Add a circular arc to the current path.
-     *
-     * @param x - X of the arc center.
-     * @param y - Y of the arc center.
-     * @param radius - Arc radius in pixels.
-     * @param startAngle - Start angle in radians (0 = 3 o'clock).
-     * @param endAngle - End angle in radians.
-     * @param counterclockwise - If `true`, draws the arc counter-clockwise.
-     */
-    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
-    /**
-     * Add a rounded rectangle to the current path.
-     *
-     * @param x - Left edge.
-     * @param y - Top edge.
-     * @param width - Rectangle width.
-     * @param height - Rectangle height.
-     * @param radii - Corner radius (uniform) or per-corner array as accepted by `CanvasRenderingContext2D.roundRect()`.
-     */
-    roundRect(x: number, y: number, width: number, height: number, radii: number | number[]): void;
-    /**
-     * Draw an image or video frame into the canvas.
-     *
-     * @param source - The image source (HTMLImageElement, HTMLVideoElement, HTMLCanvasElement, etc.).
-     * @param dx - Destination X.
-     * @param dy - Destination Y.
-     * @param dw - Destination width.
-     * @param dh - Destination height.
-     */
-    drawImage(source: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
-    /**
-     * Fill the current path with the given color or gradient.
-     *
-     * @param colorOrGradient - CSS color string or a gradient object.
-     */
-    fill(colorOrGradient: string | any): void;
-    /**
-     * Stroke the current path with the given color or gradient.
-     *
-     * @param colorOrGradient - CSS color string or a gradient object.
-     * @param lineWidth - Stroke width in pixels (default: `1`).
-     */
-    stroke(colorOrGradient: string | any, lineWidth?: number): void;
-    /**
-     * Render a text string at the given position.
-     *
-     * @param text - The string to draw.
-     * @param x - Left edge of the text baseline.
-     * @param y - Baseline Y coordinate.
-     * @param font - CSS font shorthand, e.g. `'16px monospace'`.
-     * @param color - CSS color string or gradient.
-     */
-    fillText(text: string, x: number, y: number, font: string, color: string | any): void;
-    /**
-     * Draw a filled circle through the order-preserving batch.
-     *
-     * Consecutive calls sharing the same `color` and `alpha` are coalesced into a
-     * single path and committed with one `fill()` on {@link flush} (or when the
-     * style changes / another draw call intervenes). Coordinates are in the
-     * current transform space. This collapses the per-entity
-     * `beginPath`/`arc`/`fill` of large point clouds into a handful of draw calls
-     * while preserving painter's-order semantics.
-     *
-     * @param cx - Center X in the current transform space.
-     * @param cy - Center Y in the current transform space.
-     * @param radius - Circle radius.
-     * @param color - CSS color string.
-     * @param alpha - Opacity in `[0, 1]` (default `1`).
-     */
-    fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
-    /**
-     * Commit any pending batched draws (see {@link fillCircle}). Safe to call when
-     * no batch is active (no-op). The {@link Scene} flushes at the end of each
-     * sibling group and frame.
-     */
-    flush(): void;
-    /**
-     * Create a linear gradient between two points with the given color stops.
-     *
-     * @param x0 - X of the gradient start point.
-     * @param y0 - Y of the gradient start point.
-     * @param x1 - X of the gradient end point.
-     * @param y1 - Y of the gradient end point.
-     * @param colorStops - Array of `{ stop, color }` pairs where `stop` is in `[0, 1]`.
-     * @returns An opaque gradient object suitable for {@link fill} or {@link stroke}.
-     */
-    createLinearGradient(x0: number, y0: number, x1: number, y1: number, colorStops: {
-        stop: number;
-        color: string;
-    }[]): any;
-}
-
+import { type MotionConfig, type TweenConfig, type SpringConfig } from '../animation/drivers';
+/** A numeric transform/visual property that participates in the animation system. */
+export type AnimatableProp = 'x' | 'y' | 'scaleX' | 'scaleY' | 'rotation' | 'opacity';
 /**
  * A 2-D coordinate in canvas/world space.
  */
-interface Point {
+export interface Point {
     x: number;
     y: number;
 }
@@ -189,7 +13,7 @@ interface Point {
  *
  * Returned from {@link Entity.getBounds} to enable viewport culling.
  */
-interface Bounds {
+export interface Bounds {
     x: number;
     y: number;
     width: number;
@@ -200,7 +24,7 @@ interface Bounds {
  * origin, returned from {@link Entity.getBatchCircle} to opt into the renderer's
  * draw-call batching fast-path.
  */
-interface BatchCircle {
+export interface BatchCircle {
     /** Circle radius in the entity's local space. */
     radius: number;
     /** CSS fill color. */
@@ -211,7 +35,7 @@ interface BatchCircle {
  * origin, returned from {@link Entity.getBatchRect} to opt into the GPU
  * instanced-rectangle fast-path (WebGL `pointBackend` only).
  */
-interface BatchRect {
+export interface BatchRect {
     /** Rectangle width in the entity's local space. */
     width: number;
     /** Rectangle height in the entity's local space. */
@@ -227,7 +51,7 @@ interface BatchRect {
  * to create and label the shadow DOM node (e.g. a real `<button>` or `<a href>`)
  * so the canvas stays accessible and clickable by automation/agents.
  */
-interface A11yAttributes {
+export interface A11yAttributes {
     /** Shadow element tag to create. Defaults to `'div'`. */
     tag?: 'div' | 'a' | 'button' | 'img' | 'input' | 'textarea';
     /** ARIA role applied via the `role` attribute. */
@@ -263,9 +87,9 @@ interface A11yAttributes {
 /**
  * Union of all pointer/interaction events that can be emitted by an {@link Entity}.
  */
-type VectoEvent = 'click' | 'hover' | 'pointerdown' | 'pointerup' | 'pointermove' | 'pointerleave' | 'change' | 'focus' | 'blur' | 'wheel' | 'keydown' | 'keyup';
+export type VectoEvent = 'click' | 'hover' | 'pointerdown' | 'pointerup' | 'pointermove' | 'pointerleave' | 'change' | 'focus' | 'blur' | 'wheel' | 'keydown' | 'keyup';
 /** Options for {@link Entity.on} / {@link Entity.off}. */
-interface ListenerOptions {
+export interface ListenerOptions {
     /** Register the listener for the capture phase (root→target) instead of bubble. */
     capture?: boolean;
 }
@@ -279,7 +103,7 @@ interface ListenerOptions {
  * `clientX`, `key`, …) and `preventDefault()` pass through to `nativeEvent`, so
  * handlers written against the raw DOM event keep working.
  */
-declare class VectoJSEvent<N = unknown> {
+export declare class VectoJSEvent<N = unknown> {
     /** The event name. */
     readonly type: VectoEvent;
     /** The entity the event originated on. */
@@ -334,7 +158,7 @@ declare class VectoJSEvent<N = unknown> {
  *   }
  * }
  */
-declare abstract class Entity {
+export declare abstract class Entity {
     id: string;
     children: Entity[];
     parent: Entity | null;
@@ -342,12 +166,28 @@ declare abstract class Entity {
      * Walk up the parent chain to find the scene this entity is currently attached to.
      */
     get scene(): any;
-    x: number;
-    y: number;
-    scaleX: number;
-    scaleY: number;
-    rotation: number;
-    opacity: number;
+    private _x;
+    private _y;
+    private _scaleX;
+    private _scaleY;
+    private _rotation;
+    private _opacity;
+    private _hasTransitions;
+    private _transitions;
+    private _drivers;
+    private _mounted;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    get scaleX(): number;
+    set scaleX(v: number);
+    get scaleY(): number;
+    set scaleY(v: number);
+    get rotation(): number;
+    set rotation(v: number);
+    get opacity(): number;
+    set opacity(v: number);
     isDOMPortal: boolean;
     private _interactive;
     get interactive(): boolean;
@@ -383,6 +223,10 @@ declare abstract class Entity {
      * @returns `this` for method chaining.
      */
     add(child: Entity): this;
+    /** Called once when this entity becomes attached to a live Scene. Override to react. */
+    protected onMounted(): void;
+    /** Fire onMounted for this node and its descendants, guarded against double-fire. */
+    private _notifyMounted;
     /**
      * Remove a child entity from this node.
      *
@@ -411,6 +255,26 @@ declare abstract class Entity {
      * @example entity.animate({ x: 400, opacity: 0 }, 500);
      */
     animate(targetProps: Partial<this>, durationMs: number): this;
+    /** Write a driver-computed value to a backing field without re-triggering the setter. */
+    private _applyAnimated;
+    private _currentOf;
+    /**
+     * Write a value immediately, bypassing any configured transition. For subclasses
+     * that need to seed a starting state (e.g. the presence helper's enter `from`).
+     */
+    protected setImmediate(prop: AnimatableProp, v: number): void;
+    private _spawnDriver;
+    /** Assignment path when a declarative transition is configured for `prop`. */
+    private _animateProp;
+    /** Declare which properties animate, and how. Subsequent assignment animates them. */
+    setTransition(config: Partial<Record<AnimatableProp, MotionConfig>>): this;
+    /** Imperative tween toward targets; resolves when all reach their end. */
+    animateTo(props: Partial<Record<AnimatableProp, number>>, cfg: TweenConfig): Promise<void>;
+    /** Imperative spring toward targets; resolves when all reach rest. */
+    springTo(props: Partial<Record<AnimatableProp, number>>, cfg?: SpringConfig): Promise<void>;
+    private _driveTo;
+    /** Advance active property drivers one frame. Call from update(). */
+    protected tickDrivers(dt: number): void;
     /**
      * Advance the entity's internal state for one frame.
      *
@@ -420,7 +284,7 @@ declare abstract class Entity {
      * @param dt - Elapsed time since the last frame in milliseconds.
      * @param time - Absolute timestamp from `performance.now()`.
      */
-    update(_dt: number, time: number): void;
+    update(dt: number, time: number): void;
     /**
      * Register a listener for a {@link VectoEvent}.
      *
@@ -568,5 +432,3 @@ declare abstract class Entity {
      */
     abstract render(renderer: any): void;
 }
-
-export { type A11yAttributes as A, type Bounds as B, Entity as E, type IRenderer as I, type ListenerOptions as L, type Point as P, type VectoEvent as V, type BatchCircle as a, type BatchRect as b, VectoJSEvent as c };

package/dist/tree/Scene.d.ts

@@ -0,0 +1,295 @@
+export interface IWebGLPointRenderer {
+    resize(width: number, height: number): void;
+}
+export type WebGLPointRendererCreator = (canvas: HTMLCanvasElement) => any;
+export interface IWebGPUParticleSystemManager {
+    new (device: GPUDevice): any;
+    initPipelines(format: GPUTextureFormat): Promise<void> | void;
+    setupEntityResources(entity: any): void;
+    recordComputePass(pass: GPUComputePassEncoder, entity: any, dt: number, mouseX: number, mouseY: number, width: number, height: number): void;
+    recordRenderPass(renderPassEncoder: GPURenderPassEncoder, entity: any): void;
+    destroy(): void;
+}
+import { Entity } from './Entity';
+import { IRenderer } from '../renderer/IRenderer';
+/**
+ * Options for {@link Scene}.
+ */
+export interface SceneOptions {
+    /**
+     * Backend for `getBatchCircle()` point-cloud entities:
+     * - `'canvas'` (default): the Canvas2D order-preserving same-color batch.
+     * - `'webgl'`: a stacked WebGL2 layer drawing all such circles in one draw
+     *   call (10–100× throughput for 100k+). Auto-falls back to `'canvas'` when
+     *   WebGL2 is unavailable. The GL layer composites above the 2D content, so its
+     *   points don't interleave per-entity with 2D draws.
+     */
+    pointBackend?: 'canvas' | 'webgl';
+    /**
+     * Backend for particle simulation and rendering:
+     * - `'auto'` (default): tries WebGPU first, falls back to CPU if WebGPU is unavailable or fails.
+     * - `'webgpu'`: forces WebGPU.
+     * - `'cpu'`: forces CPU simulation and rendering (disabling WebGPU completely).
+     */
+    particleBackend?: 'auto' | 'webgpu' | 'cpu';
+    /**
+     * Render the accessibility/automation shadow nodes with a visible blue dashed
+     * outline (development aid). Default `false`: shadow nodes are transparent
+     * (`opacity:0`) — still operable by Playwright/assistive tech, but the canvas
+     * is the only thing seen.
+     */
+    debugA11y?: boolean;
+    /**
+     * Cap the render loop to at most this many frames per second (power saving —
+     * e.g. a quieter fan in a library). `0` (default) means uncapped (native
+     * refresh rate). Continuous animations still run, just less often. Also
+     * settable later via {@link Scene.maxFPS}.
+     */
+    maxFPS?: number;
+    /**
+     * When `true` (default), a system **prefers-reduced-motion** setting auto-caps
+     * the loop to {@link REDUCED_MOTION_FPS} (or the lower of that and `maxFPS`).
+     * Set `false` to ignore the OS setting.
+     */
+    respectReducedMotion?: boolean;
+    /**
+     * Throttle the accessibility/automation shadow-DOM sync to at most once per this
+     * many milliseconds. `0` (default) syncs every rendered frame. During heavy
+     * animation, a small value (e.g. `100`) keeps the a11y layer eventually
+     * consistent while sparing the per-frame DOM writes that can drag Canvas FPS.
+     * Also settable later via {@link Scene.a11ySyncInterval}.
+     */
+    a11ySyncInterval?: number;
+    /**
+     * Custom renderer implementation (e.g., ThreeRenderer from @vectojs/three).
+     * If provided, this renderer will be used for drawing rather than the default CanvasRenderer.
+     */
+    renderer?: IRenderer;
+    /**
+     * Disable the automatic registration of window resize listener.
+     * Useful when Vecto is running inside a custom layout container or offscreen canvas.
+     */
+    disableWindowResize?: boolean;
+}
+/** Frame-rate the loop is capped to when the OS requests reduced motion. */
+export declare const REDUCED_MOTION_FPS = 30;
+export interface A11yTreeNode {
+    id: string;
+    tag: string;
+    role?: string;
+    label?: string;
+    value?: string;
+    checked?: boolean;
+    expanded?: boolean;
+    valuemin?: string;
+    valuemax?: string;
+    children: A11yTreeNode[];
+}
+/**
+ * Top-level orchestrator that owns the entity tree, drive the render loop,
+ * and maintains the accessibility/automation shadow layer.
+ *
+ * Create one `Scene` per `<canvas>` element.  Add {@link Entity} objects via
+ * {@link add}, then call {@link start} to begin the 60-FPS render loop.
+ *
+ * @example
+ * const scene = new Scene(document.querySelector('canvas')!);
+ * scene.add(new CircleEntity().setPosition(100, 100));
+ * scene.start();
+ */
+export declare class Scene {
+    private static webglCreator;
+    private static webgpuManagerClass;
+    static registerWebGLPointRendererCreator(creator: WebGLPointRendererCreator): void;
+    static registerWebGPUParticleSystemManager(managerClass: any): void;
+    private root;
+    overlayRoot: Entity;
+    private renderer;
+    private isRunning;
+    private lastTime;
+    canvas: HTMLCanvasElement;
+    /**
+     * Redraw strategy:
+     * - `'always'` (default): re-render every animation frame (legacy behavior).
+     * - `'onDemand'`: only re-render when the scene is marked dirty (via
+     *   {@link markDirty}) or while an animation is pending. Ideal for static /
+     *   event-driven UIs where idle frames should cost ~0.
+     */
+    renderMode: 'always' | 'onDemand';
+    private dirty;
+    /**
+     * 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}.
+     */
+    maxFPS: number;
+    /** Whether the OS prefers-reduced-motion setting auto-caps the loop. */
+    respectReducedMotion: boolean;
+    /** Cached media-query list; `.matches` is read live each frame. */
+    private reducedMotionQuery;
+    /** True when the OS asks for reduced motion and we respect it. Read by the animation drivers. */
+    get prefersReducedMotion(): boolean;
+    /**
+     * Throttle interval (ms) for the a11y/automation shadow sync. `0` = every
+     * frame. See {@link SceneOptions.a11ySyncInterval}.
+     */
+    a11ySyncInterval: number;
+    /** Timestamp of the last a11y sync, for throttling. */
+    private lastA11ySync;
+    /** True if we skipped an a11y sync during animation and need to sync when at rest. */
+    private a11yPendingSyncAfterAnimation;
+    private a11yRoot;
+    private a11yElements;
+    private resizeHandler;
+    private focusedA11yElement;
+    private caretBlinkTimer;
+    a11yNeedsReorder: boolean;
+    private portalRoot;
+    private fullViewportElements;
+    private normalElements;
+    private activeIds;
+    private activePortalsThisFrame;
+    private activePortalsPrevFrame;
+    private portalEntities;
+    private renderOrderCounter;
+    private pointRenderer;
+    private glCanvas;
+    private debugA11y;
+    width: number;
+    height: number;
+    private disableWindowResize;
+    private destroyed;
+    private device;
+    private deviceLost;
+    particleBackend: 'auto' | 'webgpu' | 'cpu';
+    private _webgpuDisabled;
+    get webgpuDisabled(): boolean;
+    set webgpuDisabled(value: boolean);
+    private recoveryTimerId;
+    private manager;
+    private initializingWebGPU;
+    private gpuCanvas;
+    private gpuContext;
+    private mouseX;
+    private mouseY;
+    private pointerMoveListener;
+    private pointerLeaveListener;
+    private hasWarnedZeroSize;
+    constructor(canvas: HTMLCanvasElement, options?: SceneOptions);
+    /**
+     * Expose the underlying {@link IRenderer} for advanced direct-draw operations.
+     *
+     * @returns The active renderer instance.
+     */
+    getRenderer(): IRenderer;
+    /**
+     * Add a top-level entity to the scene graph.
+     *
+     * @param entity - The entity to attach to the scene root.
+     * @returns `this` for method chaining.
+     * @example scene.add(new CircleEntity());
+     */
+    add(entity: Entity): this;
+    private removeA11yRecursively;
+    /**
+     * Remove a top-level entity from the scene graph and clean up its
+     * accessibility shadow elements recursively.
+     *
+     * @param entity - The entity to detach from the scene root.
+     * @returns `this` for method chaining.
+     */
+    remove(entity: Entity): this;
+    /**
+     * Tear down the a11y/automation shadow nodes for `entity` and its descendants
+     * without removing it from the scene graph. Components that manage dynamic
+     * interactive *child* entities (e.g. a {@link Entity}'s per-link hotspots) call
+     * this before discarding those children so their shadow `<a>`/controls don't
+     * leak (the per-frame `syncA11y` only creates/updates, it never prunes).
+     *
+     * @param entity - The subtree whose shadow nodes should be removed.
+     */
+    detachA11y(entity: Entity): void;
+    /**
+     * Add an overlay entity to the overlay root, bypassing main tree clipping bounds.
+     */
+    showOverlay(overlay: Entity): void;
+    /**
+     * Remove an overlay entity from the overlay root.
+     */
+    hideOverlay(overlay: Entity): void;
+    /**
+     * Tear down the Scene, halt the loop, and clean up event listeners and DOM elements.
+     */
+    destroy(): void;
+    private setupEvents;
+    /**
+     * Begin the `requestAnimationFrame` render loop.
+     *
+     * Idempotent — calling `start()` on an already-running scene is a no-op.
+     */
+    start(): void;
+    /** Schedule the next frame, or no-op where `requestAnimationFrame` is absent (SSR). */
+    private scheduleFrame;
+    /**
+     * Halt the render loop after the current frame completes.
+     *
+     * Call {@link start} again to resume rendering.
+     */
+    stop(): void;
+    /**
+     * Mark the scene as needing a redraw on the next frame.
+     *
+     * Only meaningful in `onDemand` {@link renderMode}: call it after mutating
+     * entity state outside of {@link Entity.animate} so the change is rendered.
+     */
+    markDirty(): void;
+    /** True when any node in the subtree has a pending animation. */
+    private hasAnyPendingAnimation;
+    /** True when any node in the subtree is interactive (drives a11y sync). */
+    private hasAnyInteractive;
+    private syncA11y;
+    private enforceA11yDomOrder;
+    getA11yTree(): A11yTreeNode[];
+    private renderPortalDOM;
+    private reconcilePortals;
+    /**
+     * The frame-rate cap actually in effect: the explicit {@link maxFPS}, further
+     * lowered to {@link REDUCED_MOTION_FPS} when the OS requests reduced motion
+     * (and {@link respectReducedMotion} is on). `0` means uncapped.
+     */
+    private effectiveMaxFPS;
+    private loop;
+    /**
+     * Render the entire scene graph onto the specified renderer.
+     *
+     * @param renderer - The renderer instance to draw to.
+     * @param dt - Delta time in milliseconds (default 0).
+     * @param time - Current absolute time in milliseconds (default 0).
+     */
+    render(renderer: IRenderer, dt?: number, time?: number): void;
+    /**
+     * Export the current scene state to a lightweight, flat SVG XML string.
+     */
+    toSVG(): string;
+    /**
+     * Manually resize the Scene's viewport.
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Gets the accessibility DOM element projected for the given entity ID.
+     */
+    getA11yElement(entityId: string): HTMLElement | undefined;
+    /**
+     * Gets the root entity of the scene.
+     */
+    getRoot(): Entity;
+    /**
+     * Finds the topmost interactive entity at the given coordinates.
+     */
+    findEntityAt(x: number, y: number): Entity | null;
+    private initWebGPUContext;
+    private setupDeviceLostHandler;
+    private recreateWebGPUDeviceWithRetry;
+    private renderCPUParticles;
+    private findHitRecursively;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -35,17 +35,17 @@
       "require": "./dist/index.js"
     },
     "./layout": {
-      "types": "./dist/layout.d.ts",
+      "types": "./dist/layout/index.d.ts",
       "import": "./dist/layout.mjs",
       "require": "./dist/layout.js"
     },
     "./renderer": {
-      "types": "./dist/renderer.d.ts",
+      "types": "./dist/renderer/index.d.ts",
       "import": "./dist/renderer.mjs",
       "require": "./dist/renderer.js"
     },
     "./text": {
-      "types": "./dist/text.d.ts",
+      "types": "./dist/text/index.d.ts",
       "import": "./dist/text.mjs",
       "require": "./dist/text.js"
     }
@@ -54,7 +54,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "node scripts/build-worker.js && tsup",
+    "build": "node scripts/build-worker.js && tsup && tsc -p tsconfig.build.json",
     "test": "vitest run"
   },
   "dependencies": {},