@layoutit/polycss-react 0.2.6 → 0.2.8

package/dist/index.d.cts

@@ -1,9 +1,10 @@
 import * as React$1 from 'react';
-import React__default, { ReactNode, CSSProperties, MouseEventHandler, PointerEventHandler, FocusEventHandler, KeyboardEventHandler, IframeHTMLAttributes, RefObject, MouseEvent as MouseEvent$1 } from 'react';
+import React__default, { ReactNode, CSSProperties, IframeHTMLAttributes, RefObject, MouseEvent } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as _layoutit_polycss_core from '@layoutit/polycss-core';
-import { Vec3, CameraState, CameraHandle, PolyCameraProjection, PolyTextureImageSource, PolyTexturePresentation, Vec2, PolyMaterial, PolyDirectionalLight, PolyTextureLightingMode, TextureQuality, PolyTextureLeafSizing, PolyTextureImageRendering, PolyTextureBackend, PolyTextureProjection, Polygon, PolyAmbientLight, PolySeamBleed, PolyRenderStrategiesOption, LoadMeshOptions, ParseResult, MeshResolution, BoxPolygonsOptions, ConePolygonsOptions, CylinderPolygonsOptions, DodecahedronPolygonsOptions, IcosahedronPolygonsOptions, OctahedronPolygonsOptions, PlanePolygonsOptions, RingPolygonsOptions, SpherePolygonsOptions, TetrahedronPolygonsOptions, TorusPolygonsOptions, PolyAnimationTarget, PolyAnimationMixer, PolyAnimationClip, PolyAnimationAction, ParseAnimationController } from '@layoutit/polycss-core';
+import { Vec3, CameraState, CameraHandle, PolyCameraProjection, Polygon, PolyDirectionalLight, PolyPointLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolyTextureLeafSizing, PolyTextureImageRendering, PolyTextureBackend, PolyTextureProjection, PolySeamBleed, PolyRenderStrategiesOption, PolyMaterial, 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, PolyCameraProjection, PolyCameraSnapshot, PolyCameraSnapshotOptions, PolyCameraSnapshotSource, PolyDirectionalLight, PolyMaterial, PolyMeshTransformInput, PolyRenderStrategiesOption, PolyRenderStrategy, PolySceneTransformInput, PolyTextureBackend, PolyTextureImageLighting, PolyTextureImageRendering, PolyTextureImageSource, PolyTextureLeafSizing, PolyTextureLightingMode, PolyTexturePresentation, PolyTextureProjection, 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, buildPolyCameraSceneTransform, buildPolyMeshTransform, buildPolySceneTransform, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, capturePolyCameraSnapshot, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, conePolygons, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cssDistanceToWorld, cssPositionToWorld, 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, polyCameraTargetToCss, polyCssDistanceToWorld, polyCssPositionToWorld, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, repairMeshSeams, resolvePolyCameraAppliedPerspectiveStyle, ringPolygons, rotateVec3, seamFacetSplitPolygons, seamFacetSplitReport, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, simplifyTriangleMeshPolygons, tetrahedronPolygons, torusPolygons, worldDirectionToCss, worldDirectionToPolyCss, worldDirectionalLightToCss, worldDirectionalLightToPolyCss, worldDistanceToCss, worldDistanceToPolyCss, worldPositionToCss, worldPositionToPolyCss } from '@layoutit/polycss-core';
+import { T as TransformProps, P as PolyProps, a as PolyMeshProps, b as PolyMeshHandle } from './PolyMesh-7fLCYk5L.cjs';
+export { D as DOMPassthroughProps, I as InteractionProps, c as PolyEventHandler, d as PolyMesh, e as PolyMouseEvent, f as PolyPointerEvent, g as PolyWheelEvent, U as UseMeshOptions, h as UseMeshResult, i as findMeshUnderPoint, j as findPolyMeshHandle, p as pointInMeshElement, u as usePolyMesh } from './PolyMesh-7fLCYk5L.cjs';
 
 interface PolyPerspectiveCameraProps {
     zoom?: number;
@@ -118,91 +119,32 @@ interface ShadowOptions {
      * disable the cap entirely.
      */
     maxExtend?: number;
-}
-
-/** Three.js-style transform props accepted by every PolyCSS component. */
-interface TransformProps {
-    position?: Vec3;
-    scale?: number | Vec3;
-    rotation?: Vec3;
-}
-/**
- * DOM event handlers, ARIA, and style props forwarded to the rendered
- * element by every Poly component.
- *
- * This is the DOM-native pitch: polygons are real DOM nodes you can
- * target with CSS, attach event handlers to, and inspect in DevTools.
- */
-interface DOMPassthroughProps {
-    className?: string;
-    style?: CSSProperties;
-    id?: string;
-    onClick?: MouseEventHandler<HTMLElement>;
-    onDoubleClick?: MouseEventHandler<HTMLElement>;
-    onMouseEnter?: MouseEventHandler<HTMLElement>;
-    onMouseLeave?: MouseEventHandler<HTMLElement>;
-    onMouseMove?: MouseEventHandler<HTMLElement>;
-    onPointerDown?: PointerEventHandler<HTMLElement>;
-    onPointerUp?: PointerEventHandler<HTMLElement>;
-    onPointerEnter?: PointerEventHandler<HTMLElement>;
-    onPointerLeave?: PointerEventHandler<HTMLElement>;
-    onFocus?: FocusEventHandler<HTMLElement>;
-    onBlur?: FocusEventHandler<HTMLElement>;
-    onKeyDown?: KeyboardEventHandler<HTMLElement>;
-    tabIndex?: number;
-    role?: string;
-    "aria-label"?: string;
-    "aria-hidden"?: boolean;
-    pointerEvents?: "auto" | "none";
-    [dataAttr: `data-${string}`]: string | number | boolean | undefined;
-}
-/**
- * Props for the `<Poly>` component — the atomic polygon primitive.
- *
- * Extends TransformProps + DOMPassthroughProps with the polygon's own fields.
- * This is the canonical Poly component API.
- */
-interface PolyProps extends TransformProps, DOMPassthroughProps {
-    vertices: Vec3[];
-    color?: string;
-    texture?: string;
-    textureImageSource?: PolyTextureImageSource;
-    texturePresentation?: PolyTexturePresentation;
-    uvs?: Vec2[];
-    data?: Record<string, string | number | boolean>;
-    doubleSided?: 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;
-    context?: {
-        tileSize?: number;
-        layerElevation?: number;
-        directionalLight?: PolyDirectionalLight;
-        textureLighting?: PolyTextureLightingMode;
-        textureQuality?: TextureQuality;
-        textureLeafSizing?: PolyTextureLeafSizing;
-        textureImageRendering?: PolyTextureImageRendering;
-        textureBackend?: PolyTextureBackend;
-        textureProjection?: PolyTextureProjection;
-        debugShowBackfaces?: boolean;
-        [key: string]: unknown;
-    };
-    /** Textured polygon lighting mode. Defaults to scene context, then "baked". */
-    textureLighting?: PolyTextureLightingMode;
-    /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
-     *  device-appropriate memory budget and desktop/mobile sprite sizing. */
-    textureQuality?: TextureQuality;
-    /** Atlas leaf CSS primitive sizing. Defaults to scene context, then canonical. */
-    textureLeafSizing?: PolyTextureLeafSizing;
-    /** Default image filtering for atlas and direct image texture leaves. */
-    textureImageRendering?: PolyTextureImageRendering;
-    /** Default texture backend request. Defaults to scene context, then "auto". */
-    textureBackend?: PolyTextureBackend;
-    /** Default texture projection request. Defaults to scene context, then "affine". */
-    textureProjection?: PolyTextureProjection;
-    /** Pre-computed shaded base color from the parent (optional override). */
-    baseColor?: string;
+    /**
+     * Cast a low-resolution parametric silhouette per caster instead of its full
+     * geometry — lighter DOM + cheaper projection at the cost of an approximate
+     * outline. Casts onto every receiver through the normal pipeline. Default:
+     * `false`. (Directional + point lights; the exact path stays the default.)
+     */
+    parametric?: boolean;
+    /**
+     * Parametric-shadow detail (max silhouette points / pixel-grid resolution).
+     * Only used when `parametric` is true. Default: `16`. Override per mesh via
+     * `<PolyMesh shadowDefinition>`.
+     */
+    definition?: number;
+    /**
+     * Parametric render style: `"vector"` (smooth contour, default) or `"pixel"`
+     * (greedy-meshed voxel blocks; `definition` becomes the grid resolution).
+     */
+    style?: "vector" | "pixel";
+    /**
+     * Re-emit a caster's shadow while it animates (deforms) so the shadow follows
+     * the pose instead of freezing. Default `false`: a same-topology deform keeps
+     * the last shadow pose (re-emitting every frame is expensive). Best with
+     * `parametric` — a low-res silhouette is cheap to reproject. Topology changes
+     * (different polygon count) always re-emit regardless.
+     */
+    followAnimation?: boolean;
 }
 
 interface PolySceneProps extends TransformProps {
@@ -227,6 +169,9 @@ interface PolySceneProps extends TransformProps {
     rotY?: number;
     zoom?: number;
     directionalLight?: PolyDirectionalLight;
+    /** Point lights (world-space positions). Direction-only per-face Lambert,
+     *  baked-mode only. */
+    pointLights?: PolyPointLight[];
     ambientLight?: PolyAmbientLight;
     /** Textured polygon lighting mode. Defaults to "baked". */
     textureLighting?: PolyTextureLightingMode;
@@ -275,255 +220,9 @@ interface PolySceneProps extends TransformProps {
     debugShowLabels?: boolean;
     debugShowBackfaces?: boolean;
 }
-declare function PolySceneInner({ polygons: polygonsProp, centerPolygons: centerPolygonsProp, perspective: _perspective, rotX: _rotX, rotY: _rotY, zoom: _zoom, directionalLight, ambientLight, textureLighting, textureQuality, textureLeafSizing, textureImageRendering, textureBackend, textureProjection, seamBleed, strategies, autoCenter, shadow, className, style, children, position: _position, scale: _scale, rotation: _rotation, debugShowLabels: _debugShowLabels, debugShowBackfaces, }: PolySceneProps): react_jsx_runtime.JSX.Element;
+declare function PolySceneInner({ polygons: polygonsProp, centerPolygons: centerPolygonsProp, perspective: _perspective, rotX: _rotX, rotY: _rotY, zoom: _zoom, directionalLight, pointLights, ambientLight, textureLighting, textureQuality, textureLeafSizing, textureImageRendering, textureBackend, textureProjection, seamBleed, strategies, autoCenter, shadow, className, style, children, position: _position, scale: _scale, rotation: _rotation, debugShowLabels: _debugShowLabels, debugShowBackfaces, }: PolySceneProps): react_jsx_runtime.JSX.Element;
 declare const PolyScene: React$1.MemoExoticComponent<typeof PolySceneInner>;
 
-type UseMeshOptions = LoadMeshOptions;
-interface UseMeshResult {
-    polygons: Polygon[];
-    voxelSource: ParseResult["voxelSource"];
-    loading: boolean;
-    error: Error | null;
-    warnings: string[];
-    /** Manually trigger cleanup (also called on unmount automatically). */
-    dispose: () => void;
-}
-declare function usePolyMesh(src: string, options?: UseMeshOptions): UseMeshResult;
-
-/**
- * Pointer event API for <PolyMesh>. 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). r3f
- *      replays events to occluded objects behind the front hit; doing
- *      that here would require running our own raycaster, which defeats
- *      the point of being DOM-native.
- *   2. `face`, `uv`, `uv1`, `instanceId` are omitted — they're three.js
- *      BufferGeometry / InstancedMesh concepts with no polycss analogue.
- *      The polycss-native equivalent of `face` is the hit polygon's
- *      index, exposed via `polygon` (set when the underlying DOM target
- *      is an `<i>` polygon element).
- */
-
-/**
- * Imperative handle exposed by `<PolyMesh ref>`. Read-only view of the
- * mesh's element + current transform + polygons. Mutation flows through
- * controlled props (parent owns transform state) — matches three.js
- * editor's pattern of keeping `selected` external to the object.
- */
-interface PolyMeshHandle {
-    /** The `.polycss-mesh` wrapper div (null until mounted). */
-    readonly element: HTMLDivElement | null;
-    /** Identifier passed via the `id` prop, if any. */
-    readonly id?: string;
-    /** Current `position` prop value. */
-    getPosition(): Vec3 | undefined;
-    /** Current `rotation` prop value (Euler degrees). */
-    getRotation(): Vec3 | undefined;
-    /** Current `scale` prop value. */
-    getScale(): number | Vec3 | undefined;
-    /** Polygons currently being rendered (post-autoCenter). */
-    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;
-    /**
-     * Snapshot the current `rotation` prop as the new "baked rotation" and
-     * trigger an atlas re-rasterization with the directional light
-     * inverse-rotated into the mesh's local frame.
-     *
-     * Call this after a rotate-mode drag ends (i.e. on pointer release) —
-     * **not** on every pointermove during the drag. The visual wrapper already
-     * follows the live `rotation` prop smoothly; the atlas only needs to
-     * update once per committed rotation so it doesn't re-bake every frame.
-     *
-     * Math rationale: baked atlas tiles encode `baseColor × Lambert(worldNormal,
-     * worldLight)`. When the mesh wrapper rotates via CSS the world-space normal
-     * changes but the baked color does not, causing stale shading. Calling
-     * `rebakeAtlas()` inverse-rotates the world light into the mesh-local frame
-     * before re-running the atlas baker, so `dot(localNormal, localLight) ===
-     * dot(worldNormal, worldLight)` and the shading is correct again.
-     *
-     * In dynamic (`textureLighting="dynamic"`) mode this call is a no-op for
-     * shading purposes (dynamic mode re-evaluates per frame), but it is still
-     * safe to call.
-     */
-    rebakeAtlas(): void;
-    /** Resolves when this mesh's current texture generation has usable backgrounds. */
-    whenTexturesReady(): Promise<void>;
-    /**
-     * Mutate a single polygon in place and re-render the mesh. `target` is
-     * either a polygon reference (as returned by `getPolygons()`) or its index.
-     * `partial` fields are merged onto the polygon via `Object.assign`. Skips
-     * the merge pass — cheaper than a full prop change for targeted edits like
-     * color picker updates from an inspector UI. Silently no-ops when `target`
-     * is not found or the index is out of range.
-     */
-    updatePolygon(target: Polygon | number, partial: Partial<Polygon>): void;
-}
-/**
- * Pointer event payload delivered to <PolyMesh> handlers. Mirrors r3f's
- * shape, minus raycaster-specific fields. See module docstring for the
- * intentional divergences.
- */
-interface PolyPointerEvent<E extends Event = PointerEvent> {
-    /** The mesh originally under the pointer (deepest hit). */
-    object: PolyMeshHandle;
-    /** The mesh whose handler is being invoked. Equal to `object` until
-     *  ancestor bubbling is added (out of scope for v1). */
-    eventObject: PolyMeshHandle;
-    /** All meshes stacked under the pointer this moment, front-to-back.
-     *  Computed via `document.elementsFromPoint` then filtered to
-     *  registered `.polycss-mesh` ancestors. */
-    intersections: Array<{
-        object: PolyMeshHandle;
-    }>;
-    /** Pointer position in normalized device coords [-1, 1] relative to
-     *  the camera viewport. (0,0) = viewport center. Falls back to (0,0)
-     *  when the mesh is rendered outside a `<PolyCamera>`. */
-    pointer: {
-        x: number;
-        y: number;
-    };
-    /** Pixel distance from the most recent `pointerdown` to this event.
-     *  0 on pointerdown itself. Use to discriminate click-vs-drag. */
-    delta: number;
-    /** The underlying DOM event. */
-    nativeEvent: E;
-    /** Stops native bubbling. (Equivalent to `nativeEvent.stopPropagation()`
-     *  today; reserved for future r3f-style bubbling above the wrapper.) */
-    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>`. Names mirror
- * r3f exactly. Provide any handler to opt the mesh into receiving events;
- * absent handlers add zero overhead.
- */
-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>;
-}
-/** Walk up from `el` looking for the nearest registered mesh wrapper. */
-declare function findPolyMeshHandle(el: Element | null): PolyMeshHandle | null;
-/** Test whether `(clientX, clientY)` falls inside any polygon leaf
- *  child of `meshEl`'s post-3D bounding rect. Skips zero-area rects
- *  (happy-dom and pre-layout SSR return those). */
-declare function pointInMeshElement(meshEl: HTMLElement, clientX: number, clientY: number): boolean;
-/** Walk every registered `.polycss-mesh` in the document and return
- *  the first whose polygon bounding-rects contain `(clientX, clientY)`.
- *  An optional `filter` skips matched mesh elements (e.g. gizmos). */
-declare function findMeshUnderPoint(clientX: number, clientY: number, filter?: (meshEl: HTMLElement) => boolean): PolyMeshHandle | null;
-
-interface PolyMeshProps extends TransformProps, InteractionProps {
-    /** Stable identifier — exposed on the mesh handle and reflected as
-     *  `data-poly-mesh-id` on the wrapper div. Use for selection lookups. */
-    id?: string;
-    /** URL to .obj / .glb / .gltf. Mutually exclusive with `polygons`. */
-    src?: string;
-    /**
-     * Companion `.mtl` URL for OBJ models. When set, materials defined in
-     * the mtl (Kd colors, map_Kd textures) are applied to the loaded mesh.
-     * Ignored for GLB/GLTF (they carry materials inline).
-     */
-    mtl?: string;
-    /** Pre-parsed polygons. Mutually exclusive with `src`. */
-    polygons?: Polygon[];
-    /** Optional `parseResult.voxelSource` companion for `.vox` meshes. When
-     *  set alongside `polygons`, the direct voxel renderer fast path activates
-     *  — emitting one `<b>` per visible voxel quad inside `.polycss-voxel-face`
-     *  wrappers (matches vanilla's `scene.add(parseResult)` behaviour).
-     *  Callers fetching via core's `loadMesh()` pass `parseResult.voxelSource`
-     *  here so the fast path engages; callers fetching via PolyMesh's `src`
-     *  prop get the same data wired through `useMesh` automatically. */
-    voxelSource?: _layoutit_polycss_core.ParseResult["voxelSource"];
-    /** Translate so mesh's bbox center is at local origin before applying `position`. */
-    autoCenter?: boolean;
-    /** Textured polygon lighting mode. Defaults to "baked". */
-    textureLighting?: PolyTextureLightingMode;
-    /** Atlas bitmap budget and CSS sprite size. `"auto"` (default) uses a
-     *  device-appropriate memory budget (~4 MB mobile / ~16 MB desktop) and
-     *  desktop/mobile sprite sizing. Numeric values 0.1..1 force an explicit
-     *  raster scale and the 64px sprite. */
-    textureQuality?: TextureQuality;
-    /** Atlas leaf CSS primitive sizing. Defaults to scene context, then canonical. */
-    textureLeafSizing?: PolyTextureLeafSizing;
-    /** Default image filtering for atlas and direct image texture leaves. */
-    textureImageRendering?: PolyTextureImageRendering;
-    /** Default texture backend request. Defaults to scene context, then "auto". */
-    textureBackend?: PolyTextureBackend;
-    /** Default texture projection request. Defaults to scene context, then "affine". */
-    textureProjection?: PolyTextureProjection;
-    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
-    seamBleed?: PolySeamBleed;
-    /**
-     * Hold the whole previous frame (geometry + texture) until the next atlas is
-     * decoded, then swap atomically — so a geometry edit never shows geometry
-     * before its texture. Best when edits arrive as discrete commits (no
-     * continuous drag). Defaults to false (bitmap streams in over live geometry).
-     */
-    atomicAtlas?: boolean;
-    /** Fires when the displayed atlas frame swaps to a ready one (atomic mode). */
-    onFrameReady?: () => void;
-    /** Per-polygon override render, or static children mounted inside the mesh wrapper. */
-    children?: ((polygon: Polygon, index: number) => ReactNode) | ReactNode;
-    /** Loading slot — rendered while `src` is being fetched/parsed. */
-    fallback?: ReactNode;
-    /** Error slot — rendered if parse fails. Receives the Error. */
-    errorFallback?: (error: Error) => ReactNode;
-    /** Parser options forwarded to parseObj/parseGltf. */
-    parseOptions?: UseMeshOptions;
-    /** Mesh optimization intent. Defaults to "lossy"; set "lossless" to keep
-     *  authored surface fidelity. Top-level prop wins over `parseOptions.meshResolution`
-     *  when both are present. */
-    meshResolution?: MeshResolution;
-    /**
-     * 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 of this mesh, matching Three.js's
-     * `mesh.receiveShadow` semantics. Disables the ground-shadow fallback
-     * for caster meshes — receivers handle shadow display. Defaults to `false`.
-     */
-    receiveShadow?: boolean;
-    /**
-     * Apply mesh optimization (coplanar merge + interior cull) before
-     * rendering. Defaults to `true` — matches vanilla `scene.add`'s default.
-     * Set `false` for helper meshes (axes, light markers) whose geometry
-     * shouldn't be merged, or when the imperative `updatePolygon` API needs
-     * polygon refs to survive across updates.
-     */
-    merge?: boolean;
-    className?: string;
-    style?: CSSProperties;
-}
-declare const PolyMesh: React$1.ForwardRefExoticComponent<PolyMeshProps & React$1.RefAttributes<PolyMeshHandle>>;
-
 interface PolyIframeProps {
     /** Iframe URL — forwarded to the underlying <iframe>'s `src` attribute. */
     src: string;
@@ -851,7 +550,7 @@ interface PolySelectProps {
     onChange?: (meshes: PolyMeshHandle[]) => void;
     /** Fires when a click lands inside the Select wrapper but resolves to
      *  no mesh ancestor (i.e. the background). Receives the click event. */
-    onPointerMissed?: (event: MouseEvent$1<HTMLDivElement>) => void;
+    onPointerMissed?: (event: MouseEvent<HTMLDivElement>) => void;
     /** When true (default), clicking the background clears selection. */
     clearOnMiss?: boolean;
     children?: ReactNode;
@@ -1047,4 +746,4 @@ interface UsePolyAnimationResult {
 }
 declare function usePolyAnimation(clips: PolyAnimationClip[] | undefined, controller: ParseAnimationController | undefined, root?: RefObject<PolyAnimationTarget | null> | PolyAnimationTarget | null): UsePolyAnimationResult;
 
-export { type DOMPassthroughProps, type InteractionProps, Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, type PolyBoxProps, PolyOrthographicCamera as PolyCamera, PolyCameraContext, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, type PolyCameraSnapshotStats, PolyCone, type PolyConeProps, type PolyControlsAnimateOptions, type PolyControlsCamera, PolyCylinder, type PolyCylinderProps, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, PolyDodecahedron, type PolyDodecahedronProps, type PolyEventHandler, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, type PolyFirstPersonControlsProps, PolyGround, type PolyGroundProps, PolyIcosahedron, type PolyIcosahedronProps, PolyIframe, type PolyIframeProps, type PolyLeafInfo, PolyMapControls, type PolyControlsCamera as PolyMapControlsCamera, type PolyMapControlsProps, PolyMesh, type PolyMeshHandle, type PolyMeshProps, type PolyMouseEvent, PolyOctahedron, type PolyOctahedronProps, PolyOrbitControls, type PolyControlsCamera as PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, PolyPlane, type PolyPlaneProps, type PolyPointerEvent, type PolyProps, type PolyRenderLeafStrategy, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, type PolyRingProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, type PolySnapshotRenderStats, PolySphere, type PolySphereProps, PolyTetrahedron, type PolyTetrahedronProps, type PolyTextureReadiness, type PolyTextureRenderStats, PolyTorus, type PolyTorusProps, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type PolyWheelEvent, type SharedControlsProps, type TransformProps, type UseCameraOptions, type UseCameraResult, type UseMeshOptions, type UseMeshResult, type UsePolyAnimationResult, type UseSceneContextOptions, type UseSceneContextResult, collectPolyRenderStats, collectPolyTextureReadiness, findMeshUnderPoint, findPolyMeshHandle, injectPolyBaseStyles, pointInMeshElement, queryPolyLeaves, useCameraContext, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolyMesh, usePolySceneContext, usePolySelect, usePolySelectionApi };
+export { Poly, PolyAxesHelper, type PolyAxesHelperProps, PolyBox, type PolyBoxProps, PolyOrthographicCamera as PolyCamera, PolyCameraContext, type PolyCameraContextValue, type PolyOrthographicCameraProps as PolyCameraProps, type PolyCameraSnapshotStats, PolyCone, type PolyConeProps, type PolyControlsAnimateOptions, type PolyControlsCamera, PolyCylinder, type PolyCylinderProps, PolyDirectionalLightHelper, type PolyDirectionalLightHelperProps, PolyDodecahedron, type PolyDodecahedronProps, PolyFirstPersonControls, type PolyFirstPersonControlsHandle, type PolyFirstPersonControlsOptions, type PolyFirstPersonControlsProps, PolyGround, type PolyGroundProps, PolyIcosahedron, type PolyIcosahedronProps, PolyIframe, type PolyIframeProps, type PolyLeafInfo, PolyMapControls, type PolyControlsCamera as PolyMapControlsCamera, type PolyMapControlsProps, PolyMeshHandle, PolyMeshProps, PolyOctahedron, type PolyOctahedronProps, PolyOrbitControls, type PolyControlsCamera as PolyOrbitControlsCamera, type PolyOrbitControlsProps, PolyOrthographicCamera, type PolyOrthographicCameraProps, PolyPerspectiveCamera, type PolyPerspectiveCameraProps, PolyPlane, type PolyPlaneProps, PolyProps, type PolyRenderLeafStrategy, type PolyRenderStats, type PolyRenderStatsOptions, type PolyRenderSurfaceLeafCounts, PolyRing, type PolyRingProps, PolyScene, type PolySceneProps, PolySelect, type PolySelectProps, type PolySelectionApi, type PolySnapshotRenderStats, PolySphere, type PolySphereProps, PolyTetrahedron, type PolyTetrahedronProps, type PolyTextureReadiness, type PolyTextureRenderStats, PolyTorus, type PolyTorusProps, PolyTransformControls, type PolyTransformControlsObject, type PolyTransformControlsObjectChangeEvent, type PolyTransformControlsProps, type SharedControlsProps, TransformProps, type UseCameraOptions, type UseCameraResult, type UsePolyAnimationResult, type UseSceneContextOptions, type UseSceneContextResult, collectPolyRenderStats, collectPolyTextureReadiness, injectPolyBaseStyles, queryPolyLeaves, useCameraContext, usePolyAnimation, usePolyCamera, usePolyMaterial, usePolySceneContext, usePolySelect, usePolySelectionApi };