@layoutit/polycss 0.2.0 → 0.2.2

package/dist/PolyShapeElements-BNHvErQF.d.ts

@@ -0,0 +1,654 @@
+import { CameraHandle, Vec3, Polygon, MeshResolution, ParseResult, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, TextureQuality, PolySeamBleed, PolyRenderStrategiesOption } from '@layoutit/polycss-core';
+
+interface PolyCameraOptions {
+    zoom?: number;
+    target?: Vec3;
+    rotX?: number;
+    rotY?: number;
+    /** Camera pull-back in CSS pixels (dolly). Default 0. */
+    distance?: number;
+}
+interface PolyPerspectiveCameraOptions extends PolyCameraOptions {
+    /** CSS perspective distance in pixels. Default 32000. */
+    perspective?: number;
+}
+interface PolyOrthographicCameraOptions extends PolyCameraOptions {
+}
+/** Extends CameraHandle with projection info for the container element. */
+interface PolyPerspectiveCameraHandle extends CameraHandle {
+    readonly type: "perspective";
+    /** CSS `perspective` value to set on the camera container element. */
+    readonly perspectiveStyle: string;
+}
+interface PolyOrthographicCameraHandle extends CameraHandle {
+    readonly type: "orthographic";
+    /** CSS `perspective` value to set on the camera container element ("none"). */
+    readonly perspectiveStyle: "none";
+}
+/**
+ * Creates a perspective camera handle. The `perspectiveStyle` property
+ * returns the CSS value to apply to the camera container's `perspective`
+ * property (default `"32000px"`).
+ */
+declare function createPolyPerspectiveCamera(options?: PolyPerspectiveCameraOptions): PolyPerspectiveCameraHandle;
+/**
+ * Creates an orthographic camera handle. The `perspectiveStyle` property
+ * returns `"none"` — pass it to the container element's CSS `perspective`
+ * to disable perspective projection.
+ */
+declare function createPolyOrthographicCamera(options?: PolyOrthographicCameraOptions): PolyOrthographicCameraHandle;
+/**
+ * Ergonomic alias for `createPolyOrthographicCamera`. The default camera in
+ * PolyCSS is orthographic because the engine's structural advantages
+ * (integer-pixel atlas slicing, DOM-as-render-tree) are most visible in
+ * iso/voxel/diagrammatic scenes. Use `createPolyPerspectiveCamera` explicitly
+ * when depth foreshortening is needed.
+ */
+declare const createPolyCamera: typeof createPolyOrthographicCamera;
+
+/**
+ * Public + internal types for the scene module, extracted from
+ * createPolyScene.ts so other scene/* helpers can import them without
+ * pulling in the whole factory body. createPolyScene.ts re-exports the
+ * public ones so the polycss package public surface is unchanged.
+ */
+
+interface PolySceneOptions {
+    /**
+     * Camera handle created by `createPolyCamera`, `createPolyOrthographicCamera`,
+     * or `createPolyPerspectiveCamera`. Required — `createPolyScene` will throw if
+     * this field is missing.
+     */
+    camera: PolyPerspectiveCameraHandle | PolyOrthographicCameraHandle;
+    directionalLight?: PolyDirectionalLight;
+    ambientLight?: PolyAmbientLight;
+    /** Textured polygon lighting mode. Defaults to "baked". */
+    textureLighting?: PolyTextureLightingMode;
+    /** Atlas bitmap budget and CSS sprite size. `"auto"` 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;
+    /** Solid seam overscan. `"auto"` computes a fitted per-edge amount from the polygon plan. */
+    seamBleed?: PolySeamBleed;
+    /**
+     * Skip specific render-strategy tags. Polygons that would normally use a
+     * disabled tag fall through the chain (b → i → s, u → i → s, i → s).
+     * `<s>` is the universal fallback and cannot be disabled.
+     */
+    strategies?: PolyRenderStrategiesOption;
+    /**
+     * When `true`, rotation pivots around the union bbox of all added meshes
+     * instead of world (0,0,0). The scene wraps polygons in an inner div
+     * translated by `-bboxCenter`. Updates whenever a mesh is added/removed
+     * or `setOptions` is called. Mirrors React's `<PolyScene autoCenter>`.
+     */
+    autoCenter?: boolean;
+    /**
+     * Shadow appearance for meshes with `castShadow: true`. Works in both
+     * lighting modes — dynamic mode projects via CSS vars so shadows
+     * follow a moving light, baked mode CPU-bakes the projection into
+     * each leaf's inline `matrix3d` and drops back-facing polys from the
+     * DOM entirely. Defaults: `{ color: "#000000", opacity: 0.25, lift: 0.05, maxExtend: 2000 }`.
+     */
+    shadow?: {
+        /** Shadow color as a CSS hex string. Default: `"#000000"`. */
+        color?: string;
+        /** Shadow opacity 0..1. Default: `0.25`. */
+        opacity?: number;
+        /**
+         * Raises the shadow plane slightly above the model bbox floor along
+         * +Z (Z up) so it sits on top of a receiver mesh placed at the bbox
+         * bottom, rather than below it where the receiver would occlude the
+         * shadow. In world units. Default: `0.05`.
+         */
+        lift?: number;
+        /**
+         * Maximum CSS pixels the shadow may extend beyond the mesh's
+         * footprint (the no-shear silhouette directly under the mesh). The
+         * footprint area is always preserved; only the sheared tail at low
+         * light elevations is truncated. Default: `2000`.
+         *
+         * **Trade-off:** larger values give longer shadows but the SVG
+         * backing store grows quadratically with this value, which can
+         * cause repaint flicker at extreme low-elevation angles. Pass a
+         * very large number (e.g. `Infinity`) to disable the cap entirely.
+         */
+        maxExtend?: number;
+    };
+    /**
+     * When `true`, emit `data-poly-shadow-*` attribution attributes on every
+     * shadow SVG and path (type, receiver mesh id, receiver face index,
+     * member poly indices, caster ids, caster poly indices). Useful for
+     * DevTools inspection and per-poly attribution in debug benches. When
+     * `false` (default), these attributes are suppressed entirely — production
+     * scenes ship a cleaner DOM and avoid serializing per-frame JSON.
+     */
+    debugShadowAttrs?: boolean;
+}
+interface PolyMeshTransform {
+    /** Stable identifier — exposed on the handle and reflected on the
+     *  wrapper as `data-poly-mesh-id`. Used by selection helpers to
+     *  resolve clicks back to the mesh and to dedupe selection state. */
+    id?: string;
+    position?: Vec3;
+    scale?: number | Vec3;
+    rotation?: Vec3;
+    /**
+     * Whether `scene.add()` should merge coplanar polygons before rendering.
+     * Defaults to `true`. Set `false` for animated/deforming meshes whose
+     * triangle topology must remain stable from frame to frame.
+     */
+    merge?: boolean;
+    /**
+     * Mesh optimization intent. Defaults to `"lossy"` (bounded geometric
+     * approximation when it reduces polygon count). Set `"lossless"` to preserve
+     * the authored surface — only exact coplanar merges are applied.
+     */
+    meshResolution?: MeshResolution;
+    /**
+     * Keep polygon leaf DOM nodes stable across setPolygons() calls when the
+     * mesh topology is unchanged. Intended for animated/deforming meshes.
+     */
+    stableDom?: boolean;
+    /**
+     * When `true`, this mesh's polygons are NOT included in the scene's
+     * auto-center bbox. Use for debug overlays / helpers that shouldn't
+     * shift the camera target when toggled. Defaults to `false`.
+     */
+    excludeFromAutoCenter?: boolean;
+    /**
+     * When `true`, this mesh casts a shadow onto the scene's shadow ground
+     * plane (and onto any meshes marked `receiveShadow: true`). The shadow
+     * emits as one per-mesh `<svg>` whose path is the union of every
+     * casting polygon's projection. Works in both lighting modes.
+     * Defaults to `false`.
+     */
+    castShadow?: boolean;
+    /**
+     * **(experimental)** When `true`, this mesh acts as a shadow receiver:
+     * each of its polygon faces becomes a target plane that casting meshes'
+     * shadows project onto and get clipped to. Useful for "shadow on table"
+     * scenarios. Currently only convex face outlines clip cleanly. When no
+     * receivers are present the global ground plane is used as today.
+     * Defaults to `false`.
+     */
+    receiveShadow?: boolean;
+}
+interface PolyMeshHandle {
+    /** The polygons that were loaded after normalization and automatic merge. */
+    polygons: Polygon[];
+    /** The `.polycss-mesh` wrapper div for this mesh. Exposed so layered
+     *  helpers (selection, transform controls) can resolve a click target
+     *  back to its owning mesh, attach event listeners, or measure the
+     *  mesh's screen position via `getBoundingClientRect`. */
+    readonly element: HTMLElement;
+    /** Identifier passed via `PolyMeshTransform.id` (if any). Reflected on
+     *  the wrapper as `data-poly-mesh-id`. */
+    readonly id?: string;
+    /** Current transform snapshot (position / rotation / scale). Returned
+     *  by reference — treat as read-only and use `setTransform` to mutate. */
+    readonly transform: PolyMeshTransform;
+    /** Remove the mesh from the scene. */
+    remove(): void;
+    /** Replace polygon geometry without tearing down the scene or controls. */
+    setPolygons(polygons: Polygon[], options?: {
+        merge?: boolean;
+        stableDom?: boolean;
+        recomputeAutoCenter?: boolean;
+    }): void;
+    /**
+     * Update a single polygon in place. `target` is either a polygon
+     * reference (as returned by `getPolygons()`) or its index. `partial`
+     * fields are merged onto the polygon; the mesh is then re-rendered.
+     * Skips the merge pass, so this is cheaper than `setPolygons` for
+     * targeted edits like color picker updates from an inspector UI.
+     * Silently no-ops if `target` isn't found.
+     */
+    updatePolygon(target: Polygon | number, partial: Partial<Polygon>): void;
+    /** Update transform without re-parsing. */
+    setTransform(t: Partial<PolyMeshTransform>): void;
+    /** Revoke any blob URLs the parse created. Idempotent. */
+    dispose(): void;
+    /**
+     * Re-rasterize the atlas using the directional light inverse-rotated into
+     * the mesh's local frame. Call this after a mesh rotation has been
+     * committed (e.g., on pointer release in rotate-mode transform controls) to
+     * correct stale baked shading.
+     *
+     * **Background:** Baked atlas tiles encode `baseColor × Lambert(worldNormal,
+     * worldLight)`. When the mesh wrapper rotates via CSS, the polygon's normal
+     * in world space changes but the baked color doesn't — faces stay lit/unlit
+     * incorrectly. `rebakeAtlas()` inverse-rotates the world light into the
+     * mesh's local frame and re-runs the rasterizer; because
+     * `dot(localNormal, localLight) === dot(worldNormal, worldLight)` the
+     * output is correct for any rotation.
+     *
+     * **Performance note:** This does NOT run on every `setTransform` call —
+     * only when explicitly invoked, so dragging remains smooth. Call it on
+     * pointer release (or any point where you want to commit the new shading).
+     */
+    rebakeAtlas(): void;
+    /** Current `position` from the transform (matches framework API). */
+    getPosition(): Vec3 | undefined;
+    /** Current `rotation` from the transform (matches framework API). */
+    getRotation(): Vec3 | undefined;
+    /** Current `scale` from the transform (matches framework API). */
+    getScale(): number | Vec3 | undefined;
+    /** Polygons currently being rendered (matches framework API). */
+    getPolygons(): Polygon[];
+}
+interface PolySceneHandle {
+    /** Add a mesh to the scene. Returns a handle for later removal. */
+    add(mesh: ParseResult, opts?: PolyMeshTransform): PolyMeshHandle;
+    /** Update scene-level config (lighting, autoCenter, strategies, etc.). Camera state is on `scene.camera`. */
+    setOptions(partial: Partial<Omit<PolySceneOptions, "camera">>): void;
+    /** Tear down the scene; revokes all blob URLs of registered meshes. */
+    destroy(): void;
+    /**
+     * The host element passed to `createPolyScene`. Exposed for layered
+     * helpers like `createPolyOrbitControls` that need to attach event listeners
+     * without tracking the host separately.
+     */
+    readonly host: HTMLElement;
+    /**
+     * The `.polycss-camera` wrapper element created by `createPolyScene` between
+     * the host and the `.polycss-scene` element. Carries the CSS `perspective`
+     * that matches React/Vue's `<div class="polycss-camera">` wrapper shape.
+     * FPV controls toggle `.polycss-fpv-host` on this element.
+     */
+    readonly cameraEl: HTMLElement;
+    /**
+     * The camera handle this scene is bound to. Controls update camera state
+     * via `scene.camera.update({...})` then call `scene.applyCamera()` to
+     * re-apply the transform.
+     */
+    readonly camera: PolyPerspectiveCameraHandle | PolyOrthographicCameraHandle;
+    /**
+     * Re-applies the scene transform from the current camera state. Call this
+     * after mutating `scene.camera.update({...})` to make the change visible.
+     * Controls call this once per interaction event after updating camera state.
+     */
+    applyCamera(): void;
+    /**
+     * Snapshot of the current non-camera scene options (lighting, autoCenter,
+     * textureQuality, strategies, shadow). Returned by reference — treat as
+     * read-only; use `setOptions` to update.
+     */
+    getOptions(): Readonly<Omit<PolySceneOptions, "camera">>;
+    /** Snapshot of mesh handles currently in the scene (insertion order).
+     *  Used by selection helpers to enumerate hit-test candidates. */
+    meshes(): readonly PolyMeshHandle[];
+    /** Resolve a `.polycss-mesh` element back to its handle, or `null` if
+     *  the element doesn't belong to this scene. */
+    findMeshByElement(element: Element | null): PolyMeshHandle | null;
+}
+
+/**
+ * Shared types, constants, and utilities for orbit/map controls factories.
+ * Not part of the public API surface — use createPolyOrbitControls or
+ * createPolyMapControls.
+ */
+
+interface PolyControlsAnimateOptions {
+    /**
+     * Rotation rate in degrees per 60 Hz-equivalent frame. The tick is
+     * dt-clamped so 0.3 deg/frame ≈ 18 deg/sec on every refresh rate.
+     * Default: 0.3.
+     */
+    speed?: number;
+    /** Rotation axis. Default: "y" (yaw, rotates around vertical world Z). */
+    axis?: "x" | "y";
+    /** Halt the loop while a pointer drag is in progress. Default: true. */
+    pauseOnInteraction?: boolean;
+}
+interface PolyControlsBaseOptions {
+    /** Pointer-drag. Default: true. */
+    drag?: boolean;
+    /** Wheel / pinch zoom. Default: true. */
+    wheel?: boolean;
+    /**
+     * When `true`, wheel events change `distance` (camera pull-back in CSS px)
+     * instead of `zoom`. Mirrors Three.js OrbitControls dolly behaviour.
+     * Default: false (zoom mode).
+     */
+    dolly?: boolean;
+    /**
+     * Drag-direction inversion. `false` = natural, `true` = invert (×-1),
+     * a number multiplies sensitivity (negative inverts). Default: false.
+     */
+    invert?: boolean | number;
+    /** Minimum CSS zoom. Default: 0.1. */
+    minZoom?: number;
+    /** Maximum CSS zoom. Default: 10. */
+    maxZoom?: number;
+    /** Minimum dolly distance in CSS pixels. Default: 0. Only used when `dolly: true`. */
+    minDistance?: number;
+    /** Maximum dolly distance in CSS pixels. Default: Infinity. Only used when `dolly: true`. */
+    maxDistance?: number;
+    /** Auto-rotate. Pass false (or omit) to disable. */
+    animate?: false | PolyControlsAnimateOptions;
+}
+interface PolyControlsCamera {
+    rotX: number;
+    rotY: number;
+    zoom: number;
+    target: Vec3;
+    distance: number;
+}
+interface PolyControlsChangeEvent {
+    type: "change";
+    camera: PolyControlsCamera;
+}
+interface PolyControlsInteractionEvent {
+    type: "start" | "end";
+    camera: PolyControlsCamera;
+}
+type PolyControlsEvent = PolyControlsChangeEvent | PolyControlsInteractionEvent;
+type PolyControlsListener<E extends PolyControlsEvent = PolyControlsEvent> = (event: E) => void;
+interface PolyControlsHandle {
+    update(partial: PolyControlsBaseOptions): void;
+    resume(): void;
+    pause(): void;
+    destroy(): void;
+    addEventListener<T extends PolyControlsEvent["type"]>(type: T, listener: PolyControlsListener<Extract<PolyControlsEvent, {
+        type: T;
+    }>>): void;
+    removeEventListener<T extends PolyControlsEvent["type"]>(type: T, listener: PolyControlsListener<Extract<PolyControlsEvent, {
+        type: T;
+    }>>): void;
+    hasEventListener<T extends PolyControlsEvent["type"]>(type: T, listener: PolyControlsListener<Extract<PolyControlsEvent, {
+        type: T;
+    }>>): boolean;
+}
+
+/**
+ * createPolyOrbitControls — orbit-mode camera input for a PolyScene.
+ *
+ * Left-drag rotates rotX / rotY around the target (orbit). Wheel zooms or
+ * dollies. Mirrors Three.js OrbitControls semantics.
+ *
+ * For map/pan semantics (left-drag pans, right-drag orbits) use
+ * `createPolyMapControls` instead.
+ */
+
+type PolyOrbitControlsOptions = PolyControlsBaseOptions;
+type PolyOrbitControlsHandle = PolyControlsHandle;
+declare function createPolyOrbitControls(scene: PolySceneHandle, options?: PolyOrbitControlsOptions): PolyOrbitControlsHandle;
+
+declare const ELEMENT_BASE$b: typeof HTMLElement;
+declare class PolySceneElement extends ELEMENT_BASE$b {
+    static get observedAttributes(): string[];
+    private _scene;
+    private _implicitCamera;
+    /**
+     * Returns the underlying PolySceneHandle. Children call this during their own
+     * connectedCallback to register meshes.
+     */
+    getScene(): PolySceneHandle | null;
+    private _findAncestorCamera;
+    private _buildImplicitCamera;
+    private _readNonCameraOptions;
+    private _readDirectionalLight;
+    private _readAmbientLight;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$a: typeof HTMLElement;
+declare class PolyMeshElement extends ELEMENT_BASE$a {
+    static get observedAttributes(): string[];
+    private _handle;
+    private _parseResult;
+    private _loadToken;
+    /** Returns the current mesh handle, or null if not yet loaded. */
+    getMeshHandle(): PolyMeshHandle | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private _tearDown;
+    private _maybeLoad;
+}
+
+declare const ELEMENT_BASE$9: typeof HTMLElement;
+declare class PolyIframeElement extends ELEMENT_BASE$9 {
+    static get observedAttributes(): string[];
+    private _wrapper;
+    private _iframe;
+    /** The iframe element this <poly-iframe> mounted, or null when detached. */
+    getIframeElement(): HTMLIFrameElement | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private _mount;
+    private _applyGeometry;
+    private _teardown;
+}
+
+declare const ELEMENT_BASE$8: typeof HTMLElement;
+declare class PolyPolygonElement extends ELEMENT_BASE$8 {
+    static get observedAttributes(): string[];
+    private _handle;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+    private _tearDown;
+    private _mount;
+}
+
+declare const ELEMENT_BASE$7: typeof HTMLElement;
+declare class PolyOrbitControlsElement extends ELEMENT_BASE$7 {
+    static get observedAttributes(): string[];
+    private _controls;
+    /** Returns the wrapped PolyOrbitControlsHandle once the element has
+     *  connected to its `<poly-scene>` ancestor. Lets external callers attach
+     *  `change` listeners (or call `update()` / `pause()`) the same way they
+     *  would on a vanilla `createPolyOrbitControls(scene, ...)` handle. */
+    getControls(): PolyOrbitControlsHandle | null;
+    private _readAnimate;
+    private _readOptions;
+    private _findScene;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$6: typeof HTMLElement;
+declare class PolyMapControlsElement extends ELEMENT_BASE$6 {
+    static get observedAttributes(): string[];
+    private _controls;
+    private _readAnimate;
+    private _readOptions;
+    private _findScene;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$5: typeof HTMLElement;
+declare class PolyFirstPersonControlsElement extends ELEMENT_BASE$5 {
+    static get observedAttributes(): string[];
+    private _controls;
+    private _readOptions;
+    private _findScene;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+/**
+ * <poly-perspective-camera> — standalone perspective camera element.
+ *
+ * Wraps `createPolyPerspectiveCamera`. Unlike <poly-scene> which owns the
+ * scene DOM, this element provides a camera context that child controls can
+ * read. It creates a `<div class="polycss-camera">` wrapper with the
+ * CSS `perspective` property set.
+ *
+ * Attributes (all optional):
+ *   perspective   — number, CSS perspective in pixels (default 32000)
+ *   zoom          — number
+ *   rot-x         — number, degrees (default 65)
+ *   rot-y         — number, degrees (default 45)
+ *   target        — "x,y,z" comma-separated world coordinates
+ *   distance      — number, camera pull-back in CSS pixels
+ */
+
+declare const ELEMENT_BASE$4: typeof HTMLElement;
+declare class PolyPerspectiveCameraElement extends ELEMENT_BASE$4 {
+    static get observedAttributes(): string[];
+    private _camera;
+    private _wrapper;
+    /** Returns the camera handle, or null if not yet connected. */
+    getCamera(): PolyPerspectiveCameraHandle | null;
+    private _readOptions;
+    private _mount;
+    private _teardown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+/**
+ * <poly-orthographic-camera> — standalone orthographic camera element.
+ *
+ * Wraps `createPolyOrthographicCamera`. Sets CSS `perspective: none` on the
+ * camera wrapper, disabling perspective projection.
+ *
+ * Attributes (all optional):
+ *   zoom          — number
+ *   rot-x         — number, degrees (default 65)
+ *   rot-y         — number, degrees (default 45)
+ *   target        — "x,y,z" comma-separated world coordinates
+ *   distance      — number, camera pull-back in CSS pixels
+ */
+
+declare const ELEMENT_BASE$3: typeof HTMLElement;
+declare class PolyOrthographicCameraElement extends ELEMENT_BASE$3 {
+    static get observedAttributes(): string[];
+    private _camera;
+    private _wrapper;
+    /** Returns the camera handle, or null if not yet connected. */
+    getCamera(): PolyOrthographicCameraHandle | null;
+    private _readOptions;
+    private _mount;
+    private _teardown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+/**
+ * <poly-camera> — ergonomic alias for <poly-orthographic-camera>.
+ *
+ * The default camera in PolyCSS is orthographic. `<poly-camera>` maps to
+ * `PolyOrthographicCameraElement` so the canonical tree shape works without
+ * spelling out "orthographic" when it isn't relevant to the scene being built.
+ *
+ * Use <poly-perspective-camera> when depth foreshortening is needed.
+ */
+
+declare class PolyCameraElement extends PolyOrthographicCameraElement {
+}
+
+declare const ELEMENT_BASE$2: typeof HTMLElement;
+declare class PolyTransformControlsElement extends ELEMENT_BASE$2 {
+    static get observedAttributes(): string[];
+    private _tc;
+    private _findScene;
+    private _findTargetMesh;
+    private _readOptions;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$1: typeof HTMLElement;
+declare class PolySelectElement extends ELEMENT_BASE$1 {
+    static get observedAttributes(): string[];
+    private _selection;
+    private _findScene;
+    private _readOptions;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+/**
+ * Primitive shape custom elements — <poly-box>, <poly-plane>, <poly-ring>,
+ * <poly-octahedron>, <poly-tetrahedron>, <poly-icosahedron>, <poly-dodecahedron>,
+ * <poly-cylinder>, <poly-cone>, <poly-torus>.
+ *
+ * Each element reads shape-specific attributes, calls the matching polygon
+ * generator from @layoutit/polycss-core, then registers the result with the
+ * nearest <poly-scene> ancestor using the same mechanism as <poly-mesh>.
+ *
+ * Attribute naming follows kebab-case conventions: `radial-segments`,
+ * `tubular-segments`, `radius-top`, `half-thickness`, etc.
+ */
+
+declare const ELEMENT_BASE: typeof HTMLElement;
+/**
+ * Base class for all primitive shape elements. Subclasses implement
+ * `buildPolygons()` which returns a Polygon[] from this element's attributes.
+ */
+declare abstract class PolyShapeElement extends ELEMENT_BASE {
+    private _handle;
+    abstract buildPolygons(): Polygon[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private _tearDown;
+    private _mount;
+}
+declare class PolyBoxElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyPlaneElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyRingElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyOctahedronElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyTetrahedronElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyIcosahedronElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyDodecahedronElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolySphereElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyCylinderElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyConeElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+declare class PolyTorusElement extends PolyShapeElement {
+    static get observedAttributes(): string[];
+    buildPolygons(): Polygon[];
+}
+
+export { PolyOrthographicCameraElement as A, type PolyOrthographicCameraHandle as B, type PolyOrthographicCameraOptions as C, PolyPerspectiveCameraElement as D, type PolyPerspectiveCameraHandle as E, type PolyPerspectiveCameraOptions as F, PolyPlaneElement as G, PolyPolygonElement as H, PolyRingElement as I, PolySceneElement as J, PolySelectElement as K, PolySphereElement as L, PolyTetrahedronElement as M, PolyTorusElement as N, PolyTransformControlsElement as O, type PolySceneOptions as P, createPolyCamera as Q, createPolyOrbitControls as R, createPolyOrthographicCamera as S, createPolyPerspectiveCamera as T, type PolySceneHandle as a, type PolyControlsHandle as b, type PolyControlsBaseOptions as c, type PolyControlsEvent as d, type PolyControlsListener as e, type PolyMeshHandle as f, PolyBoxElement as g, PolyCameraElement as h, type PolyCameraOptions as i, PolyConeElement as j, type PolyControlsAnimateOptions as k, type PolyControlsCamera as l, type PolyControlsChangeEvent as m, type PolyControlsInteractionEvent as n, PolyCylinderElement as o, PolyDodecahedronElement as p, PolyFirstPersonControlsElement as q, PolyIcosahedronElement as r, PolyIframeElement as s, PolyMapControlsElement as t, PolyMeshElement as u, type PolyMeshTransform as v, PolyOctahedronElement as w, PolyOrbitControlsElement as x, type PolyOrbitControlsHandle as y, type PolyOrbitControlsOptions as z };