@glyphcss/core 0.0.1 → 0.0.2

package/dist/index.d.cts

@@ -13,7 +13,7 @@ type MeshResolution = "lossless" | "lossy";
  * 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.
+ * Glyphcss world space convention: +X right, +Y forward, +Z up.
  */
 type Vec3 = [number, number, number];
 /**
@@ -35,7 +35,7 @@ interface TextureTriangle {
  * scene-local coords and does not need to be pre-normalized.
  * Mirrors three.js's `DirectionalLight`.
  */
-interface GlyphcssDirectionalLight {
+interface GlyphDirectionalLight {
     /** Direction the light shines TOWARD (typical convention). */
     direction: Vec3;
     /** Light tint, hex string. White by default. */
@@ -49,7 +49,7 @@ interface GlyphcssDirectionalLight {
  * directional contribution: the two add independently rather than
  * splitting a fixed energy budget.
  */
-interface GlyphcssAmbientLight {
+interface GlyphAmbientLight {
     /** Tint, hex string. White by default. */
     color?: string;
     /** Scalar multiplier on the ambient contribution. Default 0.4. */
@@ -60,7 +60,7 @@ interface GlyphcssAmbientLight {
  *
  * 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, glyphcss 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.
@@ -72,13 +72,13 @@ interface GlyphcssAmbientLight {
 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 glyphcss to dedupe / cache). Caller can
      *  pass a stable string; if omitted, the material's identity is its object
      *  reference. */
     key?: string;
 }
 /**
- * The single polygon type for polycss. N coplanar vertices in 3D space,
+ * The single polygon type for glyphcss. N coplanar vertices in 3D space,
  * CCW winding from outside. No bbox field, no shape discriminator, no
  * input/output distinction — one type, used by parsers, by the merge
  * pass, and by the renderer.
@@ -100,7 +100,7 @@ interface Polygon {
     /**
      * 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, glyphcss uses the direct CSS background-image path (no per-
      * polygon canvas rasterization). Falls back to the atlas path otherwise.
      */
     material?: PolyMaterial;
@@ -273,7 +273,7 @@ declare function polygonFaces(p: Polygon): PolygonFace[];
 
 /**
  * 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 glyphcss mesh
  * wrapper transforms (see `buildTransform` in each PolyMesh implementation).
  *
  * CSS composes `transform: rotateX(rx) rotateY(ry) rotateZ(rz)` as the
@@ -345,7 +345,7 @@ declare function quatFromEulerXYZ(eulerDeg: Vec3): Quat;
 declare function eulerXYZFromQuat(q: Quat): Vec3;
 
 /**
- * Base tile size in CSS pixels. One polycss world unit = BASE_TILE CSS
+ * Base tile size in CSS pixels. One glyphcss world unit = BASE_TILE CSS
  * pixels (pre-scale). Used to convert world-coordinate target values to
  * CSS translations in the transform string.
  */
@@ -360,7 +360,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).
+ * Glyphcss 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
@@ -427,7 +427,7 @@ declare function shadeColor(base: string, delta: number): string;
  * (top-down white directional with intensity 1, white ambient with
  * intensity 0.4) — useful for static SSR/validator renders.
  */
-declare function computeShapeLighting(normal: Vec3, baseColor: string, directional?: GlyphcssDirectionalLight, ambient?: GlyphcssAmbientLight): string;
+declare function computeShapeLighting(normal: Vec3, baseColor: string, directional?: GlyphDirectionalLight, ambient?: GlyphAmbientLight): string;
 
 /**
  * Merge coplanar same-color adjacent triangles into N-vertex polygons.
@@ -632,7 +632,7 @@ declare function cameraCullVisibleSignature(groups: readonly CameraCullNormalGro
  * 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 glyphcss world-space convention
  * (`+X right, +Y forward, +Z up`). Wrap with the framework's PolyMesh /
  * PolyScene equivalent to render.
  */
@@ -665,7 +665,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 glyphcss world space and intended
  * to be wrapped in the framework's PolyMesh equivalent for rendering.
  */
 
@@ -704,7 +704,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 glyphcss world space and intended
  * to be wrapped in the framework's PolyMesh equivalent for rendering.
  */
 
@@ -762,7 +762,7 @@ declare function ringQuadPolygons(options: RingQuadPolygonsOptions): Polygon[];
  * 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
+ * The polygon lives in standard glyphcss world space; wrap it in the
  * framework's PolyMesh equivalent for rendering.
  */
 
@@ -788,7 +788,7 @@ declare function planePolygons(options: PlanePolygonsOptions): Polygon[];
 
 /**
  * Geometry for a small solid-color octahedron — the marker shape used by
- * `GlyphcssDirectionalLightHelper` to indicate where a directional light is
+ * `GlyphDirectionalLightHelper` to indicate where a directional light is
  * shining from. Eight CCW-from-outside triangular faces, vertices at
  * `center ± (size, 0, 0)` etc.
  */
@@ -803,6 +803,956 @@ interface OctahedronPolygonsOptions {
 }
 declare function octahedronPolygons(options: OctahedronPolygonsOptions): Polygon[];
 
+/**
+ * Geometry for a regular tetrahedron — 4 triangular faces. Vertices are
+ * placed at alternating corners of a unit cube so the edge length is uniform.
+ * Scaled so the solid fits inside a sphere of radius `size` (i.e. the
+ * circumradius equals `size`), centered on `center`.
+ */
+
+interface TetrahedronPolygonsOptions {
+    /** Center of the tetrahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all four faces. */
+    color?: string;
+}
+declare function tetrahedronPolygons(options: TetrahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a solid-color cube — 6 square faces, one Polygon per face.
+ * Vertices sit at `center ± (size/2)` on each axis so the edge length equals
+ * `size` and the solid fits in a bounding box of `size × size × size`.
+ */
+
+interface CubePolygonsOptions {
+    /** Center of the cube in world space. */
+    center: Vec3;
+    /** Edge length of the cube. */
+    size: number;
+    /** Fill color applied to all six faces. */
+    color?: string;
+}
+declare function cubePolygons(options: CubePolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a regular dodecahedron — 12 pentagonal faces. Vertices are
+ * the standard golden-ratio form: (±1, ±1, ±1) and the three even
+ * permutations of (0, ±φ, ±1/φ). Scaled so the circumradius equals `size`.
+ *
+ * Vertex ordering (20 total):
+ *   Indices 0–7:  cube corners (±1, ±1, ±1)
+ *   Indices 8–11: (0, ±φ, ±1/φ)
+ *   Indices 12–15: (±1/φ, 0, ±φ)
+ *   Indices 16–19: (±φ, ±1/φ, 0)
+ *
+ * Face table derived from the adjacency graph of the above vertices;
+ * each face is a CCW-from-outside pentagon.
+ */
+
+interface DodecahedronPolygonsOptions {
+    /** Center of the dodecahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all twelve faces. */
+    color?: string;
+}
+declare function dodecahedronPolygons(options: DodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a regular icosahedron — 20 triangular faces. Vertices are
+ * the standard golden-ratio form: (0, ±1, ±φ) and even permutations.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Vertex ordering (12 total):
+ *   Indices 0–3:  (0, ±1, ±φ)
+ *   Indices 4–7:  (±1, ±φ, 0)
+ *   Indices 8–11: (±φ, 0, ±1)
+ *
+ * Face table derived from the adjacency graph of the above vertices;
+ * each face is a CCW-from-outside triangle.
+ */
+
+interface IcosahedronPolygonsOptions {
+    /** Center of the icosahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all twenty faces. */
+    color?: string;
+}
+declare function icosahedronPolygons(options: IcosahedronPolygonsOptions): Polygon[];
+
+/**
+ * Icosphere geometry — a sphere approximated by subdividing an icosahedron's
+ * 20 triangles. At each subdivision level every triangle is split into 4 by
+ * inserting edge midpoints, and every midpoint is projected back onto the
+ * circumscribed sphere of radius `size`. Shared edge midpoints are deduped
+ * with a `Map` keyed on sorted endpoint indices so no seam doubles occur.
+ *
+ * `subdivisions=0` → 20 triangles (bare icosahedron).
+ * `subdivisions=1` → 80 triangles (default).
+ * `subdivisions=2` → 320 triangles.
+ *
+ * Base vertices are the golden-ratio (0, ±1, ±φ) form and cyclic permutations,
+ * matching `icosahedronPolygons.ts`, scaled so circumradius equals `size`.
+ */
+
+interface SpherePolygonsOptions {
+    /** Center of the sphere in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to every surface vertex. */
+    size: number;
+    /** Subdivision level. 0 = icosahedron (20 tri), 1 = 80 tri (default). */
+    subdivisions?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function spherePolygons(options: SpherePolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a closed cylinder aligned to the Y axis. The cylinder is
+ * centered at `center`, with the bottom ring at `y - height/2` and the top
+ * ring at `y + height/2`. The circumference is approximated by `sides`
+ * evenly-spaced vertices.
+ *
+ * Output (sides + 2 polygons):
+ *   - `sides` side quads — each connecting top_i → top_(i+1) → bottom_(i+1) → bottom_i (CCW from outside).
+ *   - 1 top cap N-gon — CCW from +Y. Because the ring is generated going
+ *     counter-clockwise in XZ (increasing θ winds X→+Z), the +Y-outward
+ *     normal requires the REVERSED order.
+ *   - 1 bottom cap N-gon — CCW from −Y. The same generation order (CCW in
+ *     XZ) already produces a −Y-outward normal, so the bottom cap keeps the
+ *     natural ring order.
+ */
+
+interface CylinderPolygonsOptions {
+    /** Center of the cylinder in world space. */
+    center: Vec3;
+    /** Radius of the circular cross-section. */
+    radius: number;
+    /** Total height along the Y axis. */
+    height: number;
+    /** Number of circumference divisions. Defaults to 16. */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function cylinderPolygons(options: CylinderPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a closed cone along the Y axis. The apex sits at
+ * `y + height/2` and the base ring sits at `y - height/2`, relative to
+ * `center`. The base is a regular N-gon with circumradius `radius`.
+ *
+ * Output (sides + 1 polygons):
+ *   - `sides` side triangles — each `[apex, base_(i+1), base_i]` (CCW from outside).
+ *   - 1 base cap N-gon — CCW when viewed from −Y (reversed ring order).
+ */
+
+interface ConePolygonsOptions {
+    /** Center of the cone in world space. */
+    center: Vec3;
+    /** Circumradius of the base circle. */
+    radius: number;
+    /** Total height along the Y axis. */
+    height: number;
+    /** Number of base polygon sides. Defaults to 16. */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function conePolygons(options: ConePolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a torus (donut) centred at `center`, lying in the XZ plane
+ * with the tube axis parallel to Y. Parameterised by:
+ *
+ *   θ = 2π * u / segments  (around the donut ring)
+ *   φ = 2π * v / sides     (around the tube cross-section)
+ *
+ *   x = (majorRadius + minorRadius * cos φ) * cos θ
+ *   y =  minorRadius * sin φ
+ *   z = (majorRadius + minorRadius * cos φ) * sin θ
+ *
+ * Output: `segments × sides` quads, one per (u, v) cell, with modular
+ * index wrap and CCW-from-outside winding.
+ * Default segments=24, sides=12 → 288 quads.
+ */
+
+interface TorusPolygonsOptions {
+    /** Center of the torus in world space. */
+    center: Vec3;
+    /** Distance from the torus center to the center of the tube. */
+    majorRadius: number;
+    /** Radius of the tube cross-section. */
+    minorRadius: number;
+    /** Number of divisions around the donut ring. Defaults to 24. */
+    segments?: number;
+    /** Number of divisions around the tube cross-section. Defaults to 12. */
+    sides?: number;
+    /** Fill color applied to all quads. */
+    color?: string;
+}
+declare function torusPolygons(options: TorusPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a regular N-gonal pyramid along the Y axis. The base polygon
+ * is centred at `y - height/2` with circumradius `radius`; the apex is at
+ * `y + height/2`, both relative to `center`.
+ *
+ * Output (sides + 1 polygons):
+ *   - `sides` side triangles — each `[apex, base_(i+1), base_i]` (CCW from outside).
+ *   - 1 base cap N-gon — CCW when viewed from −Y (reversed ring order).
+ *
+ * Default sides=4 → square pyramid (5 polygons total).
+ */
+
+interface PyramidPolygonsOptions {
+    /** Center of the pyramid in world space. */
+    center: Vec3;
+    /** Circumradius of the base polygon. */
+    radius: number;
+    /** Total height along the Y axis. */
+    height: number;
+    /** Number of base polygon sides. Defaults to 4 (square pyramid). */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function pyramidPolygons(options: PyramidPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a right N-gonal prism aligned to the Y axis. The prism is
+ * centered at `center`, with the bottom cap at `y - height/2` and the top
+ * cap at `y + height/2`. The N-gon cross-section has circumradius `radius`.
+ *
+ * Output (sides + 2 polygons):
+ *   - `sides` side quads — each `[top_i, top_(i+1), bottom_(i+1), bottom_i]` (CCW from outside).
+ *   - 1 top cap N-gon — CCW when viewed from +Y.
+ *   - 1 bottom cap N-gon — CCW when viewed from −Y (reversed ring order).
+ */
+
+interface PrismPolygonsOptions {
+    /** Center of the prism in world space. */
+    center: Vec3;
+    /** Circumradius of the N-gon cross-section. */
+    radius: number;
+    /** Total height along the Y axis. */
+    height: number;
+    /** Number of sides on the N-gon cross-section. Defaults to 6. */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function prismPolygons(options: PrismPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for an N-gonal antiprism aligned to the Y axis. The antiprism is
+ * centered at `center`, with the bottom cap at `y - height/2` and the top
+ * cap at `y + height/2`. The top N-gon is rotated by π/sides relative to the
+ * bottom, and the side strip consists of 2·sides alternating triangles.
+ *
+ * Output (2·sides + 2 polygons):
+ *   - `2 * sides` side triangles — alternating "up" and "down" triangles, CCW from outside.
+ *   - 1 top cap N-gon — CCW when viewed from +Y.
+ *   - 1 bottom cap N-gon — CCW when viewed from −Y (reversed ring order).
+ */
+
+interface AntiprismPolygonsOptions {
+    /** Center of the antiprism in world space. */
+    center: Vec3;
+    /** Circumradius of the N-gon cross-sections. */
+    radius: number;
+    /** Total height along the Y axis. */
+    height: number;
+    /** Number of sides on each N-gon cap. Defaults to 6. */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function antiprismPolygons(options: AntiprismPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for an N-gonal bipyramid (two pyramids glued base-to-base along Y).
+ * The equatorial ring of `sides` vertices lies at y = `center.y`, the top apex
+ * at y = `center.y + halfHeight`, and the bottom apex at y = `center.y - halfHeight`.
+ * `radius` is the circumradius of the equatorial ring.
+ *
+ * Output (2·sides polygons):
+ *   - `sides` upper triangles — each `[topApex, ring_(i+1), ring_i]` (CCW from outside).
+ *   - `sides` lower triangles — each `[bottomApex, ring_i, ring_(i+1)]` (CCW from outside).
+ */
+
+interface BipyramidPolygonsOptions {
+    /** Center of the bipyramid in world space. */
+    center: Vec3;
+    /** Circumradius of the equatorial N-gon ring. */
+    radius: number;
+    /** Half the total height — distance from equator to each apex. */
+    halfHeight: number;
+    /** Number of sides on the equatorial ring. Defaults to 6. */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function bipyramidPolygons(options: BipyramidPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for an N-gonal trapezohedron (kite-faced solid, dual of the N-gonal
+ * antiprism). The solid has `2 * sides` kite (quadrilateral) faces, a top apex
+ * at y = `+halfHeight`, a bottom apex at y = `−halfHeight`, and two interleaved
+ * rings of `sides` vertices each at y = ±`zRing`.
+ *
+ * The belt ring elevation is derived analytically so that every kite face is
+ * exactly planar. Setting zR = halfHeight × (1 − cos(π/sides)) / (1 + cos(π/sides))
+ * is the unique value that places all four vertices of each kite in the same plane
+ * (derived by requiring the fourth vertex to satisfy the plane equation of the
+ * first three).
+ *
+ * The top ring sits at y = +zR; the bottom ring sits at y = −zR, rotated by
+ * π/sides so the two rings interleave like an antiprism.
+ *
+ * Output (2·sides polygons):
+ *   - `sides` upper kites around the top apex (CCW from outside).
+ *   - `sides` lower kites around the bottom apex (CCW from outside).
+ */
+
+interface TrapezohedronPolygonsOptions {
+    /** Center of the trapezohedron in world space. */
+    center: Vec3;
+    /** Circumradius of each belt ring. */
+    radius: number;
+    /** Half the total height — distance from equator to each apex. */
+    halfHeight: number;
+    /** Number of kite faces per hemisphere (= number of antiprism sides). Defaults to 5. */
+    sides?: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function trapezohedronPolygons(options: TrapezohedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a small stellated dodecahedron — Schläfli symbol {5/2, 5}.
+ * 12 pentagram faces on the 12 icosahedron vertices; each pentagram is
+ * decomposed into 5 triangles fanned from the face centroid (60 triangles
+ * total). Using star-polygon faces directly would fan-triangulate into a
+ * convex pentagon; the fan-from-centroid approach produces the correct
+ * 5-pointed-star silhouette.
+ *
+ * Vertices: the 12 standard icosahedron vertices (circumradius = `size`).
+ * Each pentagram face: centroid + 5 outer points picked from the icosahedron
+ * vertex set and ordered angularly in the plane perpendicular to the face
+ * axis; the [0,2,4,1,3] permutation of that angular order produces the
+ * every-other-vertex (pentagram) skip that makes a star.
+ */
+
+interface SmallStellatedDodecahedronPolygonsOptions {
+    /** Center of the polyhedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function smallStellatedDodecahedronPolygons(options: SmallStellatedDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a great dodecahedron — Schläfli symbol {5, 5/2}.
+ * 12 convex pentagonal faces on the 12 icosahedron vertices; each face is the
+ * convex pentagon formed by the 5 nearest vertices to one icosahedron vertex
+ * (same vertex group as the small stellated dodecahedron, but the 5 outer
+ * points are emitted in natural angular order rather than pentagram-skip
+ * order). The rasterizer fan-triangulates convex pentagons correctly from
+ * vertex 0 without any special decomposition.
+ *
+ * Vertices: the 12 standard icosahedron vertices (circumradius = `size`).
+ */
+
+interface GreatDodecahedronPolygonsOptions {
+    /** Center of the polyhedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function greatDodecahedronPolygons(options: GreatDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a great stellated dodecahedron — Schläfli symbol {5/2, 3}.
+ * 12 pentagram faces on the 20 dodecahedron vertices; each pentagram uses
+ * the same 5-vertex grouping as the dodecahedron faces but reordered into
+ * pentagram (every-other-vertex) skip order before being decomposed into
+ * 5 triangles fanned from the face centroid (60 triangles total).
+ *
+ * Vertices: the 20 standard dodecahedron vertices (circumradius = `size`).
+ * Face groups: same 12 pentagonal groupings as dodecahedronPolygons.ts;
+ * the [0,2,4,1,3] permutation of the convex-pentagon order produces the
+ * pentagram skip that makes each face a 5-pointed star.
+ */
+
+interface GreatStellatedDodecahedronPolygonsOptions {
+    /** Center of the polyhedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function greatStellatedDodecahedronPolygons(options: GreatStellatedDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a great icosahedron — Schläfli symbol {3, 5/2}.
+ * 20 triangular faces on the 12 icosahedron vertices in a non-convex
+ * configuration. Each face is derived from the corresponding icosahedron face
+ * by replacing every vertex with its antipode (the diametrically opposite
+ * vertex on the circumscribed sphere), then reversing the winding to restore
+ * CCW orientation (antipode-flipping mirrors the original CCW winding to CW).
+ *
+ * Vertices: the 12 standard icosahedron vertices (circumradius = `size`).
+ * Face table: antipode-flipped icosahedron faces with winding reversed —
+ * yields 20 distinct, non-degenerate triangles with correct outward normals.
+ */
+
+interface GreatIcosahedronPolygonsOptions {
+    /** Center of the polyhedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all faces. */
+    color?: string;
+}
+declare function greatIcosahedronPolygons(options: GreatIcosahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a regular cuboctahedron — 8 triangular faces + 6 square faces
+ * (14 faces total, 12 vertices). Vertices are all permutations of (±1, ±1, 0).
+ * Scaled so the circumradius equals `size`.
+ *
+ * Vertex ordering (12 total):
+ *   Indices 0–3:  (±1, ±1, 0)
+ *   Indices 4–7:  (±1, 0, ±1)
+ *   Indices 8–11: (0, ±1, ±1)
+ *
+ * Face decomposition: 8 equilateral triangles (one per octant) + 6 squares
+ * (one per cube face — edge midpoints of a cube). Each face is CCW-from-outside.
+ */
+
+interface CuboctahedronPolygonsOptions {
+    /** Center of the cuboctahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all fourteen faces. */
+    color?: string;
+}
+declare function cuboctahedronPolygons(options: CuboctahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a regular icosidodecahedron — 20 triangular faces + 12 pentagonal
+ * faces (32 faces total, 30 vertices). Constructed via the edge-midpoint method
+ * from the icosahedron: the 30 vertices are the midpoints of the icosahedron's 30
+ * edges. Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *   20 triangles — one per icosahedron face (3 edge midpoints per face).
+ *   12 pentagons — one per icosahedron vertex (5 incident-edge midpoints per vertex).
+ *
+ * Each face is CCW-from-outside.
+ */
+
+interface IcosidodecahedronPolygonsOptions {
+    /** Center of the icosidodecahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all thirty-two faces. */
+    color?: string;
+}
+declare function icosidodecahedronPolygons(options: IcosidodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated tetrahedron — 4 triangular faces + 4 hexagonal faces
+ * (8 faces total, 12 vertices). Constructed by cutting each corner of a regular
+ * tetrahedron at 1/3 of the edge length from the vertex.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Vertex ordering (12 total):
+ *   For each of the 4 tetrahedron vertices v[i], 3 truncation points are produced
+ *   at p_ij = (2/3)v[i] + (1/3)v[j] for each of the 3 incident edges.
+ *
+ * Face decomposition:
+ *   4 triangles — one per original tetrahedron vertex (corner caps).
+ *   4 hexagons  — one per original tetrahedron face (expanded from triangle to hexagon).
+ *
+ * Each face is CCW-from-outside.
+ */
+
+interface TruncatedTetrahedronPolygonsOptions {
+    /** Center of the truncated tetrahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all eight faces. */
+    color?: string;
+}
+declare function truncatedTetrahedronPolygons(options: TruncatedTetrahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated cube — 8 triangular faces + 6 octagonal faces
+ * (14 faces total, 24 vertices). Constructed by cutting each corner of a unit
+ * cube at depth t = (2 − √2)/2 along each of its 3 incident edges.
+ * This truncation depth produces regular octagons on the original square faces.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *   8 triangles — one per original cube vertex (corner caps).
+ *   6 octagons  — one per original cube face (expanded from square to octagon).
+ *
+ * Each face is CCW-from-outside.
+ */
+
+interface TruncatedCubePolygonsOptions {
+    /** Center of the truncated cube in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all fourteen faces. */
+    color?: string;
+}
+declare function truncatedCubePolygons(options: TruncatedCubePolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated octahedron (permutohedron) — 6 square faces + 8 hexagonal
+ * faces (14 faces total, 24 vertices). Vertices are all permutations of (0, ±1, ±2).
+ * Scaled so the circumradius equals `size`.
+ *
+ * Vertex ordering (24 total):
+ *   All ordered triples using one 0, one ±1, one ±2 (3! × 4 = 24 vertices).
+ *
+ * Face decomposition:
+ *   6 squares  — one per axis direction ±x/±y/±z, lying in the plane where one
+ *                coordinate equals ±2.
+ *   8 hexagons — one per octant normal (±1,±1,±1); vertices satisfy x+y+z = ±3
+ *                (for all-positive/all-negative octants) or mixed-sign combinations.
+ *
+ * Each face is CCW-from-outside.
+ */
+
+interface TruncatedOctahedronPolygonsOptions {
+    /** Center of the truncated octahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all fourteen faces. */
+    color?: string;
+}
+declare function truncatedOctahedronPolygons(options: TruncatedOctahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated dodecahedron — 20 triangular faces + 12 decagonal
+ * faces (32 faces total, 60 vertices). Constructed by truncating each vertex of
+ * a regular dodecahedron at parameter t = (3 − √5)/4 ≈ 0.191, the fraction along
+ * each incident edge that produces regular decagons on the original pentagonal faces.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *   20 triangles — one per truncated dodecahedron vertex (corner caps).
+ *   12 decagons  — one per original dodecahedron face (expanded pentagon → decagon).
+ *
+ * Each face is CCW-from-outside.
+ */
+
+interface TruncatedDodecahedronPolygonsOptions {
+    /** Center of the truncated dodecahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all thirty-two faces. */
+    color?: string;
+}
+declare function truncatedDodecahedronPolygons(options: TruncatedDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated icosahedron (soccer ball / Buckminster fullerene) —
+ * 12 pentagonal faces + 20 hexagonal faces (32 faces total, 60 vertices).
+ * Constructed by truncating each vertex of a regular icosahedron at t = 1/3
+ * (the unique rational truncation fraction for Archimedean solids — makes the
+ * hexagons regular). Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *   12 pentagons — one per icosahedron vertex (5 truncation points on incident edges).
+ *   20 hexagons  — one per icosahedron face (6 truncation points around each triangle).
+ *
+ * Each face is CCW-from-outside.
+ */
+
+interface TruncatedIcosahedronPolygonsOptions {
+    /** Center of the truncated icosahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all thirty-two faces. */
+    color?: string;
+}
+declare function truncatedIcosahedronPolygons(options: TruncatedIcosahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated cuboctahedron (great rhombicuboctahedron) —
+ * 12 square faces + 8 hexagonal faces + 6 octagonal faces (26 faces total,
+ * 48 vertices). Vertices are all distinct ordered permutations of
+ * (±1, ±(1+√2), ±(1+2√2)) — 3! orderings × 2³ sign combinations = 48 vertices.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *   12 squares  — one per edge of the parent cuboctahedron.
+ *    8 hexagons — one per triangular face of the parent cuboctahedron.
+ *    6 octagons — one per square face of the parent cuboctahedron.
+ *
+ * Faces discovered via edge-graph enumeration (all planar, outward-facing
+ * cycles of length 4, 6, 8). Each face is CCW-from-outside.
+ */
+
+interface TruncatedCuboctahedronPolygonsOptions {
+    /** Center of the truncated cuboctahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all twenty-six faces. */
+    color?: string;
+}
+declare function truncatedCuboctahedronPolygons(options: TruncatedCuboctahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a truncated icosidodecahedron (great rhombicosidodecahedron) —
+ * 30 square faces + 20 hexagonal faces + 12 decagonal faces (62 faces total,
+ * 120 vertices). Vertices are all even-permutation (cyclic) sign combinations
+ * of five base triples involving the golden ratio φ = (1+√5)/2.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Vertex construction: 5 base triples × 3 cyclic permutations × 8 sign
+ * combinations = 120 vertices. All lie on a common sphere.
+ *
+ * Face decomposition:
+ *   30 squares   — one per edge of the parent icosidodecahedron.
+ *   20 hexagons  — one per triangular face of the parent icosidodecahedron.
+ *   12 decagons  — one per pentagonal face of the parent icosidodecahedron.
+ *
+ * Faces discovered via edge-graph enumeration (planar, outward-facing cycles of
+ * length 4, 6, 10). Each face is CCW-from-outside.
+ */
+
+interface TruncatedIcosidodecahedronPolygonsOptions {
+    /** Center of the truncated icosidodecahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all sixty-two faces. */
+    color?: string;
+}
+declare function truncatedIcosidodecahedronPolygons(options: TruncatedIcosidodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a rhombicuboctahedron — 8 triangular faces + 18 square faces
+ * (26 faces total, 24 vertices). Vertices are all permutations of
+ * (±1, ±1, ±(1+√2)) — 3 axis choices × 8 sign combinations = 24 vertices.
+ * Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *    8 triangles — the 8 corner faces (one per octant).
+ *   18 squares   — 6 axial squares + 12 edge squares.
+ *
+ * Faces discovered via edge-graph enumeration (planar, outward-facing cycles of
+ * length 3 and 4). Each face is CCW-from-outside.
+ */
+
+interface RhombicuboctahedronPolygonsOptions {
+    /** Center of the rhombicuboctahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all twenty-six faces. */
+    color?: string;
+}
+declare function rhombicuboctahedronPolygons(options: RhombicuboctahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a rhombicosidodecahedron — 20 triangular faces + 30 square faces
+ * + 12 pentagonal faces (62 faces total, 60 vertices). Vertices fall into three
+ * families of cyclic-permutation + sign-combination groups:
+ *
+ *   (±1, ±1, ±φ³)              — 3 cyclic perms × 8 signs = 24 vertices
+ *   (±φ², ±φ, ±2φ)             — 3 cyclic perms × 8 signs = 24 vertices
+ *   (±(2+φ), 0, ±φ²)           — 3 cyclic perms × 4 signs = 12 vertices
+ *
+ * where φ = (1+√5)/2. Total: 60 vertices. Scaled so the circumradius equals `size`.
+ *
+ * Face decomposition:
+ *   20 triangles — corner faces (one per icosahedron vertex).
+ *   30 squares   — edge faces (one per icosahedron edge).
+ *   12 pentagons — cap faces (one per dodecahedron face).
+ *
+ * Faces discovered via edge-graph enumeration (planar, outward-facing cycles of
+ * length 3, 4, 5). Each face is CCW-from-outside.
+ */
+
+interface RhombicosidodecahedronPolygonsOptions {
+    /** Center of the rhombicosidodecahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all sixty-two faces. */
+    color?: string;
+}
+declare function rhombicosidodecahedronPolygons(options: RhombicosidodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a snub cube — 32 triangular faces + 6 square faces (38 faces
+ * total, 24 vertices). This is a chiral Archimedean solid; the right-handed
+ * enantiomorph is produced here (see chirality note below).
+ *
+ * The 24 vertices involve the tribonacci constant t ≈ 1.83929, the real root of
+ * t³ = t² + t + 1. The vertex set is:
+ *   - even cyclic permutations of (±1, ±1/t, ±t) with an even number of minuses, AND
+ *   - odd (anti-cyclic) permutations of (±1, ±1/t, ±t) with an odd number of minuses.
+ *
+ * Chirality: the right-handed convention is fixed by the choice of
+ * "even-perm × even-sign + odd-perm × odd-sign" — the alternative pairing
+ * produces the left-handed mirror image.
+ *
+ * Face decomposition:
+ *   32 triangles — 8 sets of 4 snub triangles (filling the gaps between squares).
+ *    6 squares   — one per face of the parent cube.
+ *
+ * Faces discovered via edge-graph enumeration (planar, outward-facing cycles of
+ * length 3 and 4). Each face is CCW-from-outside.
+ */
+
+interface SnubCubePolygonsOptions {
+    /** Center of the snub cube in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all thirty-eight faces. */
+    color?: string;
+}
+declare function snubCubePolygons(options: SnubCubePolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a snub dodecahedron — 80 triangular faces + 12 pentagonal faces
+ * (92 faces total, 60 vertices). This is a chiral Archimedean solid; the
+ * right-handed enantiomorph is produced here.
+ *
+ * Construction (numerical snub operation on the icosahedron):
+ * For each of the 60 directed icosahedron edges (i→j), one snub vertex is placed at:
+ *
+ *   v_ij = normalise((1−t)·ico[i] + t·ico[j] + s·normalise(ico[i] × ico[j]))
+ *
+ * where t ≈ 0.3554 and s ≈ 0.1342 are the unique snub parameters satisfying two
+ * simultaneous conditions:
+ *   (a) inner-triangle edge length = cross-edge length (v_ij to v_ji)
+ *   (b) inner-triangle edge length = pentagon edge length (v_ij to v_ik for adjacent k)
+ *
+ * These parameters are solved numerically via Newton's method to machine precision.
+ * All 60 vertices lie exactly on the unit sphere before scaling.
+ *
+ * Chirality: the right-handed enantiomorph is produced. The chirality is fixed
+ * by the sign of the s component: positive s causes the snub vertices to be
+ * displaced in the direction of ico[i] × ico[j] (the right-hand cross product).
+ * The opposite sign produces the left-handed mirror image.
+ *
+ * Face decomposition:
+ *   80 triangles — inner snub triangles (one per icosahedron face) plus outer
+ *                  snub triangles connecting adjacent face pairs.
+ *   12 pentagons — one per icosahedron vertex (5 snub vertices surrounding each).
+ *
+ * Faces discovered via edge-graph enumeration (planar, outward-facing cycles of
+ * length 3 and 5). Each face is CCW-from-outside.
+ */
+
+interface SnubDodecahedronPolygonsOptions {
+    /** Center of the snub dodecahedron in world space. */
+    center: Vec3;
+    /** Circumradius — distance from center to each vertex. */
+    size: number;
+    /** Fill color applied to all ninety-two faces. */
+    color?: string;
+}
+declare function snubDodecahedronPolygons(options: SnubDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a rhombic dodecahedron — 12 rhombic faces (24 vertices of the dual).
+ * The dual of the cuboctahedron.
+ */
+
+interface RhombicDodecahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function rhombicDodecahedronPolygons(options: RhombicDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a rhombic triacontahedron — 30 rhombic faces.
+ * The dual of the icosidodecahedron.
+ */
+
+interface RhombicTriacontahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function rhombicTriacontahedronPolygons(options: RhombicTriacontahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a triakis tetrahedron — 12 isosceles-triangle faces.
+ * The dual of the truncated tetrahedron.
+ */
+
+interface TriakisTetrahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function triakisTetrahedronPolygons(options: TriakisTetrahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a triakis octahedron — 24 isosceles-triangle faces.
+ * The dual of the truncated cube.
+ */
+
+interface TriakisOctahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function triakisOctahedronPolygons(options: TriakisOctahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a tetrakis hexahedron — 24 isosceles-triangle faces.
+ * The dual of the truncated octahedron.
+ */
+
+interface TetrakisHexahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function tetrakisHexahedronPolygons(options: TetrakisHexahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a triakis icosahedron — 60 isosceles-triangle faces.
+ * The dual of the truncated dodecahedron.
+ */
+
+interface TriakisIcosahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function triakisIcosahedronPolygons(options: TriakisIcosahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a pentakis dodecahedron — 60 isosceles-triangle faces.
+ * The dual of the truncated icosahedron.
+ */
+
+interface PentakisDodecahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function pentakisDodecahedronPolygons(options: PentakisDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a disdyakis dodecahedron — 48 scalene-triangle faces.
+ * The dual of the truncated cuboctahedron.
+ */
+
+interface DisdyakisDodecahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function disdyakisDodecahedronPolygons(options: DisdyakisDodecahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a disdyakis triacontahedron — 120 scalene-triangle faces.
+ * The dual of the truncated icosidodecahedron.
+ */
+
+interface DisdyakisTriacontahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function disdyakisTriacontahedronPolygons(options: DisdyakisTriacontahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a deltoidal icositetrahedron — 24 kite faces.
+ * The dual of the rhombicuboctahedron.
+ */
+
+interface DeltoidalIcositetrahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function deltoidalIcositetrahedronPolygons(options: DeltoidalIcositetrahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a deltoidal hexecontahedron — 60 kite faces.
+ * The dual of the rhombicosidodecahedron.
+ */
+
+interface DeltoidalHexecontahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function deltoidalHexecontahedronPolygons(options: DeltoidalHexecontahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a pentagonal icositetrahedron — 24 irregular-pentagon faces.
+ * The dual of the snub cube.
+ */
+
+interface PentagonalIcositetrahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function pentagonalIcositetrahedronPolygons(options: PentagonalIcositetrahedronPolygonsOptions): Polygon[];
+
+/**
+ * Geometry for a pentagonal hexecontahedron — 60 irregular-pentagon faces.
+ * The dual of the snub dodecahedron.
+ */
+
+interface PentagonalHexecontahedronPolygonsOptions {
+    center: Vec3;
+    size: number;
+    color?: string;
+}
+declare function pentagonalHexecontahedronPolygons(options: PentagonalHexecontahedronPolygonsOptions): Polygon[];
+
+type GlyphGeometryName = "tetrahedron" | "cube" | "octahedron" | "dodecahedron" | "icosahedron" | "smallStellatedDodecahedron" | "greatDodecahedron" | "greatStellatedDodecahedron" | "greatIcosahedron" | "cuboctahedron" | "icosidodecahedron" | "truncatedTetrahedron" | "truncatedCube" | "truncatedOctahedron" | "truncatedDodecahedron" | "truncatedIcosahedron" | "truncatedCuboctahedron" | "truncatedIcosidodecahedron" | "rhombicuboctahedron" | "rhombicosidodecahedron" | "snubCube" | "snubDodecahedron" | "rhombicDodecahedron" | "rhombicTriacontahedron" | "triakisTetrahedron" | "triakisOctahedron" | "triakisIcosahedron" | "tetrakisHexahedron" | "pentakisDodecahedron" | "disdyakisDodecahedron" | "disdyakisTriacontahedron" | "deltoidalIcositetrahedron" | "deltoidalHexecontahedron" | "pentagonalIcositetrahedron" | "pentagonalHexecontahedron" | "sphere" | "cylinder" | "cone" | "torus" | "pyramid" | "prism" | "antiprism" | "bipyramid" | "trapezohedron";
+interface GlyphGeometryOptions {
+    center?: Vec3;
+    size?: number;
+    color?: string;
+}
+/**
+ * Resolve a built-in geometry name to a `Polygon[]` list.
+ *
+ * Precedence for mesh sources: explicit `polygons` > `src` > `geometry`.
+ * When both `src` and `geometry` are supplied, `src` wins silently.
+ */
+declare function resolveGeometry(name: GlyphGeometryName, opts?: GlyphGeometryOptions): Polygon[];
+
 /**
  * Unified parser return type. All polygon-emitting parsers (parseObj,
  * parseGltf, the loadMesh dispatcher) return this exact shape.
@@ -835,7 +1785,7 @@ interface ParseAnimationController {
     sample: (clip: number | string, timeSeconds: number) => Polygon[];
 }
 interface ParseResult {
-    /** The mesh, as a flat polygon list. Already vertex-permuted to polycss space. */
+    /** The mesh, as a flat polygon list. Already vertex-permuted to glyphcss space. */
     polygons: Polygon[];
     /** Optional animation sampler for formats that carry timeline data. */
     animation?: ParseAnimationController;
@@ -872,7 +1822,7 @@ interface ParseResult {
 }
 
 /**
- * GlyphcssAnimationMixer — three.js-shaped animation API for glyphcss.
+ * GlyphAnimationMixer — three.js-shaped animation API for glyphcss.
  *
  * Mirrors three.js's AnimationMixer + AnimationAction surface closely enough
  * that users familiar with drei's `useAnimations` can migrate without friction.
@@ -887,44 +1837,44 @@ declare const LoopPingPong: 2202;
 type LoopMode = typeof LoopOnce | typeof LoopRepeat | typeof LoopPingPong;
 
 /**
- * Minimal target interface the mixer requires. `GlyphcssMeshHandle` from both
+ * Minimal target interface the mixer requires. `GlyphMeshHandle` from both
  * the glyphcss vanilla API and the React/Vue frameworks satisfies this
  * structurally — no import needed.
  */
-interface GlyphcssAnimationTarget {
+interface GlyphAnimationTarget {
     setPolygons(polygons: Polygon[]): void;
 }
 /**
  * Per-clip playback action. Mirrors three.js `AnimationAction` method surface.
  * All mutating methods return `this` for chaining.
  */
-interface GlyphcssAnimationAction {
+interface GlyphAnimationAction {
     /** Start playing (sets weight=1, resets time if not already playing). */
-    play(): GlyphcssAnimationAction;
+    play(): GlyphAnimationAction;
     /** Stop playing and reset time to 0. */
-    stop(): GlyphcssAnimationAction;
+    stop(): GlyphAnimationAction;
     /** Reset time to 0 without stopping. */
-    reset(): GlyphcssAnimationAction;
+    reset(): GlyphAnimationAction;
     /** Fade weight from 0 to 1 over `durationSeconds`. */
-    fadeIn(durationSeconds: number): GlyphcssAnimationAction;
+    fadeIn(durationSeconds: number): GlyphAnimationAction;
     /** Fade weight from current to 0 over `durationSeconds`. */
-    fadeOut(durationSeconds: number): GlyphcssAnimationAction;
+    fadeOut(durationSeconds: number): GlyphAnimationAction;
     /**
      * Cross-fade from this action to `target` over `durationSeconds`.
      * Fades this out and target in simultaneously.
      */
-    crossFadeTo(target: GlyphcssAnimationAction, durationSeconds: number): GlyphcssAnimationAction;
+    crossFadeTo(target: GlyphAnimationAction, durationSeconds: number): GlyphAnimationAction;
     /**
      * Cross-fade from `from` into this action over `durationSeconds`.
      * Sugar for `from.fadeOut(d); this.fadeIn(d)`.
      */
-    crossFadeFrom(from: GlyphcssAnimationAction, durationSeconds: number): GlyphcssAnimationAction;
+    crossFadeFrom(from: GlyphAnimationAction, durationSeconds: number): GlyphAnimationAction;
     /** Set loop mode and repetition count. */
-    setLoop(mode: LoopMode, repetitions: number): GlyphcssAnimationAction;
+    setLoop(mode: LoopMode, repetitions: number): GlyphAnimationAction;
     /** Override the effective time scale. */
-    setEffectiveTimeScale(scale: number): GlyphcssAnimationAction;
+    setEffectiveTimeScale(scale: number): GlyphAnimationAction;
     /** Override the effective weight. */
-    setEffectiveWeight(weight: number): GlyphcssAnimationAction;
+    setEffectiveWeight(weight: number): GlyphAnimationAction;
     /** When true, the action freezes on the last frame after finishing. */
     clampWhenFinished: boolean;
     /** Playback speed multiplier. Default 1. */
@@ -947,20 +1897,20 @@ interface GlyphcssAnimationAction {
     readonly isRunning: boolean;
 }
 /**
- * Drives one or more `GlyphcssAnimationAction`s against a single mesh target.
+ * Drives one or more `GlyphAnimationAction`s against a single mesh target.
  * Mirrors the three.js `AnimationMixer` API.
  */
-interface GlyphcssAnimationMixer {
+interface GlyphAnimationMixer {
     /**
      * Return the action for a clip (by index or name). Creates the action if it
      * doesn't exist yet (lazy instantiation, same as three.js).
      */
-    clipAction(clip: number | string): GlyphcssAnimationAction;
+    clipAction(clip: number | string): GlyphAnimationAction;
     /**
      * Return an existing action without creating one. Returns null if the
      * action hasn't been instantiated yet.
      */
-    existingAction(clip: number | string): GlyphcssAnimationAction | null;
+    existingAction(clip: number | string): GlyphAnimationAction | null;
     /**
      * Advance all active actions by `deltaSeconds` and apply the resulting
      * polygon frame to the root target. Call this once per animation frame.
@@ -973,7 +1923,7 @@ interface GlyphcssAnimationMixer {
     /** Remove all cached actions for this mixer's root. */
     uncacheRoot(): void;
 }
-declare function createGlyphcssAnimationMixer(root: GlyphcssAnimationTarget, controller: ParseAnimationController): GlyphcssAnimationMixer;
+declare function createGlyphAnimationMixer(root: GlyphAnimationTarget, controller: ParseAnimationController): GlyphAnimationMixer;
 
 interface ObjParseOptions {
     /**
@@ -1065,7 +2015,7 @@ interface GltfParseOptions {
     /**
      * 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 glyphcss'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.
@@ -1178,4 +2128,4 @@ declare function project(v: Vec3, cols: number, rows: number, cellAspect: number
 /** Public: derive feature edges from a triangle list. `featureAngleDeg = 0` = all edges. */
 declare function trianglesToFeatureEdges(triangles: TextureTriangle[], featureAngleDeg?: number): WireframeEdge[];
 
-export { type ApproximateMergeOptions, type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BASE_TILE, CAMERA_BACKFACE_CULL_EPS, type CameraCullNormalGroup, type CameraCullRotation, type CameraHandle, type CameraState, type CameraStyleInput, type CharRamp, type CoverPlanarPolygonsOptions, type CullInteriorOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, type DedupeOverlappingPolygonsOptions, type EdgeWeight, type GltfParseOptions, type GlyphcssAmbientLight, type GlyphcssAnimationAction, type ParseAnimationClip as GlyphcssAnimationClip, type GlyphcssAnimationMixer, type GlyphcssAnimationTarget, type GlyphcssDirectionalLight, type GridSize, type Hotspot, type HotspotCell, type LoadMeshOptions, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, type MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeMeshPolygonsOptions, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParsedColor, type PlanePolygonsOptions, type Polygon, type PolygonFace, QUAT_IDENTITY, type Quat, type RenderMode, type RingPolygonsOptions, type RingQuadPolygonsOptions, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type SolidTextureSampleOptions, type TextureTriangle, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, type Vec2, type Vec3, type VoxParseOptions, type WireframeEdge, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, coverPlanarPolygons, createGlyphcssAnimationMixer, createIsometricCamera, cullInteriorPolygons, dedupeOverlappingPolygons, eulerXYZFromQuat, findOverlappingPolygonDuplicates, formatColor, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, project, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, ringPolygons, ringQuadPolygons, rotateVec3, shadeColor, trianglesToFeatureEdges };
+export { type AntiprismPolygonsOptions, type ApproximateMergeOptions, type ArrowPolygonsOptions, type AutoRotateConfig, type AutoRotateOption, type AxesHelperOptions, BASE_TILE, type BipyramidPolygonsOptions, CAMERA_BACKFACE_CULL_EPS, type CameraCullNormalGroup, type CameraCullRotation, type CameraHandle, type CameraState, type CameraStyleInput, type CharRamp, type ConePolygonsOptions, type CoverPlanarPolygonsOptions, type CubePolygonsOptions, type CuboctahedronPolygonsOptions, type CullInteriorOptions, type CylinderPolygonsOptions, DEFAULT_CAMERA_STATE, DEFAULT_PROJECTION, type DedupeOverlappingPolygonsOptions, type DeltoidalHexecontahedronPolygonsOptions, type DeltoidalIcositetrahedronPolygonsOptions, type DisdyakisDodecahedronPolygonsOptions, type DisdyakisTriacontahedronPolygonsOptions, type DodecahedronPolygonsOptions, type EdgeWeight, type GltfParseOptions, type GlyphAmbientLight, type GlyphAnimationAction, type ParseAnimationClip as GlyphAnimationClip, type GlyphAnimationMixer, type GlyphAnimationTarget, type GlyphDirectionalLight, type GlyphGeometryName, type GlyphGeometryOptions, type GreatDodecahedronPolygonsOptions, type GreatIcosahedronPolygonsOptions, type GreatStellatedDodecahedronPolygonsOptions, type GridSize, type Hotspot, type HotspotCell, type IcosahedronPolygonsOptions, type IcosidodecahedronPolygonsOptions, type LoadMeshOptions, type LoopMode, LoopOnce, LoopPingPong, LoopRepeat, type MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeMeshPolygonsOptions, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParsedColor, type PentagonalHexecontahedronPolygonsOptions, type PentagonalIcositetrahedronPolygonsOptions, type PentakisDodecahedronPolygonsOptions, type PlanePolygonsOptions, type Polygon, type PolygonFace, type PrismPolygonsOptions, type PyramidPolygonsOptions, QUAT_IDENTITY, type Quat, type RenderMode, type RhombicDodecahedronPolygonsOptions, type RhombicTriacontahedronPolygonsOptions, type RhombicosidodecahedronPolygonsOptions, type RhombicuboctahedronPolygonsOptions, type RingPolygonsOptions, type RingQuadPolygonsOptions, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type SmallStellatedDodecahedronPolygonsOptions, type SnubCubePolygonsOptions, type SnubDodecahedronPolygonsOptions, type SolidTextureSampleOptions, type SpherePolygonsOptions, type TetrahedronPolygonsOptions, type TetrakisHexahedronPolygonsOptions, type TextureTriangle, type TorusPolygonsOptions, type TrapezohedronPolygonsOptions, type TriakisIcosahedronPolygonsOptions, type TriakisOctahedronPolygonsOptions, type TriakisTetrahedronPolygonsOptions, type TruncatedCubePolygonsOptions, type TruncatedCuboctahedronPolygonsOptions, type TruncatedDodecahedronPolygonsOptions, type TruncatedIcosahedronPolygonsOptions, type TruncatedIcosidodecahedronPolygonsOptions, type TruncatedOctahedronPolygonsOptions, type TruncatedTetrahedronPolygonsOptions, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, type Vec2, type Vec3, type VoxParseOptions, type WireframeEdge, antiprismPolygons, arrowPolygons, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, bipyramidPolygons, buildSceneContext, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, clampChannel, computeSceneBbox, computeShapeLighting, conePolygons, coverPlanarPolygons, createGlyphAnimationMixer, createIsometricCamera, cubePolygons, cuboctahedronPolygons, cullInteriorPolygons, cylinderPolygons, dedupeOverlappingPolygons, deltoidalHexecontahedronPolygons, deltoidalIcositetrahedronPolygons, disdyakisDodecahedronPolygons, disdyakisTriacontahedronPolygons, dodecahedronPolygons, eulerXYZFromQuat, findOverlappingPolygonDuplicates, formatColor, greatDodecahedronPolygons, greatIcosahedronPolygons, greatStellatedDodecahedronPolygons, icosahedronPolygons, icosidodecahedronPolygons, inverseRotateVec3, isAxisAlignedSurfaceNormal, isVoxelCameraCullableNormalGroups, loadMesh, mergePolygons, normalFacesCamera, normalizeInvertMultiplier, normalizePolygons, octahedronPolygons, optimizeMeshPolygons, parseColor, parseGltf, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseVox, pentagonalHexecontahedronPolygons, pentagonalIcositetrahedronPolygons, pentakisDodecahedronPolygons, planePolygons, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, prismPolygons, project, pyramidPolygons, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, resolveGeometry, rhombicDodecahedronPolygons, rhombicTriacontahedronPolygons, rhombicosidodecahedronPolygons, rhombicuboctahedronPolygons, ringPolygons, ringQuadPolygons, rotateVec3, shadeColor, smallStellatedDodecahedronPolygons, snubCubePolygons, snubDodecahedronPolygons, spherePolygons, tetrahedronPolygons, tetrakisHexahedronPolygons, torusPolygons, trapezohedronPolygons, triakisIcosahedronPolygons, triakisOctahedronPolygons, triakisTetrahedronPolygons, trianglesToFeatureEdges, truncatedCubePolygons, truncatedCuboctahedronPolygons, truncatedDodecahedronPolygons, truncatedIcosahedronPolygons, truncatedIcosidodecahedronPolygons, truncatedOctahedronPolygons, truncatedTetrahedronPolygons };