@jamesyong42/infinite-canvas 1.0.0 → 1.2.0

package/dist/SelectionRenderer-CeWSNZT8.d.cts

@@ -1,891 +0,0 @@
-import * as react from 'react';
-import * as _jamesyong42_reactive_ecs from '@jamesyong42/reactive-ecs';
-import { EntityId, ComponentInit, TagType, World, ComponentType, SystemDef, Unsubscribe } from '@jamesyong42/reactive-ecs';
-import * as THREE from 'three';
-
-/**
- * An archetype is a recipe for creating an entity: it declares which components
- * and tags the entity should have on spawn. Archetypes may reference a widget
- * type (for visible entities) or stand alone (for logic-only entities).
- *
- * The engine auto-generates a default archetype for every registered widget
- * that does not have an explicit one — so simple widgets don't need to ship
- * an archetype at all. Write an archetype only when you need to bundle extra
- * behaviour (Container, Locked, custom components) with a widget.
- */
-interface Archetype {
-    /** Unique archetype id. Pass this to `engine.spawn(id, ...)`. */
-    id: string;
-    /**
-     * The widget type this archetype renders as. Required for visible entities;
-     * omit for logic-only entities that have no view.
-     */
-    widget?: string;
-    /** Extra components added on spawn, beyond Transform2D / Widget / WidgetData / ZIndex. */
-    components?: ComponentInit[];
-    /** Extra tags added on spawn, beyond the interactive defaults. */
-    tags?: TagType[];
-    /**
-     * Whether the entity is user-interactive (Selectable + Draggable + Resizable).
-     * Default: true. Set `false` for backdrops, decorations, or locked entities.
-     */
-    interactive?: boolean;
-    /** Overrides the widget's defaultSize. */
-    defaultSize?: {
-        width: number;
-        height: number;
-    };
-}
-/**
- * Options for `engine.spawn(archetypeId, opts)`.
- * All fields are optional — defaults come from the archetype + widget.
- */
-interface SpawnOptions {
-    /** World-space position. Defaults to { x: 0, y: 0 }. */
-    at?: {
-        x: number;
-        y: number;
-    };
-    /** World-space size. Falls back to archetype.defaultSize → widget.defaultSize. */
-    size?: {
-        width: number;
-        height: number;
-    };
-    /** Initial rotation in radians. Default 0. */
-    rotation?: number;
-    /** Data patch merged into the widget's defaultData. */
-    data?: Record<string, unknown>;
-    /** Z-order. Default 0. */
-    zIndex?: number;
-    /** Parent entity for hierarchy nesting. */
-    parent?: EntityId;
-}
-/** Simple in-memory archetype registry. */
-interface ArchetypeRegistry {
-    register(archetype: Archetype): void;
-    get(id: string): Archetype | null;
-    getAll(): Archetype[];
-}
-declare function createArchetypeRegistry(archetypes?: Archetype[]): ArchetypeRegistry;
-
-interface Command {
-    execute(world: World): void;
-    undo(world: World): void;
-}
-declare class CommandBuffer {
-    private undoStack;
-    private redoStack;
-    private currentGroup;
-    /** Start grouping commands (e.g., on pointerdown). All commands until endGroup() are one undo step. */
-    beginGroup(): void;
-    /** Execute a command and record it for undo. */
-    execute(command: Command, world: World): void;
-    /** Close the current group — all commands since beginGroup() become one undo step. */
-    endGroup(): void;
-    /** Undo the last command group. */
-    undo(world: World): boolean;
-    /** Redo the last undone command group. */
-    redo(world: World): boolean;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    clear(): void;
-    get undoSize(): number;
-    get redoSize(): number;
-}
-declare class MoveCommand implements Command {
-    private entityIds;
-    private dx;
-    private dy;
-    private transformType;
-    private beforePositions;
-    private afterPositions;
-    private captured;
-    constructor(entityIds: EntityId[], dx: number, dy: number, transformType: ComponentType<{
-        x: number;
-        y: number;
-    }>);
-    execute(world: World): void;
-    undo(world: World): void;
-}
-declare class ResizeCommand implements Command {
-    private entityId;
-    private before;
-    private after;
-    private transformType;
-    constructor(entityId: EntityId, before: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, after: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }, transformType: ComponentType<{
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }>);
-    execute(world: World): void;
-    undo(world: World): void;
-}
-declare class SetComponentCommand<T> implements Command {
-    private entityId;
-    private type;
-    private before;
-    private after;
-    constructor(entityId: EntityId, type: ComponentType<T>, before: Partial<T>, after: Partial<T>);
-    execute(world: World): void;
-    undo(world: World): void;
-}
-
-/** Position, size, and rotation of an entity in local coordinates (world units). */
-declare const Transform2D: _jamesyong42_reactive_ecs.ComponentType<{
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    rotation: number;
-}>;
-/** Computed world-space bounding box. Read-only -- updated by the transform propagation system. */
-declare const WorldBounds: _jamesyong42_reactive_ecs.ComponentType<{
-    worldX: number;
-    worldY: number;
-    worldWidth: number;
-    worldHeight: number;
-}>;
-/** Rendering and hit-test ordering. Higher values render on top. */
-declare const ZIndex: _jamesyong42_reactive_ecs.ComponentType<{
-    value: number;
-}>;
-/** Parent entity reference. Used for nested containers and handle sync. */
-declare const Parent: _jamesyong42_reactive_ecs.ComponentType<{
-    id: EntityId;
-}>;
-/** Child entity IDs. Used for nested containers and handle sync. */
-declare const Children: _jamesyong42_reactive_ecs.ComponentType<{
-    ids: EntityId[];
-}>;
-/** Marks an entity as a renderable widget with a type identifier and rendering surface. */
-declare const Widget$1: _jamesyong42_reactive_ecs.ComponentType<{
-    surface: "dom" | "webgl" | "webview";
-    type: string;
-}>;
-/** Arbitrary application data attached to a widget entity. Access via useWidgetData(). */
-declare const WidgetData: _jamesyong42_reactive_ecs.ComponentType<{
-    data: Record<string, unknown>;
-}>;
-/** Computed responsive breakpoint based on screen-space size. Read-only. */
-declare const WidgetBreakpoint: _jamesyong42_reactive_ecs.ComponentType<{
-    current: "micro" | "compact" | "normal" | "expanded" | "detailed";
-    screenWidth: number;
-    screenHeight: number;
-}>;
-/** Marks an entity as an enterable container (double-click/double-tap to enter). */
-declare const Container: _jamesyong42_reactive_ecs.ComponentType<{
-    enterable: boolean;
-}>;
-/** Resize handle positions — 4 edges + 4 corners. */
-type ResizeHandlePos = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
-/**
- * Rectangular interactable region anchored relative to the parent entity's WorldBounds.
- * Anchor values are in 0..1 space: 0 = parent min edge, 1 = parent max edge.
- * Widget bodies do NOT need Hitbox — their WorldBounds is already their hit area.
- * Hitbox is only for sub-entities (handles, ports) whose position is parent-relative.
- */
-declare const Hitbox: _jamesyong42_reactive_ecs.ComponentType<{
-    anchorX: number;
-    anchorY: number;
-    width: number;
-    height: number;
-}>;
-/** Discriminated union of interaction roles an entity can fulfil. */
-type InteractionRoleType = {
-    type: 'drag';
-} | {
-    type: 'select';
-} | {
-    type: 'resize';
-    handle: ResizeHandlePos;
-} | {
-    type: 'rotate';
-} | {
-    type: 'connect';
-} | {
-    type: 'canvas';
-};
-type InteractionRoleData = {
-    /** Hit-test priority — higher wins when multiple entities contain the point. */
-    layer: number;
-    /** Discriminated role + role-specific data. */
-    role: InteractionRoleType;
-};
-/**
- * Declares what happens when this entity is hit, plus its hit-test priority.
- * Canonical layers: 0=canvas, 5=widget body, 10=edge handles, 15=corner handles, 20=reserved.
- */
-declare const InteractionRole: _jamesyong42_reactive_ecs.ComponentType<InteractionRoleData>;
-/** Data shape for the HandleSet component. */
-type HandleSetData = {
-    ids: EntityId[];
-};
-/**
- * Component on the parent entity listing the EntityIds of its spawned handle children.
- * Enables O(1) cascade destroy without a reverse-index scan of Parent components.
- */
-declare const HandleSet: _jamesyong42_reactive_ecs.ComponentType<HandleSetData>;
-/** CSS cursor values the canvas may request. */
-type CSSCursor = 'default' | 'grab' | 'grabbing' | 'crosshair' | 'n-resize' | 's-resize' | 'e-resize' | 'w-resize' | 'ne-resize' | 'nw-resize' | 'se-resize' | 'sw-resize';
-type CursorHintData = {
-    /** Cursor when this entity is hovered in idle state. */
-    hover: CSSCursor;
-    /** Cursor while this entity is being dragged/resized. */
-    active: CSSCursor;
-};
-/** Declares the cursor this entity requests when hovered and when active. */
-declare const CursorHint: _jamesyong42_reactive_ecs.ComponentType<CursorHintData>;
-/** Marks an entity as selectable by click or marquee. */
-declare const Selectable: _jamesyong42_reactive_ecs.TagType;
-/** Marks an entity as draggable via pointer interaction. */
-declare const Draggable: _jamesyong42_reactive_ecs.TagType;
-/** Marks an entity as resizable via edge/corner handles. */
-declare const Resizable: _jamesyong42_reactive_ecs.TagType;
-/** Prevents an entity from being moved or resized. */
-declare const Locked: _jamesyong42_reactive_ecs.TagType;
-/** Indicates the entity is currently selected. */
-declare const Selected: _jamesyong42_reactive_ecs.TagType;
-/** Indicates the entity is currently being interacted with (drag, resize). */
-declare const Active: _jamesyong42_reactive_ecs.TagType;
-/** Indicates the entity is within the visible viewport. Set by the cull system. */
-declare const Visible: _jamesyong42_reactive_ecs.TagType;
-
-/**
- * Performance profiler with User Timing API integration.
- * Zero-cost when disabled — all methods are no-ops.
- * When enabled, data shows in Chrome DevTools Performance tab.
- */
-interface FrameSample {
-    tick: number;
-    timestamp: number;
-    /** Total tick duration (ms) */
-    totalMs: number;
-    /** Per-system durations (ms) */
-    systems: Record<string, number>;
-    /** Visible entity computation (ms) */
-    visibilityMs: number;
-    /** Entity counts at this frame */
-    entityCount: number;
-    visibleCount: number;
-}
-interface ProfilerStats {
-    /** Frames per second (based on tick rate, not rAF) */
-    fps: number;
-    /** Frame time stats (ms) */
-    frameTime: {
-        avg: number;
-        p50: number;
-        p95: number;
-        p99: number;
-        max: number;
-    };
-    /** Per-system average time (ms) */
-    systemAvg: Record<string, number>;
-    /** Per-system p95 time (ms) */
-    systemP95: Record<string, number>;
-    /** Frame budget utilization at 60fps (%) */
-    budgetUsed: number;
-    /** Total samples in buffer */
-    sampleCount: number;
-}
-declare class Profiler {
-    private enabled;
-    private ring;
-    private writeIdx;
-    private filled;
-    private frameStart;
-    private currentSystems;
-    private visibilityMs;
-    private currentTick;
-    /** Enable/disable profiling. When disabled, all methods are no-ops. */
-    setEnabled(on: boolean): void;
-    isEnabled(): boolean;
-    /** Call at the start of engine.tick() */
-    beginFrame(tick: number): void;
-    /** Call around each system execution */
-    beginSystem(name: string): void;
-    endSystem(name: string): void;
-    /** Call around the visibility computation phase */
-    beginVisibility(): void;
-    endVisibility(): void;
-    /** Call at the end of engine.tick() */
-    endFrame(entityCount: number, visibleCount: number): void;
-    /** Get the last N frame samples (newest first) */
-    getSamples(count?: number): FrameSample[];
-    /** Compute rolling statistics from the ring buffer */
-    getStats(): ProfilerStats;
-    /** Clear all collected data */
-    clear(): void;
-}
-
-/**
- * Minimal Standard Schema v1 type definition.
- *
- * Compatible with Zod 3.24+, Valibot, ArkType, and any other library that
- * implements the spec at https://standardschema.dev. We do not depend on any
- * validator — users bring their own.
- *
- * Today we only carry the type parameter for `T`. Runtime validation via
- * `validate()` is wired in by features that need it (inspector, serialization).
- */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-    interface Props<Input = unknown, Output = Input> {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        readonly types?: Types<Input, Output>;
-    }
-    type Result<Output> = SuccessResult<Output> | FailureResult;
-    interface SuccessResult<Output> {
-        readonly value: Output;
-        readonly issues?: undefined;
-    }
-    interface FailureResult {
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    interface Issue {
-        readonly message: string;
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    interface PathSegment {
-        readonly key: PropertyKey;
-    }
-    interface Types<Input = unknown, Output = Input> {
-        readonly input: Input;
-        readonly output: Output;
-    }
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-}
-
-/** Rendering surface for a widget. */
-type WidgetSurface = 'dom' | 'webgl';
-/** Props passed to every DOM widget component. */
-interface DomWidgetProps {
-    entityId: EntityId;
-}
-/** Props passed to every R3F widget component. Rendered in local coords. */
-interface R3FWidgetProps {
-    entityId: EntityId;
-    /** Widget width in world units. */
-    width: number;
-    /** Widget height in world units. */
-    height: number;
-}
-interface WidgetBase<T> {
-    /** Unique widget type id. Matches `Widget { type }` on spawned entities. */
-    type: string;
-    /**
-     * Standard Schema v1-compatible schema for the widget's data.
-     * Use Zod 3.24+, Valibot, ArkType, or any other conforming validator.
-     * The schema's output type drives the widget's data type.
-     */
-    schema: StandardSchemaV1<any, T>;
-    /** Default data shape for new instances. Merged with user-supplied data at spawn. */
-    defaultData: T;
-    /** Default world-space size at spawn. */
-    defaultSize: {
-        width: number;
-        height: number;
-    };
-    /** Minimum world-space size when resizing. */
-    minSize?: {
-        width: number;
-        height: number;
-    };
-}
-/** A DOM-rendered widget. The component is wrapped in a sized div — size via CSS. */
-interface DomWidget<T = Record<string, unknown>> extends WidgetBase<T> {
-    surface?: 'dom';
-    component: React.ComponentType<DomWidgetProps>;
-}
-/** An R3F (React Three Fiber) widget. The component receives local-space width/height. */
-interface R3FWidget<T = Record<string, unknown>> extends WidgetBase<T> {
-    surface: 'webgl';
-    component: React.ComponentType<R3FWidgetProps>;
-}
-/** Either kind of widget. */
-type Widget<T = Record<string, unknown>> = DomWidget<T> | R3FWidget<T>;
-interface WidgetRegistry {
-    register(def: Widget): void;
-    get(type: string): Widget | null;
-    getAll(): Widget[];
-}
-declare function createWidgetRegistry(defs?: Widget[]): WidgetRegistry;
-/** Narrows to the R3F variant. */
-declare function isR3FWidget<T>(widget: Widget<T>): widget is R3FWidget<T>;
-
-/** A single frame in the navigation stack, capturing the container and camera state. */
-interface NavigationFrame {
-    containerId: EntityId | null;
-    camera: {
-        x: number;
-        y: number;
-        zoom: number;
-    };
-}
-/** Data shape for the CursorResource. */
-type CursorResourceData = {
-    cursor: CSSCursor;
-};
-/**
- * Output sink for the cursor system. Written by cursorSystem each tick;
- * read by the RAF loop to apply style.cursor on the root container div.
- */
-declare const CursorResource: _jamesyong42_reactive_ecs.ResourceType<CursorResourceData>;
-/** Camera state: world-space position (x, y) and zoom level. Updated by pan/zoom gestures. */
-declare const CameraResource: _jamesyong42_reactive_ecs.ResourceType<{
-    x: number;
-    y: number;
-    zoom: number;
-}>;
-/** Viewport dimensions in CSS pixels and device pixel ratio. Updated on resize. */
-declare const ViewportResource: _jamesyong42_reactive_ecs.ResourceType<{
-    width: number;
-    height: number;
-    dpr: number;
-}>;
-/** Minimum and maximum zoom levels. */
-declare const ZoomConfigResource: _jamesyong42_reactive_ecs.ResourceType<{
-    min: number;
-    max: number;
-}>;
-/** Screen-space pixel thresholds for responsive breakpoints (micro/compact/normal/expanded/detailed). */
-declare const BreakpointConfigResource: _jamesyong42_reactive_ecs.ResourceType<{
-    micro: number;
-    compact: number;
-    normal: number;
-    expanded: number;
-}>;
-/** Navigation stack for hierarchical container traversal. */
-declare const NavigationStackResource: _jamesyong42_reactive_ecs.ResourceType<{
-    frames: NavigationFrame[];
-    changed: boolean;
-}>;
-/** Responsive breakpoint name derived from a widget's screen-space size. */
-type Breakpoint = 'micro' | 'compact' | 'normal' | 'expanded' | 'detailed';
-
-/**
- * Snap guide computation for alignment during drag operations.
- * Implements Figma-style snapping:
- * 1. Edge/center alignment guides
- * 2. Equal spacing snap + indicators
- */
-interface SnapGuide {
-    /** Axis this guide aligns on */
-    axis: 'x' | 'y';
-    /** World-space coordinate of the alignment line */
-    position: number;
-    /** What kind of alignment */
-    type: 'edge' | 'center';
-}
-interface EqualSpacingIndicator {
-    /** Axis along which the equal gaps run */
-    axis: 'x' | 'y';
-    /** The equal gap value (world units) */
-    gap: number;
-    /** Pairs of (from, to) marking each equal gap segment */
-    segments: {
-        from: number;
-        to: number;
-    }[];
-    /** Position on the perpendicular axis (for rendering) */
-    perpPosition: number;
-}
-interface SnapResult {
-    /** Snap-corrected delta (world units). Apply to entity position. */
-    snapDx: number;
-    snapDy: number;
-    /** Active alignment guide lines to render */
-    guides: SnapGuide[];
-    /** Equal spacing indicators */
-    spacings: EqualSpacingIndicator[];
-}
-interface EntityBounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * Compute snap guides for a dragged entity against reference entities.
- */
-declare function computeSnapGuides(dragged: EntityBounds, references: EntityBounds[], threshold: number): SnapResult;
-
-interface Vec2 {
-    x: number;
-    y: number;
-}
-interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-interface AABB {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-/** Convert WorldBounds-shaped data to AABB */
-declare function worldBoundsToAABB(wb: {
-    worldX: number;
-    worldY: number;
-    worldWidth: number;
-    worldHeight: number;
-}): AABB;
-/** Test if two AABBs overlap */
-declare function intersectsAABB(a: AABB, b: AABB): boolean;
-/** Test if a point is inside an AABB */
-declare function pointInAABB(px: number, py: number, a: AABB): boolean;
-/** Convert screen coordinates to world coordinates */
-declare function screenToWorld(screenX: number, screenY: number, camera: {
-    x: number;
-    y: number;
-    zoom: number;
-}): Vec2;
-/** Convert world coordinates to screen coordinates */
-declare function worldToScreen(worldX: number, worldY: number, camera: {
-    x: number;
-    y: number;
-    zoom: number;
-}): Vec2;
-/** Clamp a value between min and max */
-declare function clamp(value: number, min: number, max: number): number;
-
-interface SpatialEntry extends AABB {
-    entityId: EntityId;
-}
-/**
- * Spatial index backed by an R-tree (rbush).
- * Stores world-space AABBs for fast viewport culling and hit testing.
- */
-declare class SpatialIndex {
-    private tree;
-    private entries;
-    upsert(entityId: EntityId, bounds: AABB): void;
-    remove(entityId: EntityId): void;
-    /** Query all entries intersecting the given AABB */
-    search(bounds: AABB): SpatialEntry[];
-    /** Find the topmost entity at a point (by z-order — caller sorts) */
-    searchPoint(x: number, y: number, tolerance?: number): SpatialEntry[];
-    clear(): void;
-    get size(): number;
-}
-
-/** ECS resource holding the SpatialIndex instance for viewport culling and hit testing. */
-declare const SpatialIndexResource: _jamesyong42_reactive_ecs.ResourceType<{
-    instance: SpatialIndex | null;
-}>;
-/** Directive returned by pointer handlers indicating how the canvas should handle capture. */
-type PointerDirective = {
-    action: 'passthrough';
-} | {
-    action: 'passthrough-track-drag';
-} | {
-    action: 'capture-drag';
-} | {
-    action: 'capture-resize';
-    handle: ResizeHandlePos;
-} | {
-    action: 'capture-marquee';
-};
-
-/** Keyboard modifier state captured alongside pointer events. */
-interface Modifiers {
-    shift: boolean;
-    ctrl: boolean;
-    alt: boolean;
-    meta: boolean;
-}
-/** A visible entity with its computed world-space bounds and display metadata. */
-interface VisibleEntity {
-    entityId: EntityId;
-    worldX: number;
-    worldY: number;
-    worldWidth: number;
-    worldHeight: number;
-    breakpoint: Breakpoint;
-    zIndex: number;
-    surface: string;
-    widgetType: string;
-}
-/** Per-frame change flags indicating what changed during the last tick. */
-interface FrameChanges {
-    /** Entities whose world-space position or size changed. */
-    positionsChanged: EntityId[];
-    /** Entities whose responsive breakpoint changed. */
-    breakpointsChanged: EntityId[];
-    /** Entities that entered the visible viewport. */
-    entered: EntityId[];
-    /** Entities that exited the visible viewport. */
-    exited: EntityId[];
-    /** Whether the camera position or zoom changed. */
-    cameraChanged: boolean;
-    /** Whether the navigation stack changed (entered/exited container). */
-    navigationChanged: boolean;
-    /** Whether the selection set changed. */
-    selectionChanged: boolean;
-}
-/** Configuration options for `createLayoutEngine()`. */
-interface LayoutEngineConfig {
-    /** Maximum entity count (default: 10000). */
-    maxEntities?: number;
-    /** Minimum and maximum zoom levels. */
-    zoom?: {
-        min: number;
-        max: number;
-    };
-    /** Screen-space pixel thresholds for responsive breakpoints. */
-    breakpoints?: {
-        micro: number;
-        compact: number;
-        normal: number;
-        expanded: number;
-    };
-    /** Snap alignment configuration. */
-    snap?: {
-        /** Whether snapping is enabled initially. */
-        enabled?: boolean;
-        /** Snap distance threshold in screen pixels. */
-        threshold?: number;
-    };
-    /** Widget definitions available to `spawn()`. */
-    widgets?: Widget[];
-    /** Archetype definitions available to `spawn()`. */
-    archetypes?: Archetype[];
-}
-/**
- * The core layout engine. Manages the ECS world, camera, input, undo/redo,
- * spatial indexing, and frame lifecycle for an infinite canvas.
- */
-interface LayoutEngine {
-    /** The underlying ECS world. Use for direct component/tag/resource access. */
-    readonly world: World;
-    /** Creates a bare entity with optional initial components/tags. Low-level escape hatch. */
-    createEntity(inits?: ComponentInit[]): EntityId;
-    /**
-     * Spawns a new entity from a registered archetype or widget type.
-     * If `id` matches a registered archetype, that archetype is used.
-     * Otherwise, if `id` matches a registered widget, a default archetype is synthesized.
-     * Otherwise, a bare default archetype with type=`id` is used (useful in tests).
-     */
-    spawn(id: string, opts?: SpawnOptions): EntityId;
-    /** Removes an entity and cleans up all components, tags, and spatial index entries. */
-    destroyEntity(id: EntityId): void;
-    /** Registers a widget definition. Auto-creates a matching default archetype if none exists. */
-    registerWidget(widget: Widget): void;
-    /** Returns a registered widget by type, or null. */
-    getWidget(type: string): Widget | null;
-    /** Returns all registered widgets. */
-    getWidgets(): Widget[];
-    /** Registers a custom archetype. */
-    registerArchetype(archetype: Archetype): void;
-    /** Returns a registered archetype by id, or null. */
-    getArchetype(id: string): Archetype | null;
-    /** Reads a component from an entity. Returns undefined if not present. */
-    get<T>(entity: EntityId, type: ComponentType<T>): T | undefined;
-    /** Updates a component on an entity (partial merge). */
-    set<T>(entity: EntityId, type: ComponentType<T>, data: Partial<T>): void;
-    /** Checks if an entity has a component or tag. */
-    has(entity: EntityId, type: ComponentType | TagType): boolean;
-    /** Registers a custom ECS system to run each tick. */
-    registerSystem(system: SystemDef): void;
-    /** Removes a registered system by name. */
-    removeSystem(name: string): void;
-    /** Returns the current camera state {x, y, zoom}. */
-    getCamera(): {
-        x: number;
-        y: number;
-        zoom: number;
-    };
-    /** Moves the camera by the specified screen-space delta. */
-    panBy(dx: number, dy: number): void;
-    /** Moves the camera to the specified world coordinates. */
-    panTo(worldX: number, worldY: number): void;
-    /** Adjusts zoom level anchored at a screen point. Delta is a multiplier offset. */
-    zoomAtPoint(screenX: number, screenY: number, delta: number): void;
-    /** Sets the zoom level directly. */
-    zoomTo(zoom: number): void;
-    /** Adjusts camera to fit all entities (or specified entities) in the viewport. */
-    zoomToFit(entityIds?: EntityId[], padding?: number): void;
-    /** Updates the viewport dimensions. Called automatically by InfiniteCanvas on resize. */
-    setViewport(width: number, height: number, dpr?: number): void;
-    /** Pointer-down handler. Returns a directive for how the canvas should capture the pointer. */
-    handlePointerDown(screenX: number, screenY: number, button: number, modifiers: Modifiers): PointerDirective;
-    /** Pointer-move handler. Returns a directive reflecting the current interaction. */
-    handlePointerMove(screenX: number, screenY: number, modifiers: Modifiers): PointerDirective;
-    /** Pointer-up handler. Commits drags/resizes and returns a directive. */
-    handlePointerUp(): PointerDirective;
-    /** Cancels the current pointer interaction without committing changes. */
-    handlePointerCancel(): void;
-    /** Returns IDs of all currently selected entities. */
-    getSelectedEntities(): EntityId[];
-    /** Returns the entity currently under the pointer, or null. */
-    getHoveredEntity(): EntityId | null;
-    /** Navigates into a container entity, pushing the current camera onto the navigation stack. */
-    enterContainer(entity: EntityId): void;
-    /** Navigates out of the current container, restoring the previous camera state. */
-    exitContainer(): void;
-    /** Returns the entity ID of the currently active container, or null if at root. */
-    getActiveContainer(): EntityId | null;
-    /** Returns the current navigation depth (0 = root). */
-    getNavigationDepth(): number;
-    /** Executes a command and pushes it onto the undo stack. */
-    execute(command: Command): void;
-    /** Begins a command group -- subsequent commands are bundled into one undo step. */
-    beginCommandGroup(): void;
-    /** Ends the current command group. */
-    endCommandGroup(): void;
-    /** Undoes the last command or command group. Returns true if anything was undone. */
-    undo(): boolean;
-    /** Redoes the last undone command. Returns true if anything was redone. */
-    redo(): boolean;
-    /** Returns whether there is a command to undo. */
-    canUndo(): boolean;
-    /** Returns whether there is a command to redo. */
-    canRedo(): boolean;
-    /** Schedules a tick on the next animation frame. Call after programmatic changes. */
-    markDirty(): void;
-    /** Runs one frame: executes all ECS systems, updates spatial index, emits frame events. */
-    tick(): void;
-    /** Ticks only if dirty. Returns true if a tick was performed. */
-    flushIfDirty(): boolean;
-    /** Returns visible entities with their world-space bounds, breakpoint, and surface info. */
-    getVisibleEntities(): VisibleEntity[];
-    /** Returns per-frame change flags from the last tick. */
-    getFrameChanges(): FrameChanges;
-    /** Returns the spatial index used for viewport culling and hit testing. */
-    getSpatialIndex(): SpatialIndex;
-    /** Returns active snap guide lines from the last tick. */
-    getSnapGuides(): SnapGuide[];
-    /** Returns equal-spacing indicators from the last tick. */
-    getEqualSpacing(): EqualSpacingIndicator[];
-    /** Enables or disables snap alignment. */
-    setSnapEnabled(on: boolean): void;
-    /** Sets the snap distance threshold in world pixels. */
-    setSnapThreshold(worldPx: number): void;
-    /** Performance profiler for measuring system execution times. */
-    readonly profiler: Profiler;
-    /** Registers a callback invoked after each tick. Returns an unsubscribe function. */
-    onFrame(handler: () => void): Unsubscribe;
-    /** Destroys the engine, releasing all resources and subscriptions. */
-    destroy(): void;
-}
-/**
- * Creates a new LayoutEngine instance with the given configuration.
- * This is the main entry point for the infinite canvas library.
- */
-declare function createLayoutEngine(config?: LayoutEngineConfig): LayoutEngine;
-
-declare const EngineProvider: react.Provider<LayoutEngine | null>;
-declare const ContainerRefProvider: react.Provider<react.RefObject<HTMLDivElement | null> | null>;
-declare function useContainerRef(): React.RefObject<HTMLDivElement | null> | null;
-/**
- * Returns the LayoutEngine instance from the nearest InfiniteCanvas context.
- * Throws if used outside an InfiniteCanvas provider.
- */
-declare function useLayoutEngine(): LayoutEngine;
-
-/**
- * Discriminated resolution of a widget by type. The surface determines which
- * layer renders the component and with what prop shape.
- */
-type ResolvedWidget = {
-    surface: 'dom';
-    component: React.ComponentType<DomWidgetProps>;
-} | {
-    surface: 'webgl';
-    component: React.ComponentType<R3FWidgetProps>;
-};
-type WidgetResolver = (entityId: EntityId, widgetType: string) => ResolvedWidget | null;
-declare const WidgetResolverProvider: react.Provider<WidgetResolver | null>;
-declare function useWidgetResolver(): WidgetResolver | null;
-
-interface GridConfig {
-    /** World-unit spacings for up to 3 grid levels [fine, medium, coarse]. */
-    spacings: [number, number, number];
-    /** Dot RGB color as [r, g, b] in 0–1 range. */
-    dotColor: [number, number, number];
-    /** Base dot opacity multiplier (0–1). */
-    dotAlpha: number;
-    /** CSS-pixel range where a grid level fades in: [start, end]. */
-    fadeIn: [number, number];
-    /** CSS-pixel range where a grid level fades out: [start, end]. */
-    fadeOut: [number, number];
-    /** Dot radius range in CSS pixels [min, max]. Scaled by DPR internally. */
-    dotRadius: [number, number];
-    /** Per-level opacity weight: level i gets (base + i * step). */
-    levelWeight: [number, number];
-}
-declare const DEFAULT_GRID_CONFIG: GridConfig;
-declare class GridRenderer {
-    private renderer;
-    private scene;
-    private camera;
-    private material;
-    private mesh;
-    constructor(canvas: HTMLCanvasElement);
-    /** Apply a (partial) grid config. Only provided fields are updated. */
-    setConfig(config: Partial<GridConfig>): void;
-    setSize(width: number, height: number, dpr?: number): void;
-    render(cameraX: number, cameraY: number, zoom: number): void;
-    dispose(): void;
-    /** Expose for future WebGL widget rendering */
-    getWebGLRenderer(): THREE.WebGLRenderer;
-}
-
-interface SelectionConfig {
-    /** Selection outline color [r,g,b] 0-1. Default: Figma blue. */
-    outlineColor: [number, number, number];
-    /** Selection outline width in screen px. */
-    outlineWidth: number;
-    /** Hover outline color [r,g,b] 0-1. */
-    hoverColor: [number, number, number];
-    /** Hover outline width in screen px. */
-    hoverWidth: number;
-    /** Handle size in screen px. */
-    handleSize: number;
-    /** Handle fill color [r,g,b] 0-1 (white). */
-    handleFill: [number, number, number];
-    /** Handle border color [r,g,b] 0-1 (same as outline). */
-    handleBorder: [number, number, number];
-    /** Handle border width in screen px. */
-    handleBorderWidth: number;
-    /** Group bbox dash length in screen px (0 = solid). */
-    groupDash: number;
-}
-declare const DEFAULT_SELECTION_CONFIG: SelectionConfig;
-interface SelectionBounds {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-declare class SelectionRenderer {
-    private material;
-    private mesh;
-    private scene;
-    private camera;
-    constructor();
-    setConfig(config: Partial<SelectionConfig>): void;
-    setSize(resolution: THREE.Vector2, dpr: number): void;
-    render(renderer: THREE.WebGLRenderer, cameraX: number, cameraY: number, zoom: number, selected: SelectionBounds[], hovered: SelectionBounds | null, guides?: SnapGuide[], spacings?: EqualSpacingIndicator[]): void;
-    dispose(): void;
-}
-
-export { type R3FWidget as $, type AABB as A, type Breakpoint as B, ContainerRefProvider as C, DEFAULT_GRID_CONFIG as D, EngineProvider as E, type FrameSample as F, GridRenderer as G, type EqualSpacingIndicator as H, type FrameChanges as I, HandleSet as J, type HandleSetData as K, type LayoutEngine as L, Hitbox as M, type NavigationFrame as N, InteractionRole as O, Profiler as P, type InteractionRoleData as Q, type ResolvedWidget as R, SelectionRenderer as S, type InteractionRoleType as T, type LayoutEngineConfig as U, Locked as V, type Modifiers as W, MoveCommand as X, NavigationStackResource as Y, Parent as Z, type PointerDirective as _, type R3FWidgetProps as a, type Rect as a0, Resizable as a1, ResizeCommand as a2, type ResizeHandlePos as a3, Selectable as a4, Selected as a5, type SelectionBounds as a6, SetComponentCommand as a7, type SnapGuide as a8, type SnapResult as a9, useLayoutEngine as aA, useWidgetResolver as aB, worldBoundsToAABB as aC, worldToScreen as aD, type SpawnOptions as aa, StandardSchemaV1 as ab, Transform2D as ac, type Vec2 as ad, ViewportResource as ae, Visible as af, type VisibleEntity as ag, Widget$1 as ah, WidgetBreakpoint as ai, WidgetData as aj, type Widget as ak, type WidgetRegistry as al, WidgetResolverProvider as am, type WidgetSurface as an, WorldBounds as ao, ZIndex as ap, ZoomConfigResource as aq, clamp as ar, createArchetypeRegistry as as, createLayoutEngine as at, createWidgetRegistry as au, intersectsAABB as av, isR3FWidget as aw, pointInAABB as ax, screenToWorld as ay, useContainerRef as az, type ProfilerStats as b, SpatialIndex as c, SpatialIndexResource as d, computeSnapGuides as e, type GridConfig as f, type SelectionConfig as g, Active as h, type Archetype as i, type ArchetypeRegistry as j, BreakpointConfigResource as k, type CSSCursor as l, CameraResource as m, Children as n, type Command as o, CommandBuffer as p, Container as q, CursorHint as r, type CursorHintData as s, CursorResource as t, type CursorResourceData as u, DEFAULT_SELECTION_CONFIG as v, type DomWidget as w, type DomWidgetProps as x, Draggable as y, type EntityBounds as z };