@layoutit/polycss-vue 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -1,20 +1,19 @@
 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 { ApproximateMergeOptions, ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, BoxFace, BoxFaceOptions, BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, CoverPlanarPolygonsOptions, CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, GltfParseOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MeshResolution, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParsedColor, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SolidTextureSampleOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, formatColor, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, ringPolygons, rotateVec3, shadeColor } from '@layoutit/polycss-core';
+import { PropType, Ref, InjectionKey, VNode, CSSProperties, ComputedRef, MaybeRef } from 'vue';
+import * as _layoutit_polycss_core from '@layoutit/polycss-core';
+import { Vec3, CameraState, CameraHandle, Polygon, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolySeamBleed, PolyRenderStrategiesOption, LoadMeshOptions, ParseResult, MeshResolution, PolyMaterial, Vec2, BoxPolygonsOptions, ConePolygonsOptions, CylinderPolygonsOptions, DodecahedronPolygonsOptions, IcosahedronPolygonsOptions, OctahedronPolygonsOptions, PlanePolygonsOptions, RingPolygonsOptions, SpherePolygonsOptions, TetrahedronPolygonsOptions, TorusPolygonsOptions, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
+export { ArrowPolygonsOptions, AutoRotateConfig, AutoRotateOption, AxesHelperOptions, BASE_TILE, BoxFace, BoxFaceOptions, BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, CameraCullNormalGroup, CameraCullRotation, CameraHandle, CameraState, CameraStyleInput, ConePolygonsOptions, CoverPlanarPolygonsOptions, CullInteriorOptions, CylinderPolygonsOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DodecahedronPolygonsOptions, GltfParseOptions, IcosahedronPolygonsOptions, LoadMeshOptions, LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MeshResolution, MtlParseResult, NormalizeResult, ObjParseOptions, OctahedronPolygonsOptions, OptimizeAnimatedMeshPolygonsOptions, OptimizeMeshParseResultOptions, OptimizeMeshPolygonsOptions, ParseAnimationClip, ParseAnimationController, ParseResult, ParseStlColor, ParseStlSolid, ParseStlTopology, ParsedColor, PlanePolygonsOptions, PolyAmbientLight, PolyAnimationAction, PolyAnimationClip, PolyAnimationMixer, PolyAnimationTarget, PolyDirectionalLight, PolyMaterial, PolyRenderStrategiesOption, PolyRenderStrategy, PolyTextureLightingMode, Polygon, PolygonFace, RingPolygonsOptions, SceneBbox, SceneContext, SceneContextBuildArgs, SceneContextBuildResult, SeamFacetSplitCandidate, SeamFacetSplitCandidateReason, SeamFacetSplitOptions, SeamFacetSplitReport, SeamOverlapCandidate, SeamOverlapCandidateKind, SeamOverlapDiagnostics, SeamOverlapOptions, SimplifyTriangleMeshPolygonsOptions, SolidTextureSampleOptions, StlParseOptions, TetrahedronPolygonsOptions, TexturePaintMetrics, TexturePaintMetricsOptions, TextureTriangle, TorusPolygonsOptions, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, boxPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, conePolygons, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, cylinderPolygons, dodecahedronPolygons, formatColor, icosahedronPolygons, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeAnimatedMeshPolygons, optimizeMeshParseResult, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseStl, parseVox, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, simplifyTriangleMeshPolygons, tetrahedronPolygons, torusPolygons } from '@layoutit/polycss-core';
 
-interface PolyPerspectiveCameraProps {
+interface PolyOrthographicCameraProps {
     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<{
+declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     zoom: {
         type: NumberConstructor;
     };
@@ -30,10 +29,6 @@ declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
-    perspective: {
-        type: NumberConstructor;
-        default: undefined;
-    };
     class: {
         type: StringConstructor;
     };
@@ -55,27 +50,23 @@ declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
-    perspective: {
-        type: NumberConstructor;
-        default: undefined;
-    };
     class: {
         type: StringConstructor;
     };
-}>> & Readonly<{}>, {
-    perspective: number;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-interface PolyOrthographicCameraProps {
+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 32000. */
+    perspective?: number;
     class?: string;
 }
-declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
+declare const PolyPerspectiveCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     zoom: {
         type: NumberConstructor;
     };
@@ -91,6 +82,10 @@ declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -112,13 +107,19 @@ declare const PolyOrthographicCamera: vue.DefineComponent<vue.ExtractPropTypes<{
     distance: {
         type: NumberConstructor;
     };
+    perspective: {
+        type: NumberConstructor;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {
+    perspective: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 /**
- * Lightweight reactive store for polycss scene state.
+ * 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.
  */
@@ -207,19 +208,18 @@ interface PolyShadowOptions {
     color?: string;
     opacity?: number;
     lift?: number;
-}
-
-type TextureQuality = number | "auto";
-type PolyRenderStrategy = "b" | "i" | "u";
-interface PolyRenderStrategiesOption {
-    /** Strategies to skip; polygons that would normally use them fall through
-     *  the chain (b → i → s, u → i → s, i → s). `<s>` is the universal
-     *  fallback and cannot be disabled — textured polys have no other path. */
-    disable?: readonly PolyRenderStrategy[];
+    /**
+     * Maximum CSS pixels the shadow may extend beyond the mesh's
+     * footprint. Caps the SVG backing store at low light elevations to
+     * prevent repaint flicker. Default: `2000`. Pass `Infinity` to
+     * disable the cap entirely.
+     */
+    maxExtend?: number;
 }
 
 interface PolySceneProps {
     polygons?: Polygon[];
+    centerPolygons?: Polygon[];
     perspective?: number;
     rotX?: number;
     rotY?: number;
@@ -232,6 +232,8 @@ interface PolySceneProps {
      *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
      *  raster scale and the 64px sprite. */
     textureQuality?: TextureQuality;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
     /** Opt out of specific render strategies. Disabled strategies fall through the chain (b→i→s, u→i→s, i→s). `<s>` cannot be disabled. */
     strategies?: PolyRenderStrategiesOption;
     /**
@@ -242,9 +244,10 @@ interface PolySceneProps {
      */
     autoCenter?: boolean;
     /**
-     * Shadow appearance for meshes with `castShadow: true`. Only applies in
-     * dynamic lighting mode — baked mode does not emit shadow leaves.
-     * Defaults: `{ color: "#000000", opacity: 0.25, lift: 0.05 }`.
+     * Shadow appearance for meshes with `castShadow: true`. Works in both
+     * lighting modes. Shadows emit as SVG paths and reproject when light,
+     * ground, or mesh geometry changes. Defaults:
+     * `{ color: "#000000", opacity: 0.25, lift: 0.05, maxExtend: 2000 }`.
      */
     shadow?: PolyShadowOptions;
     class?: string;
@@ -259,6 +262,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    centerPolygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
     perspective: {
         type: NumberConstructor;
     };
@@ -287,6 +294,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
     strategies: {
         type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
@@ -327,6 +338,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    centerPolygons: {
+        type: PropType<Polygon[]>;
+        default: undefined;
+    };
     perspective: {
         type: NumberConstructor;
     };
@@ -355,6 +370,10 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
     strategies: {
         type: PropType<PolyRenderStrategiesOption>;
         default: undefined;
@@ -390,10 +409,12 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>> & Readonly<{}>, {
     directionalLight: PolyDirectionalLight;
-    textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
+    seamBleed: PolySeamBleed;
+    textureLighting: PolyTextureLightingMode;
     polygons: Polygon[];
+    centerPolygons: Polygon[];
     ambientLight: PolyAmbientLight;
     textureQuality: TextureQuality;
     strategies: PolyRenderStrategiesOption;
@@ -404,10 +425,22 @@ declare const PolyScene: vue.DefineComponent<vue.ExtractPropTypes<{
     debugShowBackfaces: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+type UseMeshOptions = LoadMeshOptions;
+interface UseMeshResult {
+    polygons: Ref<Polygon[]>;
+    voxelSource: Ref<ParseResult["voxelSource"]>;
+    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;
+
 /**
  * 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
+ * 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.
  *
@@ -429,6 +462,12 @@ interface PolyMeshHandle {
     getRotation(): Vec3 | undefined;
     getScale(): number | Vec3 | undefined;
     getPolygons(): Polygon[];
+    /**
+     * Replace the mesh polygons imperatively. Animated solid-triangle meshes use
+     * a stable DOM update path that mutates mounted leaves directly; unsupported
+     * topology falls back to the normal framework render path.
+     */
+    setPolygons(polygons: Polygon[]): void;
     /**
      * Update a single polygon in place. `target` is either a polygon
      * reference (as returned by `getPolygons()`) or its index. `partial`
@@ -514,13 +553,41 @@ interface PolyMeshProps extends InteractionProps {
      *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
      *  raster scale and the 64px sprite. */
     textureQuality?: TextureQuality;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
+    /**
+     * Hold the previous frame until the next atlas is decoded, then swap
+     * atomically. Best for discrete geometry edits where a partial texture
+     * frame would be visible.
+     */
+    atomicAtlas?: boolean;
+    /** Fires when the displayed atlas frame swaps to a ready one in atomic mode. */
+    onFrameReady?: () => void;
     /**
-     * When `true` and the scene is in dynamic lighting mode, the renderer emits
-     * a flat shadow leaf sibling for each non-duplicate polygon. The shadow is
-     * projected onto the ground plane along the CSS-space light direction.
+     * When `true`, emits a per-mesh SVG shadow path in both lighting modes.
+     * Each casting polygon projects onto the scene ground plane along the
+     * directional light; overlapping outlines are merged into one silhouette.
      * Defaults to `false`.
      */
     castShadow?: boolean;
+    /**
+     * When `true`, this mesh acts as a shadow receiver. The scene's caster
+     * meshes (those with `castShadow=true`) project per-coplanar-face SVG
+     * shadows onto each visible surface, matching Three.js's `mesh.receiveShadow`
+     * semantics. Disables the ground-shadow fallback when at least one
+     * receiver exists. Defaults to `false`.
+     */
+    receiveShadow?: boolean;
+    /** Apply mesh optimization (coplanar merge + interior cull) before
+     *  rendering. Defaults to `true` — matches vanilla `scene.add`. Set
+     *  `false` for helper meshes whose geometry shouldn't be merged. */
+    merge?: boolean;
+    /** Mesh optimization intent. Defaults to "lossy"; set "lossless" to keep
+     *  authored surface fidelity. Top-level prop wins over any meshResolution
+     *  that might be set inside parseOptions. */
+    meshResolution?: MeshResolution;
+    /** Parser options forwarded to parseObj/parseGltf/parseVox. */
+    parseOptions?: UseMeshOptions;
     class?: string;
     position?: Vec3;
     scale?: number | Vec3;
@@ -543,6 +610,13 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    /** Optional `parseResult.voxelSource` companion for `.vox` meshes. When
+     *  set alongside `polygons`, the direct voxel renderer fast path
+     *  activates — mirrors vanilla's `scene.add(parseResult)` behaviour. */
+    voxelSource: {
+        type: PropType<_layoutit_polycss_core.ParseResult["voxelSource"]>;
+        default: undefined;
+    };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
@@ -555,10 +629,38 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
+    atomicAtlas: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    onFrameReady: {
+        type: PropType<() => void>;
+        default: undefined;
+    };
     castShadow: {
         type: PropType<boolean>;
         default: boolean;
     };
+    receiveShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    merge: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    meshResolution: {
+        type: PropType<MeshResolution>;
+        default: undefined;
+    };
+    parseOptions: {
+        type: PropType<UseMeshOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -641,6 +743,13 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<Polygon[]>;
         default: undefined;
     };
+    /** Optional `parseResult.voxelSource` companion for `.vox` meshes. When
+     *  set alongside `polygons`, the direct voxel renderer fast path
+     *  activates — mirrors vanilla's `scene.add(parseResult)` behaviour. */
+    voxelSource: {
+        type: PropType<_layoutit_polycss_core.ParseResult["voxelSource"]>;
+        default: undefined;
+    };
     autoCenter: {
         type: BooleanConstructor;
         default: boolean;
@@ -653,10 +762,38 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TextureQuality>;
         default: undefined;
     };
+    seamBleed: {
+        type: PropType<PolySeamBleed>;
+        default: undefined;
+    };
+    atomicAtlas: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    onFrameReady: {
+        type: PropType<() => void>;
+        default: undefined;
+    };
     castShadow: {
         type: PropType<boolean>;
         default: boolean;
     };
+    receiveShadow: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    merge: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    meshResolution: {
+        type: PropType<MeshResolution>;
+        default: undefined;
+    };
+    parseOptions: {
+        type: PropType<UseMeshOptions>;
+        default: undefined;
+    };
     class: {
         type: StringConstructor;
     };
@@ -723,17 +860,25 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{}>, {
     onClick: PolyEventHandler<MouseEvent>;
     onWheel: PolyEventHandler<WheelEvent>;
-    textureLighting: PolyTextureLightingMode;
     position: Vec3;
     scale: number | Vec3;
+    seamBleed: PolySeamBleed;
+    textureLighting: PolyTextureLightingMode;
     polygons: Polygon[];
     textureQuality: TextureQuality;
     autoCenter: boolean;
     rotation: Vec3;
+    voxelSource: _layoutit_polycss_core.PolyVoxelSource | undefined;
     id: string;
     src: string;
     mtl: string;
+    atomicAtlas: boolean;
+    onFrameReady: () => void;
     castShadow: boolean;
+    receiveShadow: boolean;
+    merge: boolean;
+    meshResolution: MeshResolution;
+    parseOptions: _layoutit_polycss_core.LoadMeshOptions;
     onContextMenu: PolyEventHandler<MouseEvent>;
     onDoubleClick: PolyEventHandler<MouseEvent>;
     onPointerDown: PolyEventHandler<PointerEvent>;
@@ -746,6 +891,142 @@ declare const PolyMesh: vue.DefineComponent<vue.ExtractPropTypes<{
     onPointerCancel: PolyEventHandler<PointerEvent>;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
+interface PolyIframeProps {
+    src: string;
+    width: number;
+    height: number;
+    position?: Vec3;
+    rotation?: Vec3;
+    scale?: number | Vec3;
+    allow?: string;
+    sandbox?: string;
+    loading?: "lazy" | "eager";
+    referrerpolicy?: string;
+    title?: string;
+    class?: string;
+    style?: CSSProperties;
+}
+declare const PolyIframe: vue.DefineComponent<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    allow: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sandbox: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<"lazy" | "eager">;
+        default: undefined;
+    };
+    referrerpolicy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    allow: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    sandbox: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    loading: {
+        type: PropType<"lazy" | "eager">;
+        default: undefined;
+    };
+    referrerpolicy: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    class: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    style: CSSProperties;
+    title: string;
+    position: Vec3;
+    scale: number | Vec3;
+    rotation: Vec3;
+    allow: string;
+    sandbox: string;
+    loading: "eager" | "lazy";
+    referrerpolicy: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
 interface PolyGroundProps {
     /** Side length of the ground quad in world units. Default `6`. */
     size?: number;
@@ -753,8 +1034,8 @@ interface PolyGroundProps {
     z?: number;
     /** World-space XY center. Default `[0, 0]`. */
     center?: [number, number];
-    /** Fill color. Default `#7d848e` — medium gray, chosen so 25% black `<q>`
-     *  shadow leaves on top have visible contrast against it. */
+    /** Fill color. Default `#7d848e` — medium gray, chosen so the default
+     *  25% black SVG shadow has visible contrast against it. */
     color?: string;
     class?: string;
 }
@@ -804,9 +1085,9 @@ declare const PolyGround: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>> & Readonly<{}>, {
     class: string;
-    color: string;
     size: number;
     center: [number, number];
+    color: string;
     z: number;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
@@ -821,7 +1102,7 @@ interface UseSceneContextResult {
     };
 }
 /**
- * Vue 3 composable that runs the polycss scene-context pipeline:
+ * 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.
@@ -829,17 +1110,6 @@ interface UseSceneContextResult {
  */
 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
@@ -998,48 +1268,1042 @@ declare const Poly: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>> & Readonly<{}>, {
     data: Record<string, string | number | boolean>;
-    pointerEvents: "none" | "auto";
-    uvs: Vec2[];
-    textureLighting: PolyTextureLightingMode;
     position: Vec3;
+    pointerEvents: "auto" | "none";
     scale: number | Vec3;
+    material: PolyMaterial;
+    uvs: Vec2[];
+    textureLighting: PolyTextureLightingMode;
     textureQuality: TextureQuality;
     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;
+type ShapeMeshProps = Omit<PolyMeshProps, "polygons" | "src" | "mtl">;
+interface PolyBoxProps extends ShapeMeshProps, BoxPolygonsOptions {
 }
-declare const PolyOrbitControls: vue.DefineComponent<vue.ExtractPropTypes<{
-    drag: {
-        type: BooleanConstructor;
+declare const PolyBox: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    center: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    min: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    max: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    texture: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    material: {
+        type: PropType<PolyMaterial>;
+        default: undefined;
+    };
+    uvs: {
+        type: PropType<Vec2[]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<BoxPolygonsOptions["data"]>;
+        default: undefined;
+    };
+    faces: {
+        type: PropType<BoxPolygonsOptions["faces"]>;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    center: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    min: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    max: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    texture: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    material: {
+        type: PropType<PolyMaterial>;
+        default: undefined;
+    };
+    uvs: {
+        type: PropType<Vec2[]>;
+        default: undefined;
+    };
+    data: {
+        type: PropType<BoxPolygonsOptions["data"]>;
+        default: undefined;
+    };
+    faces: {
+        type: PropType<BoxPolygonsOptions["faces"]>;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    data: Record<string, string | number | boolean> | undefined;
+    size: number | Vec3;
+    center: Vec3;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    texture: string;
+    material: PolyMaterial;
+    uvs: Vec2[];
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    faces: Partial<Record<_layoutit_polycss_core.BoxFace, false | _layoutit_polycss_core.BoxFaceOptions>> | undefined;
+    min: Vec3;
+    max: Vec3;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyPlaneProps extends ShapeMeshProps, PlanePolygonsOptions {
+}
+declare const PolyPlane: vue.DefineComponent<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    offset: {
+        type: PropType<number | [number, number]>;
+        default: undefined;
+    };
+    along: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    offset: {
+        type: PropType<number | [number, number]>;
+        default: undefined;
+    };
+    along: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    offset: number | [number, number];
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    along: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyRingProps extends ShapeMeshProps, RingPolygonsOptions {
+}
+declare const PolyRing: vue.DefineComponent<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    radius: {
+        type: NumberConstructor;
+        required: true;
+    };
+    halfThickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    segments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    axis: {
+        type: PropType<0 | 1 | 2>;
+        required: true;
+    };
+    radius: {
+        type: NumberConstructor;
+        required: true;
+    };
+    halfThickness: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    segments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    halfThickness: number;
+    segments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyOctahedronProps extends ShapeMeshProps, OctahedronPolygonsOptions {
+}
+declare const PolyOctahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    center: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    center: {
+        type: PropType<Vec3>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyTetrahedronProps extends ShapeMeshProps, TetrahedronPolygonsOptions {
+}
+declare const PolyTetrahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        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;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyIcosahedronProps extends ShapeMeshProps, IcosahedronPolygonsOptions {
+}
+declare const PolyIcosahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        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;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyDodecahedronProps extends ShapeMeshProps, DodecahedronPolygonsOptions {
+}
+declare const PolyDodecahedron: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        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;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolySphereProps extends ShapeMeshProps, SpherePolygonsOptions {
+}
+declare const PolySphere: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    subdivisions: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    subdivisions: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    subdivisions: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyCylinderProps extends ShapeMeshProps, CylinderPolygonsOptions {
+}
+declare const PolyCylinder: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radiusTop: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radiusTop: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    height: number;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radiusTop: number;
+    radialSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyConeProps extends ShapeMeshProps, ConePolygonsOptions {
+}
+declare const PolyCone: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    height: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    height: number;
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radialSegments: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+interface PolyTorusProps extends ShapeMeshProps, TorusPolygonsOptions {
+}
+declare const PolyTorus: vue.DefineComponent<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tube: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tubularSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    radius: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tube: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    radialSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tubularSegments: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    position: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    scale: {
+        type: PropType<number | Vec3>;
+        default: undefined;
+    };
+    rotation: {
+        type: PropType<Vec3>;
+        default: undefined;
+    };
+    autoCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    position: Vec3;
+    scale: number | Vec3;
+    autoCenter: boolean;
+    rotation: Vec3;
+    id: string;
+    radius: number;
+    radialSegments: number;
+    tube: number;
+    tubularSegments: number;
+}, {}, {}, {}, 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: {
@@ -1775,12 +3039,35 @@ declare const PolyDirectionalLightHelper: vue.DefineComponent<vue.ExtractPropTyp
 }>> & Readonly<{}>, {
     target: Vec3;
     distance: number;
-    color: string;
     size: number;
+    color: string;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare function injectPolyBaseStyles(doc?: Document): void;
 
+interface PolyRenderSurfaceLeafCounts {
+    quad: number;
+    clippedSolid: number;
+    atlas: number;
+    stableTriangle: number;
+}
+interface PolyRenderStats {
+    polygonCount: number;
+    mountedPolygonLeafCount: number;
+    shadowLeafCount: number;
+    surfaceLeafCounts: PolyRenderSurfaceLeafCounts;
+    bucketCount: number;
+}
+interface PolyRenderStatsOptions {
+    polygonCount?: number;
+    /**
+     * Optional subtree selector for diagnostics that only want model leaves and
+     * not helpers/floors/gizmos sharing the same scene root.
+     */
+    scopeSelector?: string;
+}
+declare function collectPolyRenderStats(root: ParentNode | null | undefined, optionsOrPolygonCount?: number | PolyRenderStatsOptions): PolyRenderStats;
+
 interface UsePolyAnimationResultVue {
     /** Attach to a mesh handle when not passing `root` directly. */
     ref: Ref<PolyAnimationTarget | null>;
@@ -1798,4 +3085,4 @@ interface UsePolyAnimationResultVue {
 }
 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, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, 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, type PolyRenderStrategiesOption, type PolyRenderStrategy, 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 };
+export { type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, type PolyBoxProps, PolyOrthographicCamera as PolyCamera, PolyCameraContextKey, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, PolyCone, type PolyConeProps, type PolyContext, type PolyControlsAnimateOptions, PolyCylinder, type PolyCylinderProps, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, PolyDodecahedron, type PolyDodecahedronProps, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, PolyGround, type PolyGroundProps, PolyIcosahedron, type PolyIcosahedronProps, PolyIframe, type PolyIframeProps, PolyMapControls, type PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOctahedron, type PolyOctahedronProps, PolyOrbitControls, type PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, PolyPlane, type PolyPlaneProps, type PolyPointerEvent, type PolyProps, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, type PolyRingProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, PolySelectionContextKey, PolySphere, type PolySphereProps, PolyTetrahedron, type PolyTetrahedronProps, PolyTorus, type PolyTorusProps, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResultVue, type UseSceneContextOptions, type UseSceneContextResult, collectPolyRenderStats, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };