@layoutit/polycss-core 0.0.1 → 0.2.1

package/dist/index.d.cts

@@ -11,13 +11,21 @@ declare const DEFAULT_PROJECTION: "cubic";
  *   variables, no JS work, no atlas re-rasterization.
  */
 type PolyTextureLightingMode = "baked" | "dynamic";
+/**
+ * Mesh post-processing intent.
+ * - "lossless": preserve the authored surface while applying exact
+ *   reductions such as interior culling and coplanar merge.
+ * - "lossy": allow bounded geometric approximation when it reduces the
+ *   rendered polygon/DOM count.
+ */
+type MeshResolution = "lossless" | "lossy";
 /**
  * 3D point/vector, stored as a `[x, y, z]` tuple. Tuple (rather than
  * `{x, y, z}`) for compact JSON: meshes serialize to thousands of vertices
  * and the difference adds up. Destructure with `const [x, y, z] = v` when
  * you need named axes.
  *
- * Polycss world space convention: +X right, +Y forward, +Z up.
+ * PolyCSS world space convention: +X right, +Y forward, +Z up.
  */
 type Vec3 = [number, number, number];
 /**
@@ -31,6 +39,12 @@ interface TextureTriangle {
     vertices: [Vec3, Vec3, Vec3];
     uvs: [Vec2, Vec2, Vec2];
 }
+type PolyTextureWrapMode = "repeat" | "clamp-to-edge" | "mirrored-repeat";
+interface PolyTextureWrap {
+    s: PolyTextureWrapMode;
+    t: PolyTextureWrapMode;
+}
+type PolyTextureAlphaMode = "opaque" | "mask" | "blend";
 /**
  * Directional light — simulates a single distant source (sun, key light).
  * Contributes Lambert shading scaled by `intensity`. `direction` is in
@@ -62,7 +76,7 @@ interface PolyAmbientLight {
  *
  * In CSS terms, a material bundles the `background-image` source plus paint
  * config. When a polygon references a material AND its UVs form an
- * axis-aligned rectangle, polycss renders the polygon as an <i> with
+ * axis-aligned rectangle, PolyCSS renders the polygon as an <i> with
  * `background-image: url(material.texture)` directly — no per-polygon canvas
  * rasterization, browser-cached texture, mounting / unmounting one polygon
  * does not affect any other.
@@ -74,7 +88,7 @@ interface PolyAmbientLight {
 interface PolyMaterial {
     /** Image source. Anything `background-image: url(...)` can use. */
     texture: string;
-    /** Optional unique key (used by polycss to dedupe / cache). Caller can
+    /** Optional unique key (used by PolyCSS to dedupe / cache). Caller can
      *  pass a stable string; if omitted, the material's identity is its object
      *  reference. */
     key?: string;
@@ -99,10 +113,24 @@ interface Polygon {
      * `color` (or default gray).
      */
     texture?: string;
+    /**
+     * Texture sampler wrap mode for UVs outside [0, 1]. glTF imports preserve
+     * sampler.wrapS / wrapT here so the atlas rasterizer can tile repeated UVs.
+     * When unset, renderers keep the historical single-image behavior.
+     * @internal
+     */
+    textureWrap?: PolyTextureWrap;
+    /**
+     * Texture alpha interpretation imported from glTF `material.alphaMode`.
+     * Opaque textures can use transparent PNG padding without cutting holes in
+     * the rendered polygon.
+     * @internal
+     */
+    textureAlphaMode?: PolyTextureAlphaMode;
     /**
      * Shared material. When set, `material.texture` takes precedence over the
      * inline `texture` field. If the polygon's UVs form an axis-aligned
-     * rectangle, polycss uses the direct CSS background-image path (no per-
+     * rectangle, PolyCSS uses the direct CSS background-image path (no per-
      * polygon canvas rasterization). Falls back to the atlas path otherwise.
      */
     material?: PolyMaterial;
@@ -119,6 +147,12 @@ interface Polygon {
      * @internal
      */
     textureTriangles?: TextureTriangle[];
+    /**
+     * Source material requested two-sided rendering. Importers use this so
+     * optimization passes do not collapse intentional reverse-wound faces.
+     * @internal
+     */
+    doubleSided?: boolean;
     /**
      * User-controlled metadata. Reflected to DOM as `data-*` attributes via
      * stringification by the framework wrappers. Only string|number|boolean
@@ -254,7 +288,7 @@ declare function computeTexturePaintMetrics(polygons: Polygon[], options?: Textu
 
 /**
  * Apply CSS-style chained `rotateX(rx) rotateY(ry) rotateZ(rz)` rotation
- * to a 3D vector. Matches the matrix composition used by polycss mesh
+ * to a 3D vector. Matches the matrix composition used by PolyCSS mesh
  * wrapper transforms (see `buildTransform` in each PolyMesh implementation).
  *
  * CSS composes `transform: rotateX(rx) rotateY(ry) rotateZ(rz)` as the
@@ -281,7 +315,52 @@ declare function rotateVec3(v: Vec3, rxDeg: number, ryDeg: number, rzDeg: number
 declare function inverseRotateVec3(v: Vec3, rot: Vec3): Vec3;
 
 /**
- * Base tile size in CSS pixels. One polycss world unit = BASE_TILE CSS
+ * Minimal quaternion helpers for composing rotations.
+ *
+ * Why we need quaternions: the public PolyMesh API exposes rotation as a
+ * Euler triple `[rx, ry, rz]` in degrees (drives CSS `rotateX rotateY
+ * rotateZ`, applied right-to-left). Euler triples don't compose by
+ * component addition — rotating Y after X must happen around the mesh's
+ * NEW local-Y axis, not world-Y. The transform-controls ring drag handler
+ * uses these helpers to compose around the mesh's local axis correctly:
+ *
+ *   q_start = quatFromEulerXYZ(currentRotationDeg)
+ *   q_delta = quatFromAxisAngle(localAxis, deltaRadians)
+ *   q_new   = quatMultiply(q_start, q_delta)        // RIGHT-multiply = local frame
+ *   next    = eulerXYZFromQuat(q_new)
+ *
+ * Convention: "XYZ" Euler means the composed rotation matrix is
+ * `Rx(rx) · Ry(ry) · Rz(rz)`, which matches CSS `rotateX rotateY rotateZ`
+ * (right-to-left application to a point ⇒ Z first, then Y, then X).
+ *
+ * Quaternion format: `[w, x, y, z]` (real-first, like three.js's internal
+ * `_x/_y/_z/_w` reordered). Stored as plain tuples — no constructor or
+ * runtime allocations per drag.
+ */
+
+/** Quaternion `[w, x, y, z]`, real component first. Unit-length is not
+ *  enforced by the type — callers normalize when needed. */
+type Quat = [number, number, number, number];
+/** Identity quaternion. */
+declare const QUAT_IDENTITY: Quat;
+/** Hamilton product `q1 * q2`. Apply to a vector as `q v q⁻¹`. Right-
+ *  multiplication composes the second rotation in the LOCAL frame of the
+ *  first — that's the property the gizmo relies on for local-axis drag. */
+declare function quatMultiply(q1: Quat, q2: Quat): Quat;
+/** Quaternion from axis-angle. `axis` must be unit length (caller's
+ *  responsibility — typically a CSS basis vector). `angleRad` in radians. */
+declare function quatFromAxisAngle(axis: Vec3, angleRad: number): Quat;
+/** Quaternion from Euler XYZ degrees — the order CSS `rotateX rotateY
+ *  rotateZ` applies. Matches the composed matrix `Rx(rx)·Ry(ry)·Rz(rz)`. */
+declare function quatFromEulerXYZ(eulerDeg: Vec3): Quat;
+/** Euler XYZ degrees from a quaternion — inverse of `quatFromEulerXYZ`.
+ *  Handles gimbal lock (|ry| → 90°) by collapsing rz onto rx. The output
+ *  matches the convention used by CSS `rotateX rotateY rotateZ` so it can
+ *  be written straight back into a PolyMesh rotation prop. */
+declare function eulerXYZFromQuat(q: Quat): Vec3;
+
+/**
+ * Base tile size in CSS pixels. One PolyCSS world unit = BASE_TILE CSS
  * pixels (pre-scale). Used to convert world-coordinate target values to
  * CSS translations in the transform string.
  */
@@ -296,7 +375,7 @@ type AutoRotateOption = boolean | number | AutoRotateConfig;
  * World-coordinate camera state (Three.js-style).
  *
  * `target` is the world point that should appear at the viewport centre.
- * Polycss world axes: [0]=X (rows/south), [1]=Y (cols/east), [2]=Z (up).
+ * PolyCSS world axes: [0]=X (rows/south), [1]=Y (cols/east), [2]=Z (up).
  *
  * `pan`, `tilt`, and `depthOffset` are gone. Translations now live inside
  * `target` so they happen BEFORE rotations — enabling correct world-space
@@ -394,6 +473,86 @@ declare function computeShapeLighting(normal: Vec3, baseColor: string, direction
 
 declare function mergePolygons(input: Polygon[]): Polygon[];
 
+/**
+ * dedupeOverlappingPolygons — drop polygons whose 3D footprint coincides
+ * with another polygon's, within an epsilon tolerance.
+ *
+ * Why this exists: modelers (and importers) often emit redundant geometry
+ * for the same visible surface — a doubled face on a wall, an inner shell
+ * coincident with an outer shell, or two N-gons that fan-triangulate the
+ * same region. Each duplicate is a real `<i>` element at render time:
+ * it costs DOM, Lambert math, atlas budget, AND it produces stacked
+ * shadow leaves that visibly multiply on the receiver (overlapping dark
+ * patches on the ground).
+ *
+ * This is a separate concern from `cullInteriorPolygons` (which removes
+ * polygons fully *enclosed* by other geometry, conservative against
+ * false positives) and from `mergePolygons` (which joins same-color
+ * coplanar polygons that share an edge). A polygon's exact twin
+ * doesn't share an edge with itself and isn't enclosed by anything —
+ * it slips through both passes.
+ *
+ * Algorithm:
+ *   1. Compute each polygon's plane (normal + signed offset along
+ *      normal) and centroid.
+ *   2. Bucket polygons by quantized plane key (rounded normal direction
+ *      with sign-folding so anti-parallel faces share a bucket, and
+ *      rounded distance from origin along the unsigned normal axis).
+ *      Polygons in different buckets cannot overlap.
+ *   3. Within each bucket, do an O(K²) pairwise check on at most K
+ *      polygons. Two polygons overlap if their 2D projections onto
+ *      the shared plane share a significant area fraction.
+ *   4. When a pair overlaps, drop one: prefer keeping the one whose
+ *      normal points *away* from the mesh centroid (the "outward"
+ *      face). For ties (truly identical orientation), keep the one
+ *      with greater 2D area.
+ *
+ * Runs once at parse time in the same pipeline as mergePolygons. Zero
+ * cost at runtime — once it returns the polygon array is final and the
+ * dedup logic never executes again.
+ */
+
+/** Tunable thresholds. Default values are conservative — only catch
+ *  duplicates that are visually identical surfaces (exact twins,
+ *  back-to-back winding flips, nested polys on the same plane).
+ *  Looser values are appropriate for shadow-casting purposes, where
+ *  any polygons whose projections land in the same place can share a
+ *  shadow without affecting the rendered model. */
+interface DedupeOverlappingPolygonsOptions {
+    /** Maximum 1 - |dot(n_a, n_b)| for normals to count as "parallel".
+     *  Default 1e-3 (strict — must be near-identical orientation).
+     *  Looser values (~5e-2 ≈ 18° off) treat near-parallel normals as
+     *  duplicates, useful for shadow dedup where small orientation
+     *  differences project to nearly the same shadow shape. */
+    normalTolerance?: number;
+    /** Maximum signed-distance difference between two polygons' plane
+     *  offsets (along their shared normal) to count as coplanar.
+     *  Default 0.05 (world units). Looser values treat distinct
+     *  parallel shells (e.g. an inner cavity wall behind an outer
+     *  wall) as shadow-duplicates. */
+    distanceTolerance?: number;
+    /** Minimum overlap fraction (max of A-in-B and B-in-A vertex
+     *  containment ratios) for a pair to count as a duplicate.
+     *  Default 0.7. Lower (~0.4) is liberal; higher (~0.9) is strict. */
+    overlapFraction?: number;
+    /** Preserve reverse-wound faces from authored double-sided materials.
+     *  Geometry dedupe keeps these by default; shadow dedupe can disable it
+     *  because coincident front/back casters produce stacked shadows. */
+    preserveDoubleSidedBackfaces?: boolean;
+}
+/** Identify polygons that are duplicates within tolerance. Returns the
+ *  set of indices into the input array that should be dropped (the
+ *  losers of duplicate pairs). The "winner" of a pair is the polygon
+ *  whose normal faces away from the mesh centroid (outward), with
+ *  larger area as a tiebreaker.
+ *
+ *  Exposed for callers that want to act on the index set directly —
+ *  e.g. shadow casting can use a looser tolerance to skip shadow leaves
+ *  for redundant casters without removing them from the renderable
+ *  polygon set. */
+declare function findOverlappingPolygonDuplicates(input: Polygon[], options?: DedupeOverlappingPolygonsOptions): Set<number>;
+declare function dedupeOverlappingPolygons(input: Polygon[], options?: DedupeOverlappingPolygonsOptions): Polygon[];
+
 interface CoverPlanarPolygonsOptions {
     /** Smallest connected coplanar group worth attempting. Default 4. */
     minGroupPolygons?: number;
@@ -413,6 +572,106 @@ interface CoverPlanarPolygonsOptions {
  */
 declare function coverPlanarPolygons(input: Polygon[], options?: CoverPlanarPolygonsOptions): Polygon[];
 
+interface OptimizeMeshPolygonsOptions {
+    /** Public quality/resolution intent. Defaults to "lossy". */
+    meshResolution?: MeshResolution;
+    /**
+     * Run the planar cover pass as an exact candidate for untextured coplanar
+     * regions. Defaults to true.
+     */
+    rectCover?: boolean | CoverPlanarPolygonsOptions;
+}
+declare function optimizeMeshPolygons(polygons: Polygon[], options?: OptimizeMeshPolygonsOptions): Polygon[];
+
+type SeamOverlapCandidateKind = "true-gap" | "connected-facet" | "material-boundary";
+interface SeamOverlapCandidate {
+    kind: SeamOverlapCandidateKind;
+    aPolygon: number;
+    aEdge: number;
+    bPolygon: number;
+    bEdge: number;
+    aColor?: string;
+    bColor?: string;
+    aMaterialKey: string;
+    bMaterialKey: string;
+    gapPx: number;
+    spanPx: number;
+    aStartPx: number;
+    aEndPx: number;
+    bStartPx: number;
+    bEndPx: number;
+    targetClosurePx: number;
+    appliedClosurePx: number;
+    residualGapPx: number;
+    residualTargetPx: number;
+}
+interface SeamOverlapDiagnostics {
+    exactPairs: number;
+    nearPairs: number;
+    patchedPolygons: number;
+    patchedEdges: number;
+    maxMeasuredGapPx: number;
+    maxAppliedAmountPx: number;
+    unclosedPairs: number;
+    maxResidualGapPx: number;
+}
+interface SeamOverlapOptions {
+    overlapPx?: number;
+    maxGapPx?: number;
+    capacityScale?: number;
+}
+interface SeamFacetSplitOptions {
+    rotX?: number;
+    rotY?: number;
+    viewAware?: boolean;
+    passes?: number;
+    budget?: number;
+}
+type SeamFacetSplitCandidateReason = "component-anchor" | "global-outlier" | "local-follow-up" | "shared-polygon" | "below-threshold";
+interface SeamFacetSplitCandidate {
+    key: string;
+    aPolygon: number;
+    aEdge: number;
+    bPolygon: number;
+    bEdge: number;
+    color?: string;
+    materialKey: string;
+    lengthPx: number;
+    projectedLengthPx: number;
+    score: number;
+    normalRisk: number;
+    shapeRisk: number;
+    viewRisk: number;
+    component: number;
+    marginalCost: number;
+    selected: boolean;
+    reason: SeamFacetSplitCandidateReason;
+}
+interface SeamFacetSplitReport {
+    candidates: SeamFacetSplitCandidate[];
+    selectedPolygons: number;
+    selectedEdges: number;
+    addedPolygons: number;
+}
+
+declare const DEFAULT_SEAM_OVERLAP_OPTIONS: {
+    readonly overlapPx: 1.25;
+    readonly maxGapPx: 14;
+    readonly capacityScale: 1;
+};
+declare const DEFAULT_SEAM_FACET_SPLIT_OPTIONS: {
+    readonly budget: 40;
+};
+declare function seamFacetSplitPolygons(polygons: Polygon[], seamOptions?: number | SeamOverlapOptions, splitOptions?: SeamFacetSplitOptions): Polygon[];
+declare function seamFacetSplitReport(polygons: Polygon[], seamOptions?: number | SeamOverlapOptions, splitOptions?: SeamFacetSplitOptions): SeamFacetSplitReport;
+declare function seamOverlapPolygons(polygons: Polygon[], options?: number | SeamOverlapOptions): Polygon[];
+declare function repairMeshSeams(polygons: Polygon[], seamOptions?: number | SeamOverlapOptions, splitOptions?: SeamFacetSplitOptions): Polygon[];
+declare function seamOverlapDiagnostics(polygons: Polygon[], options?: number | SeamOverlapOptions): SeamOverlapDiagnostics;
+declare function seamOverlapReport(polygons: Polygon[], options?: number | SeamOverlapOptions): {
+    diagnostics: SeamOverlapDiagnostics;
+    candidates: SeamOverlapCandidate[];
+};
+
 /**
  * cullInteriorPolygons — remove polygons that are fully enclosed by other
  * polygons of the same mesh and therefore never visible from any external
@@ -435,17 +694,40 @@ declare function coverPlanarPolygons(input: Polygon[], options?: CoverPlanarPoly
  */
 
 interface CullInteriorOptions {
-    /** Hemisphere ray samples per polygon. Higher = fewer false positives, slower. Default 12. */
+    /** Hemisphere ray samples per polygon. Higher = fewer false positives, slower. Default 8. */
     samples?: number;
 }
 declare function cullInteriorPolygons(polygons: Polygon[], options?: CullInteriorOptions): Polygon[];
 
+declare const CAMERA_BACKFACE_CULL_EPS = 0.00001;
+declare const VOXEL_CAMERA_CULL_AXIS_EPS = 0.001;
+declare const VOXEL_CAMERA_CULL_NORMAL_LIMIT = 6;
+interface CameraCullRotation {
+    rotX: number;
+    rotY: number;
+    meshRotation?: Vec3;
+}
+interface CameraCullNormalGroup {
+    key: string;
+    normal: Vec3;
+}
+declare function polygonCssSurfaceNormal(polygon: Polygon): Vec3 | null;
+declare function cameraFacingDepth(normal: Vec3, rotation: CameraCullRotation): number;
+declare function normalFacesCamera(normal: Vec3, rotation: CameraCullRotation, depthThreshold?: number): boolean;
+declare function polygonFacesCamera(polygon: Polygon, rotation: CameraCullRotation, depthThreshold?: number): boolean;
+declare function cameraCullNormalKey(normal: Vec3): string;
+declare function cameraCullNormalGroups(normals: Iterable<Vec3 | null | undefined>): CameraCullNormalGroup[];
+declare function cameraCullNormalGroupsFromPolygons(polygons: readonly Polygon[]): CameraCullNormalGroup[];
+declare function isAxisAlignedSurfaceNormal(normal: Vec3, axisEpsilon?: number): boolean;
+declare function isVoxelCameraCullableNormalGroups(groups: readonly CameraCullNormalGroup[]): boolean;
+declare function cameraCullVisibleSignature(groups: readonly CameraCullNormalGroup[], rotation: CameraCullRotation, depthThreshold?: number): string;
+
 /**
  * Geometry for the three.js-style debug axes gizmo: three thin colored
  * cuboids stretching along world-X, world-Y and world-Z. Mirrors the
  * convention `red=X, green=Y, blue=Z`.
  *
- * Returned polygons are in the standard polycss world-space convention
+ * Returned polygons are in the standard PolyCSS world-space convention
  * (`+X right, +Y forward, +Z up`). Wrap with the framework's PolyMesh /
  * PolyScene equivalent to render.
  */
@@ -471,6 +753,30 @@ interface AxesHelperOptions {
  */
 declare function axesHelperPolygons(options?: AxesHelperOptions): Polygon[];
 
+/**
+ * Axis-aligned box/cuboid geometry as six quad polygons.
+ *
+ * Returned polygons are in standard PolyCSS world space:
+ * +X = right, +Y = front/forward, +Z = top/up.
+ */
+
+type BoxFace = "right" | "left" | "front" | "back" | "top" | "bottom";
+type BoxFaceOptions = Pick<Polygon, "color" | "texture" | "material" | "uvs" | "data">;
+interface BoxPolygonsOptions extends BoxFaceOptions {
+    /** Size along the world X/Y/Z axes. Defaults to a 1×1×1 cube. */
+    size?: number | Vec3;
+    /** Center used with `size`. Defaults to the origin. */
+    center?: Vec3;
+    /** Explicit minimum world-space corner. When set with `max`, bounds win over size/center. */
+    min?: Vec3;
+    /** Explicit maximum world-space corner. When set with `min`, bounds win over size/center. */
+    max?: Vec3;
+    /** Per-face material/data overrides. Set a face to `false` to omit it. */
+    faces?: Partial<Record<BoxFace, BoxFaceOptions | false>>;
+}
+/** Build the polygons for one axis-aligned box/cuboid. */
+declare function boxPolygons(options?: BoxPolygonsOptions): Polygon[];
+
 /**
  * Geometry for a single 3D arrow: a thin axis-aligned cuboid shaft
  * stretching from the origin along one signed axis, capped with a
@@ -478,7 +784,7 @@ declare function axesHelperPolygons(options?: AxesHelperOptions): Polygon[];
  * drag handle for `<TransformControls>` — same primitive recipe as
  * `axesHelperPolygons`, plus an arrowhead.
  *
- * Returned polygons are in standard polycss world space and intended
+ * Returned polygons are in standard PolyCSS world space and intended
  * to be wrapped in the framework's PolyMesh equivalent for rendering.
  */
 
@@ -497,6 +803,11 @@ interface ArrowPolygonsOptions {
     headHalfThickness?: number;
     /** Fill color. */
     color?: string;
+    /** Emit the rectangular shaft polygons. Default `true`. Set `false` to
+     *  render just the pyramid head — used by transform-control gizmos to
+     *  declutter back-facing axes (only the head still identifies direction
+     *  while the shaft would visually overlap the front-facing arrow). */
+    shaft?: boolean;
 }
 /** Build the polygons for one signed-axis arrow. */
 declare function arrowPolygons(options: ArrowPolygonsOptions): Polygon[];
@@ -512,7 +823,7 @@ declare function arrowPolygons(options: ArrowPolygonsOptions): Polygon[];
  * "rotation circle" and keeps the polygon count proportional to the
  * `segments` knob.
  *
- * Returned polygons are in standard polycss world space and intended
+ * Returned polygons are in standard PolyCSS world space and intended
  * to be wrapped in the framework's PolyMesh equivalent for rendering.
  */
 
@@ -534,6 +845,66 @@ interface RingPolygonsOptions {
 /** Build the polygons for a flat ring (annulus). */
 declare function ringPolygons(options: RingPolygonsOptions): Polygon[];
 
+/**
+ * One square quad covering the bounding box of a ring (annulus) in the
+ * plane perpendicular to a chosen axis. Used by `<PolyTransformControls
+ * mode="rotate">` together with a CSS `mask: radial-gradient(...)` to
+ * render the visible donut, replacing the segmented quad-strip approach
+ * of `ringPolygons` with a single DOM element per ring.
+ *
+ * The caller is responsible for applying the mask CSS and using a donut-
+ * shaped hit-test (the quad's bounding rect alone would over-hit the
+ * inner hole). The recommended setup is to set the CSS custom property
+ * `--ring-inner-ratio` on the mesh element so the mask scales with the
+ * caller's chosen thickness ratio.
+ */
+
+interface RingQuadPolygonsOptions {
+    /** World axis the ring is perpendicular to: 0=X, 1=Y, 2=Z. The quad
+     *  lies in the plane spanned by the other two axes. */
+    axis: 0 | 1 | 2;
+    /** Outer radius of the ring. The quad spans ±outerRadius in both
+     *  in-plane axes. */
+    outerRadius: number;
+    /** Fill color. */
+    color?: string;
+}
+/** Build a single 4-vertex polygon (a square) bounding the ring's outer
+ *  circle. CSS `mask` is expected to clip this to the donut shape at
+ *  render time. */
+declare function ringQuadPolygons(options: RingQuadPolygonsOptions): Polygon[];
+
+/**
+ * A flat quad on one of the three axis-aligned planes, offset diagonally
+ * along the two in-plane axes. Used as a planar drag handle in
+ * `<PolyTransformControls>` — clicking and dragging this handle moves the
+ * attached mesh along two axes simultaneously (XY, XZ, or YZ), instead of
+ * the single-axis motion the arrow shafts provide.
+ *
+ * The polygon lives in standard PolyCSS world space; wrap it in the
+ * framework's PolyMesh equivalent for rendering.
+ */
+
+interface PlanePolygonsOptions {
+    /** Axis perpendicular to the plane: 0 = YZ plane, 1 = XZ plane,
+     *  2 = XY plane. The quad lies on the OTHER two axes. */
+    axis: 0 | 1 | 2;
+    /** Half-extent of the quad along each in-plane axis. Default `0.4`. */
+    size?: number;
+    /** Center of the quad along the two in-plane axes. Pass a single number
+     *  to use the same offset on both (positive places the handle in the
+     *  +A/+B corner). Pass `[offsetA, offsetB]` to control each
+     *  independently — sign flips move the handle to a different octant.
+     *  `A = (axis+1)%3`, `B = (axis+2)%3`. Default `size * 2`. */
+    offset?: number | [number, number];
+    /** Position along the perpendicular axis. Default `0` (on the plane). */
+    along?: number;
+    /** Fill color. */
+    color?: string;
+}
+/** Build the polygons for one axis-aligned planar drag handle. */
+declare function planePolygons(options: PlanePolygonsOptions): Polygon[];
+
 /**
  * Geometry for a small solid-color octahedron — the marker shape used by
  * `PolyDirectionalLightHelper` to indicate where a directional light is
@@ -551,6 +922,249 @@ interface OctahedronPolygonsOptions {
 }
 declare function octahedronPolygons(options: OctahedronPolygonsOptions): Polygon[];
 
+/**
+ * Icosphere (subdivided icosahedron) geometry — approximates a sphere with
+ * triangular faces. Each subdivision step quadruples the face count:
+ *   subdivisions 0 → 20, 1 → 80, 2 → 320, 3 → 1280 (capped).
+ *
+ * Vertex coordinates use PolyCSS world space: +X right, +Y forward, +Z up.
+ * The sphere is centered at the origin; all vertices sit at distance `radius`.
+ * Faces wind CCW from the outside (outward normal = away from origin).
+ */
+
+interface SpherePolygonsOptions {
+    /** Radius of the sphere. Default 50. */
+    radius?: number;
+    /** Subdivision level (0 = bare icosahedron, 20 triangles; each +1 quadruples count). Default 1 → 80 triangles. Cap at 3 (1280 triangles). */
+    subdivisions?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function spherePolygons(options?: SpherePolygonsOptions): Polygon[];
+
+/**
+ * Regular tetrahedron geometry — four equilateral triangular faces.
+ *
+ * Vertices are placed so the tetrahedron is centered at the origin.
+ * Faces wind CCW from the outside.
+ *
+ * PolyCSS world space: +X right, +Y forward, +Z up.
+ */
+
+interface TetrahedronPolygonsOptions {
+    /** Circumradius: distance from center to each vertex. Default 100. */
+    size?: number;
+    /** Fill color applied to all four faces. */
+    color?: string;
+}
+declare function tetrahedronPolygons(options?: TetrahedronPolygonsOptions): Polygon[];
+
+/**
+ * Regular icosahedron geometry — 20 equilateral triangular faces.
+ *
+ * Vertices are placed on a sphere of radius `size` centered at the origin.
+ * Faces wind CCW from the outside.
+ *
+ * PolyCSS world space: +X right, +Y forward, +Z up.
+ */
+
+interface IcosahedronPolygonsOptions {
+    /** Circumradius: distance from center to each vertex. Default 100. */
+    size?: number;
+    /** Fill color applied to all 20 faces. */
+    color?: string;
+}
+declare function icosahedronPolygons(options?: IcosahedronPolygonsOptions): Polygon[];
+
+/**
+ * Regular dodecahedron geometry — 12 regular pentagonal faces.
+ *
+ * Vertices are placed on a sphere of radius `size` centered at the origin.
+ * Each face is a pentagon (5 vertices) wound CCW from the outside.
+ *
+ * All 12 pentagonal faces of a regular dodecahedron are truly planar — each
+ * lies on a single tangent plane. No triangulation is needed. The renderer
+ * uses <i> (border-shape) on Chromium and <s> elsewhere for non-quad polygons.
+ *
+ * PolyCSS world space: +X right, +Y forward, +Z up.
+ */
+
+interface DodecahedronPolygonsOptions {
+    /** Circumradius: distance from center to each vertex. Default 100. */
+    size?: number;
+    /** Fill color applied to all 12 faces. */
+    color?: string;
+}
+declare function dodecahedronPolygons(options?: DodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Z-axis cylinder geometry with optional radius taper.
+ *
+ * Geometry:
+ *   - `radialSegments` side faces (quads for cylinders/frustums, triangles
+ *     when one radius collapses to a cone tip).
+ *   - `radialSegments` bottom-cap triangles (fan from center).
+ *   - `radialSegments` top-cap triangles (fan from center), omitted when
+ *     radiusTop ≈ 0 (i.e. cone tip).
+ *
+ * The cylinder sits centered at the origin, spanning Z = −height/2 to
+ * Z = +height/2. Side quads are axis-aligned in the cylinder's own local
+ * frame, which maximises the chance of hitting the <b> quad fast-path.
+ *
+ * PolyCSS world space: +X right, +Y forward, +Z up. The cylinder axis is
+ * the Z axis so a typical upright pillar stands without any extra rotation.
+ */
+
+interface CylinderPolygonsOptions {
+    /** Bottom-cap radius. Default 50. */
+    radius?: number;
+    /** Top-cap radius. Defaults to `radius` (straight cylinder).
+     *  Set to 0 (or near 0) for a cone. */
+    radiusTop?: number;
+    /** Height along the Z axis. Default 100. */
+    height?: number;
+    /** Number of radial segments. Default 12. */
+    radialSegments?: number;
+    /** Fill color applied to all polygons. */
+    color?: string;
+}
+declare function cylinderPolygons(options?: CylinderPolygonsOptions): Polygon[];
+
+/**
+ * Z-axis cone geometry — a cylinder with `radiusTop: 0`.
+ *
+ * This is a thin wrapper around `cylinderPolygons` with `radiusTop` forced
+ * to zero. The top cap is omitted (no area at the tip), and side faces are
+ * emitted as triangles.
+ *
+ * PolyCSS world space: +X right, +Y forward, +Z up. Cone axis is Z; the apex
+ * is at Z = +height/2 and the base at Z = -height/2.
+ */
+
+interface ConePolygonsOptions {
+    /** Base radius. Default 50. */
+    radius?: number;
+    /** Height along the Z axis. Default 100. */
+    height?: number;
+    /** Number of radial segments. Default 12. */
+    radialSegments?: number;
+    /** Fill color applied to all polygons. */
+    color?: string;
+}
+declare function conePolygons(options?: ConePolygonsOptions): Polygon[];
+
+/**
+ * Torus geometry — Z-axis ring plane.
+ *
+ * The torus is centered at the origin. The ring lies in the XY plane (the
+ * ground plane in PolyCSS world space, where Z is up). The donut hole points
+ * along the Z axis.
+ *
+ * Geometry: `radialSegments × tubularSegments` quads on the surface.
+ *
+ * DOM cost note: at default settings (12 × 16 = 192 quads) this is the
+ * heaviest of the built-in primitives. Reduce radialSegments / tubularSegments
+ * if render budget is tight.
+ *
+ * PolyCSS world space: +X right, +Y forward, +Z up.
+ */
+
+interface TorusPolygonsOptions {
+    /** Distance from center of tube to center of torus. Default 50. */
+    radius?: number;
+    /** Radius of the tube. Default 15. */
+    tube?: number;
+    /** Number of segments around the main ring. Default 12. */
+    radialSegments?: number;
+    /** Number of segments around the tube cross-section. Default 16. */
+    tubularSegments?: number;
+    /** Fill color applied to all polygons. */
+    color?: string;
+}
+declare function torusPolygons(options?: TorusPolygonsOptions): Polygon[];
+
+/** Tiny non-zero scale collapsed into the projection's Z column to keep
+ *  the matrix invertible. Chromium skips elements whose composed
+ *  transform is singular (m22 = 0 would make this a true projection
+ *  matrix, but Chromium would refuse to paint it), so we crush Z to 1%
+ *  of its input instead of exactly zero. The result still looks flat
+ *  to the eye — sub-pixel drift on any realistic scene size. */
+declare const BAKED_SHADOW_Z_SQUASH = 0.01;
+/** Minimum absolute value of the up-axis light component before the
+ *  projection blows up (we divide by it). Matches the --clz clamp in
+ *  the dynamic-mode applyDynamicLightVars helper so baked + dynamic
+ *  behave identically when the light is near-horizontal. */
+declare const BAKED_SHADOW_MIN_UP = 0.01;
+/**
+ * Build the CSS-space shadow projection matrix for a fixed light + ground
+ * plane. The 16-element output mirrors the matrix3d expression in the
+ * dynamic-mode `--shadow-proj` CSS custom property, but with literal
+ * numbers — ready to be formatted into a single `matrix3d(...)` per
+ * shadow leaf.
+ *
+ * `lightDir` is the direction the light TRAVELS (e.g. `[0, 0, -1]` is
+ * straight down). PolyCSS world Z is up, and the world→CSS axis swap
+ * leaves Z alone — see styles.ts for the full convention.
+ *
+ * `groundCssZ` is the receiver plane in CSS-Z (= world-Z) coordinates,
+ * already in unit-less form (matrix3d entries must be dimensionless).
+ */
+declare function buildBakedShadowProjectionMatrix(lightDir: Vec3, groundCssZ: number): number[];
+/**
+ * Decides whether a polygon should cast a shadow given its outward
+ * normal and the light's travel direction.
+ *
+ * True for polygons whose normals point in the same direction as the
+ * light travels — i.e., on the far/dark side of the mesh from the
+ * light's POV. Those define the silhouette of the cast shadow.
+ *
+ * False for front-facing polygons whose projection would land inside
+ * the silhouette and only add overdraw. Dynamic mode hides these with
+ * a Lambert opacity gate; baked mode skips the DOM emission entirely.
+ */
+declare function isBakedShadowCaster(normal: Vec3, lightDir: Vec3): boolean;
+/**
+ * 2D convex hull (Andrew's monotone chain, O(n log n)). Returns the
+ * hull vertices in CCW order. Used to compute a receiver mesh's XY
+ * footprint when subtracting it from the global ground shadow.
+ */
+declare function convexHull2D(points: ReadonlyArray<readonly [number, number]>): Array<[number, number]>;
+/**
+ * Signed area of a 2D polygon (positive for CCW vertex order, negative
+ * for CW). Used by `ensureCcw2D` to normalize winding before concatenating
+ * polygons into a compound SVG path under `fill-rule="nonzero"`: mixed
+ * CCW/CW subpaths would cancel each other's winding in the overlap
+ * region and paint an unintended hole.
+ */
+declare function polygonSignedArea2D(vertices: ReadonlyArray<readonly [number, number]>): number;
+/**
+ * Returns the polygon's vertices in CCW order, reversing if necessary.
+ * Operates on a copy — input is left unmodified.
+ */
+declare function ensureCcw2D(vertices: ReadonlyArray<readonly [number, number]>): Array<[number, number]>;
+/**
+ * Projects a single CSS-3D vertex onto the shadow ground plane, returning
+ * the resulting 2D point in CSS coordinates. Mirrors the per-element
+ * matrix3d that the dynamic-mode `--shadow-proj` builds, but evaluated on
+ * the CPU for a fixed light + ground — handy when many projected vertices
+ * are needed at once (e.g. rendering shadow outlines into a single SVG
+ * per mesh instead of one DOM leaf per casting polygon).
+ *
+ * `cssVertex` is a 3D point that has already been through the world→CSS
+ * axis swap and unit scale (so its components are dimensionless CSS-space
+ * coordinates). `lightDir` follows the same `--clx/--cly/--clz` convention
+ * as `buildBakedShadowProjectionMatrix`.
+ */
+declare function projectCssVertexToGround(cssVertex: Vec3, lightDir: Vec3, groundCssZ: number): [number, number];
+
+type Pt = readonly [number, number];
+/**
+ * Clips `subject` against the convex polygon `clip`. Both polygons are
+ * 2D, given in CCW vertex order. Returns the clipped polygon as a new
+ * array of points; an empty array means `subject` lies entirely outside.
+ */
+declare function clipPolygonToConvex2D(subject: ReadonlyArray<Pt>, clip: ReadonlyArray<Pt>): Array<[number, number]>;
+
 /**
  * Unified parser return type. All polygon-emitting parsers (parseObj,
  * parseGltf, the loadMesh dispatcher) return this exact shape.
@@ -563,6 +1177,22 @@ declare function octahedronPolygons(options: OctahedronPolygonsOptions): Polygon
  * is empty (e.g. `parseObj`, where it's a no-op).
  */
 
+interface PolyVoxelCell {
+    x: number;
+    y: number;
+    z: number;
+    color: string;
+}
+interface PolyVoxelSource {
+    kind: "magica-vox";
+    cells: PolyVoxelCell[];
+    rows: number;
+    cols: number;
+    depth: number;
+    scale: number;
+    gridShift: number;
+    sourceBytes: number;
+}
 interface ParseAnimationClip {
     /** Stable numeric index in the source file's animation array. */
     index: number;
@@ -585,6 +1215,8 @@ interface ParseAnimationController {
 interface ParseResult {
     /** The mesh, as a flat polygon list. Already vertex-permuted to polycss space. */
     polygons: Polygon[];
+    /** Optional raw voxel source for `.vox` fast paths; polygon fallback remains authoritative. */
+    voxelSource?: PolyVoxelSource;
     /** Optional animation sampler for formats that carry timeline data. */
     animation?: ParseAnimationController;
     /**
@@ -616,6 +1248,8 @@ interface ParseResult {
         animations?: ParseAnimationClip[];
         /** Source file size in bytes (for diagnostics). */
         sourceBytes?: number;
+        /** Voxel count for `.vox` sources. */
+        voxelCount?: number;
     };
 }
 
@@ -723,6 +1357,12 @@ interface PolyAnimationMixer {
 }
 declare function createPolyAnimationMixer(root: PolyAnimationTarget, controller: ParseAnimationController): PolyAnimationMixer;
 
+interface OptimizeAnimatedMeshPolygonsOptions {
+    /** Public quality/resolution intent. Defaults to "lossy". */
+    meshResolution?: MeshResolution;
+}
+declare function optimizeAnimatedMeshPolygons(result: ParseResult, options?: OptimizeAnimatedMeshPolygonsOptions): ParseResult;
+
 interface ObjParseOptions {
     /**
      * Largest mesh extent (in scene-space units). The mesh is uniformly
@@ -810,10 +1450,16 @@ interface GltfParseOptions {
      * material's `pbrMetallicRoughness.baseColorFactor` if not in this map.
      */
     materialColors?: Record<string, string>;
+    /**
+     * Override map: glTF material name → texture image URL. Takes priority over
+     * `pbrMetallicRoughness.baseColorTexture`; useful for GLB/GLTF exports that
+     * preserved UVs but dropped external image references.
+     */
+    materialTextures?: Record<string, string>;
     /**
      * Which axis is "up" in the source mesh.
      *  - "y" (default, glTF spec): cyclic permutation (x,y,z) → (z,x,y) so
-     *    +Y ends up on polycss's +Z (elevation).
+     *    +Y ends up on PolyCSS's +Z (elevation).
      *  - "z" (Blender-style, FBX2glTF often emits this): identity, no swap.
      * Pick "z" if the model lands on its side / lies down instead of
      * standing.
@@ -851,8 +1497,9 @@ declare function bakeSolidTextureSamples(result: ParseResult, options?: SolidTex
 
 interface VoxParseOptions {
     /**
-     * Largest mesh extent (in scene-space units). The mesh is uniformly
-     * scaled so its longest bbox dimension equals this. Default: 60.
+     * Largest mesh extent (in scene-space units). For `.vox`, the requested
+     * extent is snapped to the nearest integer CSS cell size to keep voxel
+     * fast-path coordinates integral. Default: 60.
      */
     targetSize?: number;
     /**
@@ -861,6 +1508,19 @@ interface VoxParseOptions {
      * non-negative integers so zero makes sensible default.
      */
     gridShift?: number;
+    /**
+     * Optional lossy palette simplification. When > 0, opaque, hue-compatible
+     * palette colors within this RGB distance are folded into the most-used
+     * nearby color before greedy voxel meshing. Default: disabled.
+     */
+    paletteMergeDistance?: number;
+    /**
+     * Optional lossy local cleanup. When > 0, small face-plane color islands
+     * and thin streaks are recolored to a neighboring dominant hue-compatible
+     * color within this RGB distance before greedy voxel meshing. Default:
+     * disabled.
+     */
+    colorRegionMergeDistance?: number;
 }
 declare function parseVox(buffer: ArrayBuffer, options?: VoxParseOptions): ParseResult;
 
@@ -908,7 +1568,521 @@ interface LoadMeshOptions {
      * low-poly models that use texture atlases as color swatches.
      */
     solidTextureSamples?: boolean | SolidTextureSampleOptions;
+    /**
+     * Mesh optimization intent. Defaults to "lossy"; set "lossless" to keep
+     * exact planar candidates only.
+     */
+    meshResolution?: MeshResolution;
 }
 declare function loadMesh(url: string, options?: LoadMeshOptions): Promise<ParseResult>;
 
-export { type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BASE_TILE, type CameraHandle, type CameraState, type CameraStyleInput, type CoverPlanarPolygonsOptions, type CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, type GltfParseOptions, type LoadMeshOptions, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParsedColor, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyDirectionalLight, type PolyMaterial, type PolyTextureLightingMode, type Polygon, type PolygonFace, type RingPolygonsOptions, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type SolidTextureSampleOptions, type TexturePaintMetrics, type TexturePaintMetricsOptions, type TextureTriangle, type Vec2, type Vec3, type VoxParseOptions, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, buildSceneContext, clampChannel, computeSceneBbox, computeShapeLighting, computeTexturePaintMetrics, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, cullInteriorPolygons, formatColor, inverseRotateVec3, loadMesh, mergePolygons, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, polygonFaces, ringPolygons, rotateVec3, shadeColor };
+declare const DEFAULT_TILE = 50;
+declare const DEFAULT_LIGHT_DIR: Vec3;
+declare const DEFAULT_LIGHT_COLOR = "#ffffff";
+declare const DEFAULT_LIGHT_INTENSITY = 1;
+declare const DEFAULT_AMBIENT_COLOR = "#ffffff";
+declare const DEFAULT_AMBIENT_INTENSITY = 0.4;
+declare const ATLAS_MAX_SIZE = 4096;
+declare const ATLAS_PADDING = 1;
+declare const MIN_ATLAS_SCALE = 0.1;
+declare const MAX_ATLAS_SCALE = 1;
+declare const AUTO_ATLAS_LOW_AREA: number;
+declare const AUTO_ATLAS_MEDIUM_AREA: number;
+declare const AUTO_ATLAS_MAX_BITMAP_SIDE = 2048;
+declare const AUTO_ATLAS_MAX_DECODED_BYTES_MOBILE: number;
+declare const AUTO_ATLAS_MAX_DECODED_BYTES_DESKTOP: number;
+declare const AUTO_ATLAS_SCALE_GUARD = 0.995;
+declare const COLOR_PARSE_CACHE_MAX = 512;
+declare const ASYNC_RENDER_BUDGET_MS = 12;
+declare const RECT_EPS = 0.001;
+declare const BASIS_EPS = 1e-9;
+declare const SURFACE_NORMAL_EPS = 0.0001;
+declare const SURFACE_DISTANCE_EPS = 0.1;
+declare const SEAM_LIGHT_EPS = 0.01;
+declare const TEXTURE_TRIANGLE_BLEED = 0.75;
+declare const TEXTURE_EDGE_REPAIR_ALPHA_MIN = 1;
+declare const TEXTURE_EDGE_REPAIR_SOURCE_ALPHA_MIN = 250;
+declare const TEXTURE_EDGE_REPAIR_RADIUS = 1.5;
+declare const SOLID_TRIANGLE_BLEED = 0.75;
+declare const DEFAULT_MATRIX_DECIMALS = 3;
+declare const DEFAULT_BORDER_SHAPE_DECIMALS = 2;
+declare const DEFAULT_ATLAS_CSS_DECIMALS = 4;
+declare const DECIMAL_SCALES: number[];
+declare const SOLID_QUAD_CANONICAL_SIZE = 64;
+declare const SOLID_TRIANGLE_CANONICAL_SIZE = 32;
+declare const SOLID_TRIANGLE_LARGE_BORDER_CANONICAL_SIZE = 96;
+declare const SOLID_TRIANGLE_CORNER_CLASS = "polycss-corner-triangle";
+declare const SOLID_TRIANGLE_LARGE_BORDER_CLASS = "polycss-large-border-triangle";
+declare const ATLAS_CANONICAL_SIZE_EXPLICIT = 64;
+declare const ATLAS_CANONICAL_SIZE_AUTO_DESKTOP = 128;
+declare const BORDER_SHAPE_CENTER_PERCENT = 50;
+declare const BORDER_SHAPE_POINT_EPS = 1e-7;
+declare const BORDER_SHAPE_CANONICAL_SIZE = 16;
+declare const BORDER_SHAPE_BLEED = 0.9;
+declare const CORNER_SHAPE_POINT_EPS = 0.75;
+declare const CORNER_SHAPE_DUPLICATE_EPS = 0.2;
+declare const PROJECTIVE_QUAD_DENOM_EPS = 0.05;
+declare const PROJECTIVE_QUAD_MAX_WEIGHT_RATIO = 256;
+declare const PROJECTIVE_QUAD_BLEED = 0.6;
+declare const DEFAULT_SEAM_BLEED = 1.5;
+
+interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+interface RGBFactors {
+    r: number;
+    g: number;
+    b: number;
+}
+interface UvAffine {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+interface UvSampleRect {
+    minU: number;
+    minV: number;
+    maxU: number;
+    maxV: number;
+}
+interface TextureTrianglePlan {
+    screenPts: number[];
+    uvAffine: UvAffine | null;
+    uvSampleRect: UvSampleRect | null;
+}
+interface TextureAtlasPlan {
+    index: number;
+    polygon: Polygon;
+    texture?: string;
+    tileSize: number;
+    layerElevation: number;
+    matrix: string;
+    canonicalMatrix: string;
+    atlasMatrix: string;
+    atlasCanonicalSize?: number;
+    projectiveMatrix: string | null;
+    canvasW: number;
+    canvasH: number;
+    screenPts: number[];
+    uvAffine: UvAffine | null;
+    uvSampleRect: UvSampleRect | null;
+    textureTriangles: TextureTrianglePlan[] | null;
+    textureEdgeRepairEdges: Set<number> | null;
+    textureEdgeRepair: boolean;
+    seamBleed?: number;
+    seamBleedEdges?: Set<number>;
+    seamBleedEdgeAmounts?: Map<number, number>;
+    seamBleedInsets?: SeamBleedInsets;
+    /** World-space surface normal — stable across light changes, used by dynamic mode. */
+    normal: Vec3;
+    textureTint: RGBFactors;
+    shadedColor: string;
+}
+interface BorderShapeBounds {
+    minX: number;
+    minY: number;
+    width: number;
+    height: number;
+}
+interface BorderShapeGeometry {
+    bounds: BorderShapeBounds;
+    points: Array<[number, number]>;
+}
+type CornerShapeCorner = "topLeft" | "topRight" | "bottomRight" | "bottomLeft";
+type CornerShapeSide = "left" | "right" | "top" | "bottom";
+interface CornerShapeRadius {
+    x: number;
+    y: number;
+}
+interface CornerShapeGeometry {
+    bounds: BorderShapeBounds;
+    radii: Partial<Record<CornerShapeCorner, CornerShapeRadius>>;
+}
+type TextureQuality = number | "auto";
+type PolySeamBleed = number | "auto";
+type PolySeamBleedEdgeValue = ReadonlySet<number> | ReadonlyMap<number, number>;
+type PolySeamBleedEdges = ReadonlyMap<number, PolySeamBleedEdgeValue> | readonly (PolySeamBleedEdgeValue | undefined)[];
+type PolyRenderStrategy = "b" | "i" | "u";
+type SolidTrianglePrimitive = "border" | "border-large" | "corner-bevel";
+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[];
+}
+interface SeamBleedInsets {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+interface PackedTextureAtlasEntry extends TextureAtlasPlan {
+    pageIndex: number;
+    x: number;
+    y: number;
+}
+interface PackedPage {
+    width: number;
+    height: number;
+    entries: PackedTextureAtlasEntry[];
+}
+interface PackingShelf {
+    x: number;
+    y: number;
+    height: number;
+}
+interface PackingPage extends PackedPage {
+    shelves: PackingShelf[];
+    sealed?: boolean;
+}
+interface PackedAtlas {
+    entries: Array<PackedTextureAtlasEntry | null>;
+    pages: PackedPage[];
+}
+interface SolidTriangleBasis {
+    a: number;
+    b: number;
+    c: number;
+}
+interface SolidTriangleColorPlan {
+    index: number;
+    polygon: Polygon;
+    colorComputed: boolean;
+    bakedColor?: string;
+    bakedRgb?: RGB;
+    bakedAlpha?: number;
+    dynamicVars?: string;
+}
+interface SolidTrianglePlan extends SolidTriangleColorPlan {
+    styleText: string;
+    transformText: string;
+    basis: SolidTriangleBasis;
+    primitive: SolidTrianglePrimitive;
+}
+interface SolidTriangleComputeOptions {
+    basis?: SolidTriangleBasis;
+    includeColor?: boolean;
+    matrixDecimals?: number;
+    color?: string;
+    primitive?: SolidTrianglePrimitive;
+    /** Pre-resolved primitive used when `primitive` is not set — replaces the
+     *  browser-global resolution that formerly happened inside the function. */
+    resolvedPrimitive?: SolidTrianglePrimitive | null;
+}
+interface StableTriangleColorState {
+    updatesDisabled: boolean;
+    freezeFrames: number;
+    colorFrame: number;
+    maxStep: number;
+}
+interface SolidTriangleFrame {
+    polygonCount: number;
+    vertices: ArrayLike<number>;
+    colors?: readonly (string | undefined)[];
+}
+interface SolidPaintDefaults {
+    paintColor?: string;
+    dynamicColor?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    dynamicColorKey?: string;
+}
+interface TextureAtlasPage {
+    width: number;
+    height: number;
+    url: string | null;
+}
+interface RectBrush {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface LocalBasis {
+    xAxis: Vec3;
+    yAxis: Vec3;
+    local2D: Vec2[];
+    shiftX: number;
+    shiftY: number;
+    canvasW: number;
+    canvasH: number;
+    pixelArea: number;
+    rawArea: number;
+}
+interface BasisOptions {
+    optimize: boolean;
+    fixedXAxis?: Vec3;
+    boundsOrigin?: Vec3;
+    snapBounds?: boolean;
+    seamEdges?: Set<number>;
+}
+interface BasisHint {
+    xAxis?: Vec3;
+    boundsOrigin?: Vec3;
+    seamEdges: Set<number>;
+    textureEdgeRepairEdges?: Set<number>;
+}
+interface PolygonBasisInfo {
+    pts: Vec3[];
+    normal: Vec3;
+    planeD: number;
+    optimizable: boolean;
+}
+interface ProjectiveQuadGuardSettings {
+    denomEps: number;
+    maxWeightRatio: number;
+    bleed: number;
+    disableGuards: boolean;
+}
+interface ProjectiveQuadGuardOverrides {
+    denomEps?: number;
+    maxWeightRatio?: number;
+    bleed?: number;
+    disableGuards?: boolean;
+}
+interface ProjectiveQuadGuardGlobal {
+    __polycssProjectiveQuadGuards?: ProjectiveQuadGuardOverrides;
+}
+interface ProjectiveQuadCoefficients {
+    g: number;
+    h: number;
+    w1: number;
+    w3: number;
+}
+interface StablePlanBasis {
+    normal: Vec3;
+    xAxis: Vec3;
+    yAxis: Vec3;
+    tx: number;
+    ty: number;
+    tz: number;
+}
+/** Options for solidTrianglePlan computation — the pure-math subset of
+ *  RenderTextureAtlasOptions with no DOM reference. */
+interface SolidTrianglePlanOptions {
+    tileSize?: number;
+    layerElevation?: number;
+    directionalLight?: PolyDirectionalLight;
+    ambientLight?: PolyAmbientLight;
+    textureLighting?: PolyTextureLightingMode;
+    solidPaintDefaults?: SolidPaintDefaults;
+    strategies?: PolyRenderStrategiesOption;
+    seamBleed?: PolySeamBleed;
+    seamEdges?: Set<number>;
+}
+/** Internal solid-triangle plan options (extends SolidTrianglePlanOptions). */
+interface InternalSolidTrianglePlanOptions extends SolidTrianglePlanOptions {
+    optimizeStableTriangleStyle?: boolean;
+    stableTriangleColorSteps?: number;
+    stableTriangleMatrixDecimals?: number;
+}
+/** Options accepted by the public {@link computeTextureAtlasPlanPublic} wrapper. */
+interface ComputeTextureAtlasPlanOptions {
+    tileSize?: number;
+    layerElevation?: number;
+    directionalLight?: PolyDirectionalLight;
+    ambientLight?: PolyAmbientLight;
+    /** Shared-edge set returned by {@link buildTextureEdgeRepairSets}. */
+    textureEdgeRepairEdges?: Set<number>;
+    seamBleed?: PolySeamBleed;
+    seamEdges?: Set<number>;
+}
+
+declare function roundDecimal(value: number, decimals: number): string;
+declare function formatCssLength(value: number, decimals?: number): string;
+declare function formatMatrix3dValues(values: readonly number[], decimals?: number): string;
+declare function formatAffineMatrix3dColumns(xCol: Vec3, yCol: Vec3, zCol: Vec3, txCol: Vec3, decimals?: number): string;
+declare function formatAffineMatrix3dScalars(x0: number, x1: number, x2: number, y0: number, y1: number, y2: number, z0: number, z1: number, z2: number, tx0: number, tx1: number, tx2: number, decimals?: number): string;
+declare function formatAffineMatrix3dTransformScalars(x0: number, x1: number, x2: number, y0: number, y1: number, y2: number, z0: number, z1: number, z2: number, tx0: number, tx1: number, tx2: number, decimals?: number): string;
+declare function formatScaledMatrixFromPlan(entry: TextureAtlasPlan, scaleX: number, scaleY: number, offsetX?: number, offsetY?: number): string;
+declare function formatBorderShapeMatrix(entry: TextureAtlasPlan, bounds: BorderShapeBounds): string;
+declare function formatSolidQuadMatrix(entry: TextureAtlasPlan): string;
+declare function formatAtlasMatrix(entry: TextureAtlasPlan, atlasCanonicalSize: number): string;
+declare function formatPercent(value: number, decimals?: number): string;
+/** Format a raw comma-separated matrix3d value string with rounded decimals. */
+declare function formatMatrix3d(matrix: string, decimals?: number): string;
+/** Format a pixel CSS length value. */
+declare function formatCssLengthPx(value: number, decimals?: number): string;
+/**
+ * Produce the CSS matrix3d transform for a solid-quad (`<b>`) leaf, including
+ * the canonical 64px primitive scale.
+ */
+declare function formatSolidQuadEntryMatrix(entry: TextureAtlasPlan): string;
+
+declare function buildTextureEdgeRepairSets(polygons: Polygon[]): Array<Set<number> | undefined>;
+declare function resolveSeamBleed(value: unknown, fallback: number): number;
+declare function normalizedSeamBleed(value: unknown): number | undefined;
+declare function safePlanSeamBleedAmount(screenPts: number[], edgeIndex: number, requested: number): number;
+declare function computePlanSeamBleedEdgeAmounts(screenPts: number[], seamEdges: ReadonlySet<number> | undefined, seamBleed: number | undefined): Map<number, number> | undefined;
+declare function seamBleedAmountArray(vertexCount: number, edgeAmounts: ReadonlyMap<number, number> | undefined): number[] | null;
+declare function computeSeamBleedInsets(screenPts: number[], edgeAmounts: ReadonlyMap<number, number> | undefined): SeamBleedInsets | undefined;
+interface SeamBleedDetectionOptions {
+    tileSize?: number;
+    layerElevation?: number;
+    directionalLight?: unknown;
+    ambientLight?: unknown;
+}
+declare function buildSeamBleedPolygonSet(polygons: Polygon[], options?: SeamBleedDetectionOptions): Set<number>;
+declare function buildSeamBleedPolygonEdges(polygons: Polygon[], options?: SeamBleedDetectionOptions): Map<number, Set<number>>;
+
+type PureColorParseResult = ReturnType<typeof parsePureColor>;
+declare function cachedParsePureColor(input: string): PureColorParseResult;
+declare function parseHex(hex: string): RGB;
+declare function rgbKey({ r, g, b }: RGB): string;
+/** Returns the parsed alpha for a color string (1.0 default). */
+declare function parseAlpha(input: string): number;
+declare function rgbToHex({ r, g, b }: RGB): string;
+declare function textureTintFactors(directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number): RGBFactors;
+declare function tintToCss({ r, g, b }: RGBFactors): string;
+declare function shadePolygon(baseColor: string, directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number): string;
+declare function quantizeCssColor(input: string, steps: number): string;
+declare function rgbEqual(a: RGB | undefined, b: RGB | undefined): boolean;
+declare function stepRgbToward(current: RGB, target: RGB, maxStep: number): RGB;
+declare function rgbToCss(rgb: RGB, alpha?: number): string;
+declare function colorErrorScore(current: string | undefined, next: string): number;
+
+declare function fullRectBounds(entry: TextureAtlasPlan): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+} | null;
+declare function isFullRectSolid(entry: TextureAtlasPlan): boolean;
+declare function isSolidTrianglePlan(entry: TextureAtlasPlan): boolean;
+declare function isProjectiveQuadPlan(entry: TextureAtlasPlan): entry is TextureAtlasPlan & {
+    projectiveMatrix: string;
+};
+declare function safariCssProjectiveUnsupported(userAgent: string): boolean;
+declare function incrementCount(map: Map<string, number>, key: string): void;
+declare function dominantCountKey(map: Map<string, number>): string | undefined;
+interface FilterAtlasPlansEnv {
+    solidTriangleSupported: boolean;
+    borderShapeSupported: boolean;
+}
+/**
+ * Filter a plan array to the subset that needs atlas packing, given the active
+ * render strategies and texture-lighting mode. Plans excluded from the atlas
+ * will be rendered via `<b>`, `<i>`, or `<u>` by the framework components.
+ */
+declare function filterAtlasPlans(plans: Array<TextureAtlasPlan | null>, textureLighting: PolyTextureLightingMode, disabled: ReadonlySet<PolyRenderStrategy>, env: FilterAtlasPlansEnv): Array<TextureAtlasPlan | null>;
+interface GetSolidPaintDefaultsEnv {
+    solidTriangleSupported: boolean;
+    projectiveQuadSupported: boolean;
+    cornerShapeSupported: boolean;
+    borderShapeSupported: boolean;
+}
+declare function getSolidPaintDefaultsForPlansCore(plans: Array<TextureAtlasPlan | null>, textureLighting: PolyTextureLightingMode, disabled: ReadonlySet<PolyRenderStrategy>, env: GetSolidPaintDefaultsEnv, parseHexFn: (color: string) => RGB, rgbKeyFn: (rgb: RGB) => string, cornerShapeGeometryForPlanFn?: (plan: TextureAtlasPlan) => unknown): {
+    paintColor?: string;
+    dynamicColorKey?: string;
+    dynamicColor?: RGB;
+};
+
+declare function cssPoints(vertices: Vec3[], tile: number, elev: number): Vec3[];
+declare function computeSurfaceNormal(pts: Vec3[]): Vec3 | null;
+declare function isConvexPolygonPoints(points: Array<[number, number]>): boolean;
+declare function signedArea2D(points: Array<[number, number]>): number;
+declare function intersect2DLines(a0: [number, number], a1: [number, number], b0: [number, number], b1: [number, number]): [number, number] | null;
+declare function intersect2DLinesRaw(a0x: number, a0y: number, a1x: number, a1y: number, b0x: number, b0y: number, b1x: number, b1y: number): Vec2 | null;
+declare function expandClipPoints(points: number[], amount: number): number[];
+declare function offsetConvexPolygonPoints(points: number[], amount: number): number[];
+declare function offsetConvexPolygonPointsByEdgeAmounts(points: number[], amounts: readonly number[]): number[];
+declare function offsetTrianglePoints(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, amount: number): number[];
+declare function offsetStableTrianglePoints(left: number, right: number, height: number, amount: number): number[];
+declare function stableBasisFromPlan(source: TextureAtlasPlan, polygon: Polygon): StablePlanBasis | null;
+declare function stableTriangleMatrixDecimals(matrixDecimals: number | undefined): number;
+
+declare function polygonContainsPoint(points: Array<[number, number]>, px?: number, py?: number): boolean;
+declare function borderShapeBoundsFromPoints(points: number[], fallbackWidth: number, fallbackHeight: number): BorderShapeBounds;
+declare function borderShapeGeometryForPlan(entry: TextureAtlasPlan): BorderShapeGeometry;
+declare function simplifyCornerShapePoints(points: Array<[number, number]>): Array<[number, number]>;
+declare function cornerShapePointSides([x, y]: [number, number]): Set<CornerShapeSide> | null;
+declare function sharedCornerShapeSide(a: Set<CornerShapeSide>, b: Set<CornerShapeSide>): boolean;
+declare function cornerShapeDiagonal(aPoint: [number, number], aSides: Set<CornerShapeSide>, bPoint: [number, number], bSides: Set<CornerShapeSide>): [CornerShapeCorner, CornerShapeRadius] | null;
+declare function cornerShapeGeometryForPlan(entry: TextureAtlasPlan): CornerShapeGeometry | null;
+declare function cssBorderShapeForGeometry(points: Array<[number, number]>): string;
+declare function cssBorderShapeForPlan(entry: TextureAtlasPlan): string;
+declare function formatBorderShapeEntryMatrix(entry: TextureAtlasPlan): string;
+declare function formatBorderShapeElementStyle(entry: TextureAtlasPlan): string;
+declare function formatCornerShapeElementStyle(entry: TextureAtlasPlan, geometry: CornerShapeGeometry): string;
+
+declare function computeSolidTriangleColorPlanFromNormal(polygon: Polygon, index: number, nx: number, ny: number, nz: number, options: SolidTrianglePlanOptions, includeColor: boolean, colorOverride?: string): SolidTriangleColorPlan;
+declare function computeSolidTriangleColorPlan(polygon: Polygon, index: number, options: SolidTrianglePlanOptions): SolidTriangleColorPlan | null;
+declare function computeSolidTrianglePlan(polygon: Polygon, index: number, options: SolidTrianglePlanOptions, computeOptions?: SolidTriangleComputeOptions): SolidTrianglePlan | null;
+declare function computeSolidTrianglePlanFromCssPoints(polygon: Polygon, index: number, options: SolidTrianglePlanOptions, computeOptions: SolidTriangleComputeOptions, p0x: number, p0y: number, p0z: number, p1x: number, p1y: number, p1z: number, p2x: number, p2y: number, p2z: number): SolidTrianglePlan | null;
+
+declare function resolveProjectiveQuadGuards(overrides: ProjectiveQuadGuardOverrides | undefined): ProjectiveQuadGuardSettings;
+declare function computeProjectiveQuadCoefficients(q: Array<[number, number]>, guards: ProjectiveQuadGuardSettings): ProjectiveQuadCoefficients | null;
+declare function computeProjectiveQuadMatrix(screenPts: number[], xAxis: Vec3, yAxis: Vec3, normal: Vec3, tx: number, ty: number, tz: number, guards: ProjectiveQuadGuardSettings, seamBleedEdgeAmounts?: ReadonlyMap<number, number>): string | null;
+declare function dotVec(a: Vec3, b: Vec3): number;
+declare function crossVec(a: Vec3, b: Vec3): Vec3;
+declare function isBasisOptimizable(polygon: Polygon): boolean;
+declare function getPolygonBasisInfo(polygon: Polygon, tile: number, elev: number): PolygonBasisInfo | null;
+declare function compatibleSurface(a: PolygonBasisInfo | null, b: PolygonBasisInfo | null): boolean;
+declare function compatibleBleedSurface(a: PolygonBasisInfo | null, b: PolygonBasisInfo | null): boolean;
+declare function seamLightBrightness(info: PolygonBasisInfo | null, options: SolidTrianglePlanOptions): number | null;
+declare function basisAxisKey(axis: Vec3): string;
+declare function makeLocalBasis(pts: Vec3[], origin: Vec3, normal: Vec3, rawXAxis: Vec3, options?: {
+    boundsOrigin?: Vec3;
+    snapBounds?: boolean;
+}): LocalBasis | null;
+declare function evaluateIslandAxis(component: number[], infos: Array<PolygonBasisInfo | null>, axis: Vec3, boundsOrigin: Vec3): {
+    pixelArea: number;
+    rawArea: number;
+} | null;
+declare function chooseIslandXAxis(component: number[], infos: Array<PolygonBasisInfo | null>): BasisHint | null;
+declare function buildBasisHints(polygons: Polygon[], options: SolidTrianglePlanOptions): Array<BasisHint | undefined>;
+declare function chooseLocalBasis(pts: Vec3[], origin: Vec3, normal: Vec3, options: BasisOptions): LocalBasis | null;
+declare function isFullRectBasis(basis: LocalBasis): boolean;
+declare function computeUvAffine(points: Vec2[], uvs: Vec2[]): UvAffine | null;
+declare function computeUvSampleRect(uvs: Vec2[]): UvSampleRect | null;
+declare function projectTextureTriangle(triangle: TextureTriangle, tile: number, elev: number, origin: Vec3, xAxis: Vec3, yAxis: Vec3, shiftX: number, shiftY: number): TextureTrianglePlan | null;
+declare function computeTextureAtlasPlan(polygon: Polygon, index: number, options: SolidTrianglePlanOptions, projectiveQuadGuards: ProjectiveQuadGuardSettings, basisHint?: BasisHint): TextureAtlasPlan | null;
+/**
+ * Compute the per-polygon layout plan for one polygon in isolation.
+ *
+ * This is the public single-polygon variant used by React and Vue components.
+ * It does not run the cross-polygon basis-optimisation or seam-detection that
+ * the full `renderPolygonsWithTextureAtlas` pipeline performs, but the
+ * strategy selection (projective-quad, rect, etc.) is identical to the
+ * canonical renderer.
+ *
+ * The `projectiveQuadOverrides` parameter is the pre-resolved override bag
+ * formerly obtained from `doc.defaultView.__polycssProjectiveQuadGuards`.
+ * Callers that have a Document should extract it before calling; callers in
+ * browser-free environments can pass `undefined` for the default guards.
+ */
+declare function computeTextureAtlasPlanPublic(polygon: Polygon, index: number, options?: ComputeTextureAtlasPlanOptions, projectiveQuadOverrides?: ProjectiveQuadGuardOverrides): TextureAtlasPlan | null;
+
+declare function normalizeAtlasScale(scale: number | string | undefined): number;
+declare function atlasArea(pages: PackedPage[]): number;
+declare function autoAtlasScaleCap(pages: PackedPage[], maxDecodedBytes: number): number;
+declare function autoAtlasScale(pages: PackedPage[], maxDecodedBytes: number): number;
+declare function atlasBitmapMaxSide(pages: PackedPage[], atlasScale: number): number;
+declare function atlasDecodedBytes(pages: PackedPage[], atlasScale: number): number;
+declare function autoAtlasBudgetFactor(pages: PackedPage[], atlasScale: number, maxDecodedBytes: number): number;
+/** Returns the max decoded-bytes budget for the given device class. */
+declare function autoAtlasMaxDecodedBytes(isMobile: boolean): number;
+/** Returns the atlas canonical size for the given texture quality and device class. */
+declare function atlasCanonicalSizeForTextureQuality(textureQualityInput: TextureQuality | undefined, isMobile: boolean): number;
+declare function applyPackedAtlasCanonicalSize(packed: PackedAtlas, atlasCanonicalSize: number): PackedAtlas;
+declare function atlasCanonicalSizeForEntry(entry: TextureAtlasPlan): number;
+declare function atlasPadding(atlasScale: number): number;
+declare function packTextureAtlasPlans(plans: Array<TextureAtlasPlan | null>, atlasScale?: number): PackedAtlas;
+/**
+ * Pack atlas plans and resolve atlas scale, accepting a pre-resolved isMobile
+ * boolean instead of a Document reference.
+ */
+declare function packTextureAtlasPlansWithScaleCore(plans: Array<TextureAtlasPlan | null>, textureQualityInput: TextureQuality | undefined, isMobile: boolean): {
+    packed: PackedAtlas;
+    atlasScale: number;
+    atlasCanonicalSize: number;
+};
+
+export { ASYNC_RENDER_BUDGET_MS, ATLAS_CANONICAL_SIZE_AUTO_DESKTOP, ATLAS_CANONICAL_SIZE_EXPLICIT, ATLAS_MAX_SIZE, ATLAS_PADDING, AUTO_ATLAS_LOW_AREA, AUTO_ATLAS_MAX_BITMAP_SIDE, AUTO_ATLAS_MAX_DECODED_BYTES_DESKTOP, AUTO_ATLAS_MAX_DECODED_BYTES_MOBILE, AUTO_ATLAS_MEDIUM_AREA, AUTO_ATLAS_SCALE_GUARD, type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BAKED_SHADOW_MIN_UP, BAKED_SHADOW_Z_SQUASH, BASE_TILE, BASIS_EPS, BORDER_SHAPE_BLEED, BORDER_SHAPE_CANONICAL_SIZE, BORDER_SHAPE_CENTER_PERCENT, BORDER_SHAPE_POINT_EPS, type BasisHint, type BasisOptions, type BorderShapeBounds, type BorderShapeGeometry, type BoxFace, type BoxFaceOptions, type BoxPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, COLOR_PARSE_CACHE_MAX, CORNER_SHAPE_DUPLICATE_EPS, CORNER_SHAPE_POINT_EPS, type CameraCullNormalGroup, type CameraCullRotation, type CameraHandle, type CameraState, type CameraStyleInput, type ComputeTextureAtlasPlanOptions, type ConePolygonsOptions, type CornerShapeCorner, type CornerShapeGeometry, type CornerShapeRadius, type CornerShapeSide, type CoverPlanarPolygonsOptions, type CullInteriorOptions, type CylinderPolygonsOptions, DECIMAL_SCALES, DEFAULT_AMBIENT_COLOR, DEFAULT_AMBIENT_INTENSITY, DEFAULT_ATLAS_CSS_DECIMALS, DEFAULT_BORDER_SHAPE_DECIMALS, DEFAULT_CAMERA_STATE, DEFAULT_LIGHT_COLOR, DEFAULT_LIGHT_DIR, DEFAULT_LIGHT_INTENSITY, DEFAULT_MATRIX_DECIMALS, DEFAULT_PROJECTION, DEFAULT_SEAM_BLEED, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DEFAULT_TILE, type DedupeOverlappingPolygonsOptions, type DodecahedronPolygonsOptions, type FilterAtlasPlansEnv, type GetSolidPaintDefaultsEnv, type GltfParseOptions, type IcosahedronPolygonsOptions, type InternalSolidTrianglePlanOptions, type LoadMeshOptions, type LocalBasis, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, MAX_ATLAS_SCALE, MIN_ATLAS_SCALE, type MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeAnimatedMeshPolygonsOptions, type OptimizeMeshPolygonsOptions, PROJECTIVE_QUAD_BLEED, PROJECTIVE_QUAD_DENOM_EPS, PROJECTIVE_QUAD_MAX_WEIGHT_RATIO, type PackedAtlas, type PackedPage, type PackedTextureAtlasEntry, type PackingPage, type PackingShelf, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParsedColor, type PlanePolygonsOptions, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyDirectionalLight, type PolyMaterial, type PolyRenderStrategiesOption, type PolyRenderStrategy, type PolySeamBleed, type PolySeamBleedEdgeValue, type PolySeamBleedEdges, type PolyTextureAlphaMode, type PolyTextureLightingMode, type PolyTextureWrap, type PolyTextureWrapMode, type PolyVoxelCell, type PolyVoxelSource, type Polygon, type PolygonBasisInfo, type PolygonFace, type ProjectiveQuadCoefficients, type ProjectiveQuadGuardGlobal, type ProjectiveQuadGuardOverrides, type ProjectiveQuadGuardSettings, QUAT_IDENTITY, type Quat, RECT_EPS, type RGB, type RGBFactors, type RectBrush, type RingPolygonsOptions, type RingQuadPolygonsOptions, SEAM_LIGHT_EPS, SOLID_QUAD_CANONICAL_SIZE, SOLID_TRIANGLE_BLEED, SOLID_TRIANGLE_CANONICAL_SIZE, SOLID_TRIANGLE_CORNER_CLASS, SOLID_TRIANGLE_LARGE_BORDER_CANONICAL_SIZE, SOLID_TRIANGLE_LARGE_BORDER_CLASS, SURFACE_DISTANCE_EPS, SURFACE_NORMAL_EPS, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type SeamBleedInsets, type SeamFacetSplitCandidate, type SeamFacetSplitCandidateReason, type SeamFacetSplitOptions, type SeamFacetSplitReport, type SeamOverlapCandidate, type SeamOverlapCandidateKind, type SeamOverlapDiagnostics, type SeamOverlapOptions, type SolidPaintDefaults, type SolidTextureSampleOptions, type SolidTriangleBasis, type SolidTriangleColorPlan, type SolidTriangleComputeOptions, type SolidTriangleFrame, type SolidTrianglePlan, type SolidTrianglePlanOptions, type SolidTrianglePrimitive, type SpherePolygonsOptions, type StablePlanBasis, type StableTriangleColorState, TEXTURE_EDGE_REPAIR_ALPHA_MIN, TEXTURE_EDGE_REPAIR_RADIUS, TEXTURE_EDGE_REPAIR_SOURCE_ALPHA_MIN, TEXTURE_TRIANGLE_BLEED, type TetrahedronPolygonsOptions, type TextureAtlasPage, type TextureAtlasPlan, type TexturePaintMetrics, type TexturePaintMetricsOptions, type TextureQuality, type TextureTriangle, type TextureTrianglePlan, type TorusPolygonsOptions, type UvAffine, type UvSampleRect, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, type Vec2, type Vec3, type VoxParseOptions, applyPackedAtlasCanonicalSize, arrowPolygons, atlasArea, atlasBitmapMaxSide, atlasCanonicalSizeForEntry, atlasCanonicalSizeForTextureQuality, atlasDecodedBytes, atlasPadding, autoAtlasBudgetFactor, autoAtlasMaxDecodedBytes, autoAtlasScale, autoAtlasScaleCap, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, basisAxisKey, borderShapeBoundsFromPoints, borderShapeGeometryForPlan, boxPolygons, buildBakedShadowProjectionMatrix, buildBasisHints, buildSceneContext, buildSeamBleedPolygonEdges, buildSeamBleedPolygonSet, buildTextureEdgeRepairSets, cachedParsePureColor, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, chooseIslandXAxis, chooseLocalBasis, clampChannel, clipPolygonToConvex2D, colorErrorScore, compatibleBleedSurface, compatibleSurface, computePlanSeamBleedEdgeAmounts, computeProjectiveQuadCoefficients, computeProjectiveQuadMatrix, computeSceneBbox, computeSeamBleedInsets, computeShapeLighting, computeSolidTriangleColorPlan, computeSolidTriangleColorPlanFromNormal, computeSolidTrianglePlan, computeSolidTrianglePlanFromCssPoints, computeSurfaceNormal, computeTextureAtlasPlan, computeTextureAtlasPlanPublic, computeTexturePaintMetrics, computeUvAffine, computeUvSampleRect, conePolygons, convexHull2D, cornerShapeDiagonal, cornerShapeGeometryForPlan, cornerShapePointSides, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, crossVec, cssBorderShapeForGeometry, cssBorderShapeForPlan, cssPoints, cullInteriorPolygons, cylinderPolygons, dedupeOverlappingPolygons, dodecahedronPolygons, dominantCountKey, dotVec, ensureCcw2D, eulerXYZFromQuat, evaluateIslandAxis, expandClipPoints, filterAtlasPlans, findOverlappingPolygonDuplicates, formatAffineMatrix3dColumns, formatAffineMatrix3dScalars, formatAffineMatrix3dTransformScalars, formatAtlasMatrix, formatBorderShapeElementStyle, formatBorderShapeEntryMatrix, formatBorderShapeMatrix, formatColor, formatCornerShapeElementStyle, formatCssLength, formatCssLengthPx, formatMatrix3d, formatMatrix3dValues, formatPercent, formatScaledMatrixFromPlan, formatSolidQuadEntryMatrix, formatSolidQuadMatrix, fullRectBounds, getPolygonBasisInfo, getSolidPaintDefaultsForPlansCore, icosahedronPolygons, incrementCount, intersect2DLines, intersect2DLinesRaw, inverseRotateVec3, isAxisAlignedSurfaceNormal, isBakedShadowCaster, isBasisOptimizable, isConvexPolygonPoints, isFullRectBasis, isFullRectSolid, isProjectiveQuadPlan, isSolidTrianglePlan, isVoxelCameraCullableNormalGroups, loadMesh, makeLocalBasis, mergePolygons, normalFacesCamera, normalizeAtlasScale, normalizeInvertMultiplier, normalizePolygons, normalizedSeamBleed, octahedronPolygons, offsetConvexPolygonPoints, offsetConvexPolygonPointsByEdgeAmounts, offsetStableTrianglePoints, offsetTrianglePoints, optimizeAnimatedMeshPolygons, optimizeMeshPolygons, packTextureAtlasPlans, packTextureAtlasPlansWithScaleCore, parseAlpha, parseColor, parseGltf, parseHex, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, planePolygons, polygonContainsPoint, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, polygonSignedArea2D, projectCssVertexToGround, projectTextureTriangle, quantizeCssColor, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, repairMeshSeams, resolveProjectiveQuadGuards, resolveSeamBleed, rgbEqual, rgbKey, rgbToCss, rgbToHex, ringPolygons, ringQuadPolygons, rotateVec3, roundDecimal, safariCssProjectiveUnsupported, safePlanSeamBleedAmount, seamBleedAmountArray, seamFacetSplitPolygons, seamFacetSplitReport, seamLightBrightness, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, shadePolygon, sharedCornerShapeSide, signedArea2D, simplifyCornerShapePoints, spherePolygons, stableBasisFromPlan, stableTriangleMatrixDecimals, stepRgbToward, tetrahedronPolygons, textureTintFactors, tintToCss, torusPolygons };