@layoutit/polycss-vue 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,1439 @@
+import * as vue from 'vue';
+import { PropType, Ref, InjectionKey, VNode, ComputedRef, MaybeRef } from 'vue';
+import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, LoadMeshOptions, PolyMaterial, Vec2, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
+export { ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, buildSceneContext, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, formatColor, inverseRotateVec3, loadMesh, mergePolygons, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, polygonFaces, ringPolygons, rotateVec3, shadeColor } from '@layoutit/polycss-core';
+
+interface PolyPerspectiveCameraProps {
+    zoom?: number;
+    target?: Vec3;
+    rotX?: number;
+    rotY?: number;
+    /** Camera pull-back in CSS pixels (dolly). Default 0. */
+    distance?: number;
+    /** CSS perspective distance in pixels. Defaults to 8000. */
+    perspective?: number;
+    class?: string;
+}
+declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+    zoom: {
+        type: NumberConstructor;
+    };
+    target: {
+        type: PropType<Vec3>;
+    };
+    rotX: {
+        type: NumberConstructor;
+    };
+    rotY: {
+        type: NumberConstructor;
+    };
+    distance: {
+        type: NumberConstructor;
+    };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    zoom: {
+        type: NumberConstructor;
+    };
+    target: {
+        type: PropType<Vec3>;
+    };
+    rotX: {
+        type: NumberConstructor;
+    };
+    rotY: {
+        type: NumberConstructor;
+    };
+    distance: {
+        type: NumberConstructor;
+    };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {
+    perspective: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyOrthographicCameraProps {
+    zoom?: number;
+    target?: Vec3;
+    rotX?: number;
+    rotY?: number;
+    /** Camera pull-back in CSS pixels (dolly). Default 0. */
+    distance?: number;
+    class?: string;
+}
+declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+    zoom: {
+        type: NumberConstructor;
+    };
+    target: {
+        type: PropType<Vec3>;
+    };
+    rotX: {
+        type: NumberConstructor;
+    };
+    rotY: {
+        type: NumberConstructor;
+    };
+    distance: {
+        type: NumberConstructor;
+    };
+    class: {
+        type: StringConstructor;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    zoom: {
+        type: NumberConstructor;
+    };
+    target: {
+        type: PropType<Vec3>;
+    };
+    rotX: {
+        type: NumberConstructor;
+    };
+    rotY: {
+        type: NumberConstructor;
+    };
+    distance: {
+        type: NumberConstructor;
+    };
+    class: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Lightweight reactive store for polycss scene state.
+ * Components subscribe to specific slices via selectors,
+ * so only the components that care about a changed value re-render.
+ */
+
+interface SceneStoreState {
+    cameraState: CameraState;
+}
+interface SceneStore {
+    getState(): SceneStoreState;
+    setState(partial: Partial<SceneStoreState>): void;
+    subscribe(listener: () => void): () => void;
+    /** Update camera state from the current imperative camera handle. */
+    updateCameraFromRef(handle: CameraHandle): boolean;
+    /** Force notify all subscribers (e.g. after prop-driven camera change). */
+    notifyAll(): void;
+}
+
+interface UseCameraOptions {
+    zoom?: number;
+    target?: Vec3;
+    rotX?: number;
+    rotY?: number;
+    distance?: number;
+}
+interface UseCameraResult {
+    store: SceneStore;
+    cameraRef: Ref<CameraHandle>;
+    sceneElRef: Ref<HTMLElement | null>;
+    /**
+     * Bind to the camera root element. Layered components like
+     * <PolyOrbitControls> need the underlying ref to wire non-passive wheel /
+     * pointer listeners (Vue's @wheel is passive by default in modern
+     * versions and can't preventDefault).
+     */
+    cameraElRef: Ref<HTMLDivElement | null>;
+    /**
+     * Apply the current camera state (from cameraRef.value.state) directly
+     * to sceneEl.style.transform. Exposed so layered components like
+     * <PolyOrbitControls> can call it after mutating cameraRef.value.
+     */
+    applyTransformDirect: () => void;
+}
+declare function usePolyCamera(options: Ref<UseCameraOptions>): UseCameraResult;
+
+interface PolyCameraContextValue {
+    store: SceneStore;
+    cameraRef: Ref<CameraHandle>;
+    sceneElRef: Ref<HTMLElement | null>;
+    /**
+     * Camera root element ref. Exposed so layered components like
+     * <PolyControls> can attach pointer/wheel listeners.
+     */
+    cameraElRef: Ref<HTMLElement | null>;
+    /**
+     * Apply the current camera state (from cameraRef.value.state) directly
+     * to sceneEl.style.transform. Layered components call this after
+     * mutating cameraRef.value to make the DOM reflect the new state.
+     */
+    applyTransformDirect: () => void;
+}
+declare const PolyCameraContextKey: InjectionKey<PolyCameraContextValue>;
+
+type AtlasScale = number | "auto";
+
+interface PolySceneProps {
+    polygons?: Polygon[];
+    perspective?: number;
+    rotX?: number;
+    rotY?: number;
+    zoom?: number;
+    directionalLight?: PolyDirectionalLight;
+    ambientLight?: PolyAmbientLight;
+    textureLighting?: PolyTextureLightingMode;
+    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
+    atlasScale?: AtlasScale;
+    /**
+     * When `true`, rotation pivots around the mesh's bbox center instead of
+     * world (0,0,0). Polygon data is not mutated — a wrapper div translates
+     * the polygons so the bbox center coincides with the scene anchor (0,0,0).
+     * Mirrors React's PolyScene autoCenter prop.
+     */
+    autoCenter?: boolean;
+    class?: string;
+    position?: Vec3;
+    scale?: number | Vec3;
+    rotation?: Vec3;
+    debugShowLabels?: boolean;
+    debugShowBackfaces?: boolean;
+}
+declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
+    polygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
+    perspective: {
+        type: NumberConstructor;
+    };
+    rotX: {
+        type: NumberConstructor;
+    };
+    rotY: {
+        type: NumberConstructor;
+    };
+    zoom: {
+        type: NumberConstructor;
+    };
+    directionalLight: {
+        type: PropType<PolyDirectionalLight>;
+        default: undefined;
+    };
+    ambientLight: {
+        type: PropType<PolyAmbientLight>;
+        default: undefined;
+    };
+    textureLighting: {
+        type: PropType<PolyTextureLightingMode>;
+        default: string;
+    };
+    atlasScale: {
+        type: PropType<AtlasScale>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: StringConstructor;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    debugShowLabels: {
+        type: BooleanConstructor;
+    };
+    debugShowBackfaces: {
+        type: BooleanConstructor;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    polygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
+    perspective: {
+        type: NumberConstructor;
+    };
+    rotX: {
+        type: NumberConstructor;
+    };
+    rotY: {
+        type: NumberConstructor;
+    };
+    zoom: {
+        type: NumberConstructor;
+    };
+    directionalLight: {
+        type: PropType<PolyDirectionalLight>;
+        default: undefined;
+    };
+    ambientLight: {
+        type: PropType<PolyAmbientLight>;
+        default: undefined;
+    };
+    textureLighting: {
+        type: PropType<PolyTextureLightingMode>;
+        default: string;
+    };
+    atlasScale: {
+        type: PropType<AtlasScale>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    class: {
+        type: StringConstructor;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    debugShowLabels: {
+        type: BooleanConstructor;
+    };
+    debugShowBackfaces: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    directionalLight: PolyDirectionalLight;
+    textureLighting: PolyTextureLightingMode;
+    position: Vec3;
+    scale: number | Vec3;
+    atlasScale: AtlasScale;
+    polygons: Polygon[];
+    ambientLight: PolyAmbientLight;
+    autoCenter: boolean;
+    rotation: Vec3;
+    debugShowLabels: boolean;
+    debugShowBackfaces: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Pointer event API for `<PolyMesh>` (Vue). Mirrors @react-three/fiber's
+ * mesh event surface (handler names + payload shape) so devs migrating
+ * from three.js use the same mental model. polycss is DOM-native so
+ * we get native pointer events for free — no raycaster, no canvas
+ * event synthesis.
+ *
+ * Diverges from r3f in two intentional ways:
+ *   1. Bubbling matches DOM (pointer hits the front element only).
+ *   2. `face`, `uv`, `uv1`, `instanceId` are omitted — three.js
+ *      BufferGeometry / InstancedMesh concepts with no polycss
+ *      analogue.
+ */
+
+/** Imperative handle exposed by `<PolyMesh>` via Vue's defineExpose.
+ *  Read-only view of the mesh's element + current transform +
+ *  polygons. Mutation flows through controlled props (parent owns
+ *  transform state). */
+interface PolyMeshHandle {
+    readonly element: HTMLDivElement | null;
+    readonly id?: string;
+    getPosition(): Vec3 | undefined;
+    getRotation(): Vec3 | undefined;
+    getScale(): number | Vec3 | undefined;
+    getPolygons(): Polygon[];
+    /**
+     * Re-rasterize the baked texture atlas using the mesh's current rotation.
+     *
+     * Call this after a rotation gesture completes (e.g. on rotate-ring pointer
+     * release) to correct stale lighting. Baked atlas tiles encode
+     * `baseColor × Lambert(worldNormal, worldLight)` at bake time. When the
+     * mesh wrapper rotates via CSS, the polygon normals change in world space
+     * but the pre-multiplied colors don't — faces stay lit/unlit incorrectly.
+     *
+     * `rebakeAtlas()` advances the internal `bakedRotation` snapshot to the
+     * current `rotation` prop and re-runs the atlas pipeline, this time
+     * inverse-rotating the world light into the mesh-local frame so that
+     * `dot(localNormal, localLight) === dot(worldNormal, worldLight)` holds.
+     *
+     * In `textureLighting === "dynamic"` mode this is a no-op: dynamic
+     * shading is computed per-frame from live surface-normal CSS vars, so it
+     * is always correct and never needs rebaking.
+     */
+    rebakeAtlas(): void;
+}
+interface PolyPointerEvent<E extends Event = PointerEvent> {
+    object: PolyMeshHandle;
+    eventObject: PolyMeshHandle;
+    intersections: Array<{
+        object: PolyMeshHandle;
+    }>;
+    pointer: {
+        x: number;
+        y: number;
+    };
+    delta: number;
+    nativeEvent: E;
+    stopPropagation(): void;
+}
+type PolyMouseEvent = PolyPointerEvent<MouseEvent>;
+type PolyWheelEvent = PolyPointerEvent<WheelEvent>;
+type PolyEventHandler<E extends Event = PointerEvent> = (event: PolyPointerEvent<E>) => void;
+/** Pointer / mouse / wheel handlers accepted by `<PolyMesh>`. Same
+ *  names as r3f. Provide any handler to opt in to events. */
+interface InteractionProps {
+    onClick?: PolyEventHandler<MouseEvent>;
+    onContextMenu?: PolyEventHandler<MouseEvent>;
+    onDoubleClick?: PolyEventHandler<MouseEvent>;
+    onWheel?: PolyEventHandler<WheelEvent>;
+    onPointerDown?: PolyEventHandler<PointerEvent>;
+    onPointerUp?: PolyEventHandler<PointerEvent>;
+    onPointerMove?: PolyEventHandler<PointerEvent>;
+    onPointerOver?: PolyEventHandler<PointerEvent>;
+    onPointerOut?: PolyEventHandler<PointerEvent>;
+    onPointerEnter?: PolyEventHandler<PointerEvent>;
+    onPointerLeave?: PolyEventHandler<PointerEvent>;
+    onPointerCancel?: PolyEventHandler<PointerEvent>;
+}
+declare function findPolyMeshHandle(el: Element | null): PolyMeshHandle | null;
+declare function pointInMeshElement(meshEl: HTMLElement, clientX: number, clientY: number): boolean;
+declare function findMeshUnderPoint(clientX: number, clientY: number, filter?: (meshEl: HTMLElement) => boolean): PolyMeshHandle | null;
+
+interface PolyMeshProps extends InteractionProps {
+    /** Stable identifier — exposed on the mesh handle and reflected on
+     *  the wrapper as `data-poly-mesh-id`. Used by Select / TransformControls
+     *  for selection lookups. */
+    id?: string;
+    src?: string;
+    /**
+     * Companion `.mtl` URL for OBJ models. When set, materials defined in
+     * the mtl are applied to the loaded mesh. Ignored for GLB/GLTF.
+     */
+    mtl?: string;
+    polygons?: Polygon[];
+    autoCenter?: boolean;
+    textureLighting?: PolyTextureLightingMode;
+    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
+    atlasScale?: AtlasScale;
+    class?: string;
+    position?: Vec3;
+    scale?: number | Vec3;
+    rotation?: Vec3;
+}
+declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    src: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    mtl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    polygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    textureLighting: {
+        type: PropType<PolyTextureLightingMode>;
+        default: undefined;
+    };
+    atlasScale: {
+        type: PropType<AtlasScale>;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    onClick: {
+        type: PropType<PolyEventHandler<MouseEvent>>;
+        default: undefined;
+    };
+    onContextMenu: {
+        type: PropType<PolyEventHandler<MouseEvent>>;
+        default: undefined;
+    };
+    onDoubleClick: {
+        type: PropType<PolyEventHandler<MouseEvent>>;
+        default: undefined;
+    };
+    onWheel: {
+        type: PropType<PolyEventHandler<WheelEvent>>;
+        default: undefined;
+    };
+    onPointerDown: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerUp: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerMove: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerOver: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerOut: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerEnter: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerLeave: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerCancel: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    src: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    mtl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    polygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    textureLighting: {
+        type: PropType<PolyTextureLightingMode>;
+        default: undefined;
+    };
+    atlasScale: {
+        type: PropType<AtlasScale>;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    onClick: {
+        type: PropType<PolyEventHandler<MouseEvent>>;
+        default: undefined;
+    };
+    onContextMenu: {
+        type: PropType<PolyEventHandler<MouseEvent>>;
+        default: undefined;
+    };
+    onDoubleClick: {
+        type: PropType<PolyEventHandler<MouseEvent>>;
+        default: undefined;
+    };
+    onWheel: {
+        type: PropType<PolyEventHandler<WheelEvent>>;
+        default: undefined;
+    };
+    onPointerDown: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerUp: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerMove: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerOver: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerOut: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerEnter: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerLeave: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+    onPointerCancel: {
+        type: PropType<PolyEventHandler<PointerEvent>>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    onClick: PolyEventHandler<MouseEvent>;
+    onWheel: PolyEventHandler<WheelEvent>;
+    textureLighting: PolyTextureLightingMode;
+    position: Vec3;
+    scale: number | Vec3;
+    atlasScale: AtlasScale;
+    polygons: Polygon[];
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    src: string;
+    mtl: string;
+    onContextMenu: PolyEventHandler<MouseEvent>;
+    onDoubleClick: PolyEventHandler<MouseEvent>;
+    onPointerDown: PolyEventHandler<PointerEvent>;
+    onPointerUp: PolyEventHandler<PointerEvent>;
+    onPointerMove: PolyEventHandler<PointerEvent>;
+    onPointerOver: PolyEventHandler<PointerEvent>;
+    onPointerOut: PolyEventHandler<PointerEvent>;
+    onPointerEnter: PolyEventHandler<PointerEvent>;
+    onPointerLeave: PolyEventHandler<PointerEvent>;
+    onPointerCancel: PolyEventHandler<PointerEvent>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface UseSceneContextOptions {
+    directionalLight?: PolyDirectionalLight;
+}
+interface UseSceneContextResult {
+    polygons: Polygon[];
+    sceneBbox: {
+        min: Vec3;
+        max: Vec3;
+    };
+}
+/**
+ * Vue 3 composable that runs the polycss scene-context pipeline:
+ *   normalizePolygons → mergePolygons by default → bbox compute.
+ *
+ * Returns a Ref to the processed polygons + the scene-wide axis-aligned bbox.
+ * Recomputes when `polygons` or relevant options change.
+ */
+declare function usePolySceneContext(polygons: Ref<Polygon[]>, options: Ref<UseSceneContextOptions>): Ref<UseSceneContextResult>;
+
+type UseMeshOptions = LoadMeshOptions;
+interface UseMeshResult {
+    polygons: Ref<Polygon[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    warnings: Ref<string[]>;
+    /** Manually trigger cleanup (also called on unmount automatically). */
+    dispose: () => void;
+}
+declare function usePolyMesh(src: Ref<string>, options?: UseMeshOptions): UseMeshResult;
+
+/**
+ * usePolyMaterial — Vue composable that returns a stable computed material
+ * handle. Accepts either a plain options object or a reactive getter so that
+ * reactive texture URLs (e.g. from a blob URL that updates) stay tracked.
+ *
+ * Stable computed identity means v-memo comparisons on <Poly> work correctly
+ * when the inputs haven't changed.
+ */
+declare function usePolyMaterial(source: {
+    texture: string;
+    key?: string;
+} | (() => {
+    texture: string;
+    key?: string;
+})): ComputedRef<PolyMaterial>;
+
+interface PolyContext {
+    tileSize?: number;
+    layerElevation?: number;
+    directionalLight?: PolyDirectionalLight;
+    textureLighting?: PolyTextureLightingMode;
+    atlasScale?: AtlasScale;
+    debugShowBackfaces?: boolean;
+    [key: string]: unknown;
+}
+interface PolyProps {
+    vertices: Vec3[];
+    color?: string;
+    texture?: string;
+    uvs?: Vec2[];
+    data?: Record<string, string | number | boolean>;
+    /** Shared material. When set AND the polygon's UVs form an axis-aligned
+     *  rectangle, renders via `background-image` directly — no per-polygon
+     *  canvas rasterization. Falls back to the atlas path otherwise. */
+    material?: PolyMaterial;
+    position?: Vec3;
+    scale?: number | Vec3;
+    rotation?: Vec3;
+    context?: PolyContext;
+    textureLighting?: PolyTextureLightingMode;
+    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
+    atlasScale?: AtlasScale;
+    baseColor?: string;
+    pointerEvents?: "auto" | "none";
+}
+declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
+    vertices: {
+        type: PropType<Vec3[]>;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+    };
+    texture: {
+        type: StringConstructor;
+    };
+    uvs: {
+        type: PropType<Vec2[]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<Record<string, string | number | boolean>>;
+        default: undefined;
+    };
+    material: {
+        type: PropType<PolyMaterial>;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    textureLighting: {
+        type: PropType<PolyTextureLightingMode>;
+        default: undefined;
+    };
+    atlasScale: {
+        type: PropType<AtlasScale>;
+        default: undefined;
+    };
+    context: {
+        type: PropType<PolyContext>;
+        default: undefined;
+    };
+    baseColor: {
+        type: StringConstructor;
+    };
+    pointerEvents: {
+        type: PropType<"auto" | "none">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    vertices: {
+        type: PropType<Vec3[]>;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+    };
+    texture: {
+        type: StringConstructor;
+    };
+    uvs: {
+        type: PropType<Vec2[]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<Record<string, string | number | boolean>>;
+        default: undefined;
+    };
+    material: {
+        type: PropType<PolyMaterial>;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    textureLighting: {
+        type: PropType<PolyTextureLightingMode>;
+        default: undefined;
+    };
+    atlasScale: {
+        type: PropType<AtlasScale>;
+        default: undefined;
+    };
+    context: {
+        type: PropType<PolyContext>;
+        default: undefined;
+    };
+    baseColor: {
+        type: StringConstructor;
+    };
+    pointerEvents: {
+        type: PropType<"auto" | "none">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    data: Record<string, string | number | boolean>;
+    pointerEvents: "none" | "auto";
+    uvs: Vec2[];
+    textureLighting: PolyTextureLightingMode;
+    position: Vec3;
+    scale: number | Vec3;
+    atlasScale: AtlasScale;
+    rotation: Vec3;
+    material: PolyMaterial;
+    context: PolyContext;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyControlsAnimateOptions {
+    speed?: number;
+    axis?: "x" | "y";
+    pauseOnInteraction?: boolean;
+}
+interface PolyOrbitControlsCamera {
+    rotX: number;
+    rotY: number;
+    zoom: number;
+    target: Vec3;
+    distance: number;
+}
+interface PolyOrbitControlsProps {
+    drag?: boolean;
+    wheel?: boolean;
+    /** When true, wheel changes camera pull-back (distance) instead of zoom scale. */
+    dolly?: boolean;
+    invert?: boolean | number;
+    /** Minimum zoom multiplier (zoom mode). Default 0.1. */
+    minZoom?: number;
+    /** Maximum zoom multiplier (zoom mode). Default 10. */
+    maxZoom?: number;
+    /** Minimum camera pull-back in CSS pixels when dolly=true. Default 0. */
+    minDistance?: number;
+    /** Maximum camera pull-back in CSS pixels when dolly=true. Default 5000. */
+    maxDistance?: number;
+    animate?: false | PolyControlsAnimateOptions;
+}
+declare const PolyOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_camera: PolyOrbitControlsCamera) => true;
+    "interaction-start": (_camera: PolyOrbitControlsCamera) => true;
+    "interaction-end": (_camera: PolyOrbitControlsCamera) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((_camera: PolyOrbitControlsCamera) => any) | undefined;
+    "onInteraction-start"?: ((_camera: PolyOrbitControlsCamera) => any) | undefined;
+    "onInteraction-end"?: ((_camera: PolyOrbitControlsCamera) => any) | undefined;
+}>, {
+    drag: boolean;
+    wheel: boolean;
+    animate: false | PolyControlsAnimateOptions;
+    dolly: boolean;
+    invert: number | boolean;
+    minZoom: number;
+    maxZoom: number;
+    minDistance: number;
+    maxDistance: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyMapControlsCamera {
+    rotX: number;
+    rotY: number;
+    zoom: number;
+    target: Vec3;
+    distance: number;
+}
+interface PolyMapControlsProps {
+    drag?: boolean;
+    wheel?: boolean;
+    /** When true, wheel changes camera pull-back (distance) instead of zoom scale. */
+    dolly?: boolean;
+    invert?: boolean | number;
+    /** Minimum zoom multiplier (zoom mode). Default 0.1. */
+    minZoom?: number;
+    /** Maximum zoom multiplier (zoom mode). Default 10. */
+    maxZoom?: number;
+    /** Minimum camera pull-back in CSS pixels when dolly=true. Default 0. */
+    minDistance?: number;
+    /** Maximum camera pull-back in CSS pixels when dolly=true. Default 5000. */
+    maxDistance?: number;
+    animate?: false | PolyControlsAnimateOptions;
+}
+declare const PolyMapControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>, () => null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_camera: PolyMapControlsCamera) => true;
+    "interaction-start": (_camera: PolyMapControlsCamera) => true;
+    "interaction-end": (_camera: PolyMapControlsCamera) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    drag: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wheel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dolly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    invert: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    minZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxZoom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxDistance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animate: {
+        type: PropType<false | PolyControlsAnimateOptions>;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((_camera: PolyMapControlsCamera) => any) | undefined;
+    "onInteraction-start"?: ((_camera: PolyMapControlsCamera) => any) | undefined;
+    "onInteraction-end"?: ((_camera: PolyMapControlsCamera) => any) | undefined;
+}>, {
+    drag: boolean;
+    wheel: boolean;
+    animate: false | PolyControlsAnimateOptions;
+    dolly: boolean;
+    invert: number | boolean;
+    minZoom: number;
+    maxZoom: number;
+    minDistance: number;
+    maxDistance: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyTransformControlsObjectChangeEvent {
+    object: PolyMeshHandle;
+    position?: Vec3;
+    rotation?: Vec3;
+}
+interface PolyTransformControlsProps {
+    object: PolyTransformControlsObject;
+    mode?: "translate" | "rotate";
+    space?: "world" | "local";
+    size?: number;
+    showX?: boolean;
+    showY?: boolean;
+    showZ?: boolean;
+    translationSnap?: number | null;
+    rotationSnap?: number | null;
+    enabled?: boolean;
+    onChange?: () => void;
+    onObjectChange?: (event: PolyTransformControlsObjectChangeEvent) => void;
+    onMouseDown?: () => void;
+    onMouseUp?: () => void;
+    onDraggingChanged?: (dragging: boolean) => void;
+}
+/** `object` prop: either a PolyMeshHandle directly or a Vue ref to one
+ *  (e.g. a template ref via `:object="meshRef"`). */
+type PolyTransformControlsObject = PolyMeshHandle | Ref<PolyMeshHandle | null | undefined> | ComputedRef<PolyMeshHandle | null | undefined> | null;
+declare const PolyTransformControls: vue.DefineComponent<vue.ExtractPropTypes<{
+    object: {
+        type: PropType<PolyTransformControlsObject>;
+        default: null;
+    };
+    mode: {
+        type: PropType<"translate" | "rotate">;
+        default: string;
+    };
+    space: {
+        type: PropType<"world" | "local">;
+        default: string;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showX: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showY: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showZ: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    translationSnap: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    rotationSnap: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: () => true;
+    objectChange: (_e: PolyTransformControlsObjectChangeEvent) => true;
+    mouseDown: () => true;
+    mouseUp: () => true;
+    draggingChanged: (_d: boolean) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    object: {
+        type: PropType<PolyTransformControlsObject>;
+        default: null;
+    };
+    mode: {
+        type: PropType<"translate" | "rotate">;
+        default: string;
+    };
+    space: {
+        type: PropType<"world" | "local">;
+        default: string;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showX: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showY: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showZ: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    translationSnap: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    rotationSnap: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: (() => any) | undefined;
+    onObjectChange?: ((_e: PolyTransformControlsObjectChangeEvent) => any) | undefined;
+    onMouseDown?: (() => any) | undefined;
+    onMouseUp?: (() => any) | undefined;
+    onDraggingChanged?: ((_d: boolean) => any) | undefined;
+}>, {
+    object: PolyTransformControlsObject;
+    mode: "rotate" | "translate";
+    space: "local" | "world";
+    size: number;
+    enabled: boolean;
+    showX: boolean;
+    showY: boolean;
+    showZ: boolean;
+    translationSnap: number | null;
+    rotationSnap: number | null;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolySelectProps {
+    multiple?: boolean;
+    clearOnMiss?: boolean;
+    filter?: (meshes: PolyMeshHandle[]) => PolyMeshHandle[];
+    onChange?: (meshes: PolyMeshHandle[]) => void;
+    onPointerMissed?: (event: MouseEvent) => void;
+}
+interface PolySelectionApi {
+    selected: ReadonlyArray<PolyMeshHandle>;
+    set(next: PolyMeshHandle[]): void;
+    add(handle: PolyMeshHandle): void;
+    remove(handle: PolyMeshHandle): void;
+    toggle(handle: PolyMeshHandle): void;
+    clear(): void;
+    has(handle: PolyMeshHandle): boolean;
+}
+declare const PolySelectionContextKey: InjectionKey<{
+    selected: ComputedRef<PolyMeshHandle[]>;
+    api: PolySelectionApi;
+}>;
+declare const PolySelect: vue.DefineComponent<vue.ExtractPropTypes<{
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearOnMiss: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filter: {
+        type: PropType<(meshes: PolyMeshHandle[]) => PolyMeshHandle[]>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    change: (_meshes: PolyMeshHandle[]) => true;
+    pointerMissed: (_event: MouseEvent) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearOnMiss: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filter: {
+        type: PropType<(meshes: PolyMeshHandle[]) => PolyMeshHandle[]>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onChange?: ((_meshes: PolyMeshHandle[]) => any) | undefined;
+    onPointerMissed?: ((_event: MouseEvent) => any) | undefined;
+}>, {
+    filter: (meshes: PolyMeshHandle[]) => PolyMeshHandle[];
+    multiple: boolean;
+    clearOnMiss: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/** Read the current selection from the nearest enclosing `<PolySelect>`.
+ *  Returns an empty array when called outside one. */
+declare function usePolySelect(): ComputedRef<PolyMeshHandle[]>;
+/** Read the imperative selection API. Throws when called outside a `<PolySelect>`. */
+declare function usePolySelectionApi(): PolySelectionApi;
+
+interface PolyAxesHelperProps {
+    size?: number;
+    thickness?: number;
+    negative?: boolean;
+    xColor?: string;
+    yColor?: string;
+    zColor?: string;
+}
+declare const PolyAxesHelper: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    thickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    negative: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    xColor: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    yColor: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    zColor: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    thickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    negative: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    xColor: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    yColor: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    zColor: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    thickness: number;
+    negative: boolean;
+    xColor: string;
+    yColor: string;
+    zColor: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface PolyDirectionalLightHelperProps {
+    light: PolyDirectionalLight;
+    target?: Vec3;
+    distance?: number;
+    size?: number;
+    color?: string;
+}
+declare const PolyDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTypes<{
+    light: {
+        type: PropType<PolyDirectionalLight>;
+        required: true;
+    };
+    target: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    distance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    light: {
+        type: PropType<PolyDirectionalLight>;
+        required: true;
+    };
+    target: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    distance: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    target: Vec3;
+    distance: number;
+    color: string;
+    size: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare function injectPolyBaseStyles(doc?: Document): void;
+
+interface UsePolyAnimationResultVue {
+    /** Attach to a mesh handle when not passing `root` directly. */
+    ref: Ref<PolyAnimationTarget | null>;
+    /** The active mixer, or null if inputs are not ready yet. */
+    mixer: ComputedRef<PolyAnimationMixer | null>;
+    /** Resolved clip list. */
+    clips: ComputedRef<PolyAnimationClip[]>;
+    /** Clip names in input order. */
+    names: ComputedRef<string[]>;
+    /**
+     * Lazy action proxy keyed by clip name. Accessing `actions.value["walk"]`
+     * instantiates the action via the mixer. Returns null when mixer is null.
+     */
+    actions: ComputedRef<Record<string, PolyAnimationAction | null>>;
+}
+declare function usePolyAnimation(clips: MaybeRef<PolyAnimationClip[] | undefined>, controller: MaybeRef<ParseAnimationController | undefined>, root?: MaybeRef<PolyAnimationTarget | null | undefined>): UsePolyAnimationResultVue;
+
+export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyPerspectiveCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyPerspectiveCameraProps as PolyCameraProps, type PolyContext, type PolyControlsAnimateOptions, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, type PolyEventHandler, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, type PolyPointerEvent, type PolyProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResultVue, type UseSceneContextOptions, type UseSceneContextResult, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };