@layoutit/polycss-core 0.2.6 → 0.2.8

package/dist/index.d.cts

@@ -1,206 +1,5 @@
-declare const DEFAULT_PROJECTION: "cubic";
-/**
- * How polygon lighting is applied by DOM renderers.
- * - "baked": multiply the light tint into the off-DOM canvas before the
- *   polygon becomes an atlas sprite. Best fidelity (full RGB tint) but
- *   the atlas re-rasterizes whenever the light changes.
- * - "dynamic": lighting computed entirely in CSS via per-polygon normals
- *   embedded in calc() and scene-root light vars (background-color +
- *   background-blend-mode multiply, masked by the atlas alpha). Atlas
- *   stays light-independent — sliding the light only writes a few CSS
- *   variables, no JS work, no atlas re-rasterization.
- */
-type PolyTextureLightingMode = "baked" | "dynamic";
-type PolyTextureLeafSizing = "canonical" | "local" | "raster";
-type PolyTextureBackend = "auto" | "atlas" | "image";
-type PolyTextureImageRendering = "auto" | "pixelated";
-type PolyTextureImageLighting = "scene" | "source";
-type PolyTextureProjection = "affine" | "projective";
-interface PolyTextureImageSource {
-    url: string;
-    width: number;
-    height: number;
-    sourceRect?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    imageRendering?: PolyTextureImageRendering;
-}
-interface PolyTexturePresentation {
-    imageRendering?: PolyTextureImageRendering;
-    backend?: PolyTextureBackend;
-    lighting?: PolyTextureImageLighting;
-    projection?: PolyTextureProjection;
-}
-/**
- * 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.
- */
-type Vec3 = [number, number, number];
-/**
- * 2D point/vector — `[u, v]`. Used for texture-atlas UV coordinates on
- * polygons. Convention follows OBJ: u is horizontal (0=left, 1=right),
- * v is vertical (0=bottom, 1=top). Renderers flip v when binding to raster
- * image space whose Y-axis points down.
- */
-type Vec2 = [number, number];
-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
- * scene-local CSS-pixel coords and does not need to be pre-normalized.
- * Mirrors three.js's `DirectionalLight`.
- */
-interface PolyDirectionalLight {
-    /** Direction the light shines TOWARD (typical convention). */
-    direction: Vec3;
-    /** Light tint, hex string. White by default. */
-    color?: string;
-    /** Scalar multiplier on the directional contribution. Default 1. */
-    intensity?: number;
-}
-/**
- * Ambient light — uniform fill that adds to every polygon regardless of
- * orientation. Mirrors three.js's `AmbientLight`. Decoupled from the
- * directional contribution: the two add independently rather than
- * splitting a fixed energy budget.
- */
-interface PolyAmbientLight {
-    /** Tint, hex string. White by default. */
-    color?: string;
-    /** Scalar multiplier on the ambient contribution. Default 0.4. */
-    intensity?: number;
-}
-/**
- * Material — paint configuration shareable across many polygons.
- *
- * 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
- * `background-image: url(material.texture)` directly — no per-polygon canvas
- * rasterization, browser-cached texture, mounting / unmounting one polygon
- * does not affect any other.
- *
- * Three.js parallel: combines THREE.Texture + a basic Material in one. CSS
- * has no shader/sampler concerns, so the texture/material split from
- * Three.js doesn't pay rent here.
- */
-interface PolyMaterial {
-    /** Image source. Anything `background-image: url(...)` can use. */
-    texture: string;
-    /** 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;
-    imageSource?: PolyTextureImageSource;
-    presentation?: PolyTexturePresentation;
-}
-/**
- * The single polygon type for polycss. 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.
- */
-interface Polygon {
-    /** N coplanar vertices in 3D space, CCW winding from outside. */
-    vertices: Vec3[];
-    /**
-     * Solid base color. Falls back to "#cccccc" when neither color nor
-     * texture is set.
-     */
-    color?: string;
-    /**
-     * Texture URL. When set with `uvs`, UV-mapped via affine; without
-     * `uvs`, single-tile fill. If the load fails, renderer falls back to
-     * `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-
-     * polygon canvas rasterization). Falls back to the atlas path otherwise.
-     */
-    material?: PolyMaterial;
-    textureImageSource?: PolyTextureImageSource;
-    texturePresentation?: PolyTexturePresentation;
-    /**
-     * Per-vertex UV coords (0..1, OBJ convention with v=0 at bottom).
-     * Length MUST equal vertices.length when set; mismatched UVs are
-     * stripped by `normalizePolygons`.
-     */
-    uvs?: Vec2[];
-    /**
-     * Renderer-internal source triangles for UV textures. Merge passes use this
-     * to reduce DOM planes while preserving per-triangle texture mapping in the
-     * generated atlas.
-     * @internal
-     */
-    textureTriangles?: TextureTriangle[];
-    /**
-     * Import-time simplifier seam keys retained after solid texture baking.
-     * Renderers ignore this; mesh optimization uses it to avoid welding vertices
-     * that shared a position but came from different texture/attribute seams.
-     * @internal
-     */
-    simplifyVertexKeys?: string[];
-    /**
-     * Stricter import-time simplifier keys that preserve source vertex identity.
-     * Renderers ignore this; candidate simplification uses it only for fallback
-     * passes where relaxed seam welding loses after render-cost optimization.
-     * @internal
-     */
-    simplifySourceVertexKeys?: string[];
-    /**
-     * 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
-     * values are kept; other shapes are dropped by `normalizePolygons`.
-     */
-    data?: Record<string, string | number | boolean>;
-}
+import { P as Polygon, V as Vec3, C as CameraState, a as PolyDirectionalLight, b as PolyAmbientLight, M as MeshResolution, c as PolyPointLight, d as PolyTextureLightingMode, e as Vec2, f as PolyTextureLeafSizing, g as PolyTextureImageSource, h as PolyTextureImageRendering, i as PolyTextureImageLighting, j as PolyTextureProjection, k as PolyTextureBackend, T as TextureTriangle, l as PolyTexturePresentation } from './camera-VU-yix11.cjs';
+export { A as AutoRotateConfig, m as AutoRotateOption, B as BASE_TILE, n as CameraHandle, o as CameraStyleInput, D as DEFAULT_CAMERA_STATE, p as DEFAULT_PROJECTION, q as PolyCameraProjection, r as PolyCameraSceneTransformOptions, s as PolyCameraSnapshot, t as PolyCameraSnapshotOptions, u as PolyCameraSnapshotSource, v as PolyMaterial, w as PolyTextureAlphaMode, x as PolyTextureWrap, y as PolyTextureWrapMode, z as buildPolyCameraSceneTransform, E as capturePolyCameraSnapshot, F as createIsometricCamera, G as normalizeInvertMultiplier, H as polyCameraTargetToCss, I as resolvePolyCameraAppliedPerspectiveStyle } from './camera-VU-yix11.cjs';
 
 /**
  * normalizePolygons — validates a polygon list, drops degenerate inputs,
@@ -411,82 +210,6 @@ declare function quatFromEulerXYZ(eulerDeg: Vec3): Quat;
  *  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.
- */
-declare const BASE_TILE = 50;
-interface AutoRotateConfig {
-    axis?: "x" | "y";
-    speed?: number;
-    pauseOnInteraction?: boolean;
-}
-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).
- *
- * `pan`, `tilt`, and `depthOffset` are gone. Translations now live inside
- * `target` so they happen BEFORE rotations — enabling correct world-space
- * pan at any tilt angle.
- *
- * `distance` is the camera's pull-back from the target in CSS pixels.
- * Increasing distance moves the camera farther from the target along the
- * view axis (dolly out) — analogous to three.js's spherical radius.
- * Default 0 keeps orthographic/isometric scenes flat.
- */
-interface CameraState {
-    target: Vec3;
-    rotX: number;
-    rotY: number;
-    zoom: number;
-    /** Camera pull-back from target in CSS pixels. Default 0. */
-    distance: number;
-}
-interface CameraStyleInput {
-    rows?: number;
-    cols?: number;
-}
-interface CameraHandle {
-    state: CameraState;
-    update(next: Partial<CameraState>): void;
-    getStyle(input?: CameraStyleInput): {
-        transform: string;
-        width: string;
-        height: string;
-    };
-}
-interface PolyCameraSceneTransformOptions {
-    autoCenterOffset?: Vec3;
-    layoutScale?: number;
-    tileSize?: number;
-}
-type PolyCameraProjection = "orthographic" | "perspective";
-interface PolyCameraSnapshot {
-    projection: PolyCameraProjection;
-    perspectiveStyle: string;
-    appliedPerspectiveStyle: string;
-    state: CameraState;
-}
-interface PolyCameraSnapshotOptions {
-    projection?: PolyCameraProjection;
-    perspectiveStyle?: string;
-}
-type PolyCameraSnapshotSource = CameraHandle & {
-    readonly type?: PolyCameraProjection;
-    readonly perspectiveStyle?: string;
-};
-declare function normalizeInvertMultiplier(value: number | boolean | undefined): number | undefined;
-declare const DEFAULT_CAMERA_STATE: CameraState;
-declare function polyCameraTargetToCss(target?: Vec3, autoCenterOffset?: Vec3, tileSize?: number): Vec3;
-declare function buildPolyCameraSceneTransform(state?: Partial<CameraState>, options?: PolyCameraSceneTransformOptions): string;
-declare function resolvePolyCameraAppliedPerspectiveStyle(perspectiveStyle?: string): string;
-declare function capturePolyCameraSnapshot(camera: PolyCameraSnapshotSource, options?: PolyCameraSnapshotOptions): PolyCameraSnapshot;
-declare function createIsometricCamera(initial?: Partial<CameraState>): CameraHandle;
-
 /**
  * Screen → world inverse projection helpers.
  *
@@ -571,7 +294,7 @@ declare function shadeColor(base: string, delta: number): string;
  *
  * Math (decoupled, three.js convention):
  *   tint = ambient.color · ambient.intensity
- *        + directional.color · directional.intensity · max(0, n · (−L))
+ *        + directional.color · directional.intensity · max(0, n · L)
  *   final = baseColor × tint
  *
  * Pass `directional` and/or `ambient` undefined to fall back to defaults
@@ -1455,6 +1178,29 @@ declare const BAKED_SHADOW_MIN_UP = 0.01;
  * already in unit-less form (matrix3d entries must be dimensionless).
  */
 declare function buildBakedShadowProjectionMatrix(lightDir: Vec3, groundCssZ: number): number[];
+/**
+ * Radial variant of `projectCssVertexToGround` for a point light at a fixed
+ * CSS-frame position. The shadow ray travels FROM the light THROUGH the
+ * vertex and onto the ground plane `z = groundCssZ`, so each vertex projects
+ * along its own direction (a true perspective projection) rather than the
+ * single parallel direction a directional light uses.
+ *
+ * Returns `null` when no valid forward intersection exists — the vertex sits
+ * on the light's side of the ground plane, or the ray runs parallel to it.
+ * The caller drops that vertex (and any polygon that loses ≥1 vertex falls
+ * back to a degenerate projection it can skip).
+ *
+ * `lightPos` and `cssVertex` are both in the dimensionless CSS frame (after
+ * the world→CSS axis swap + tile scale), matching `projectCssVertexToGround`.
+ */
+declare function projectCssVertexToGroundFromPoint(cssVertex: Vec3, lightPos: Vec3, groundCssZ: number): [number, number] | null;
+/**
+ * Point-light variant of `isBakedShadowCaster`. A polygon casts shadow when
+ * its outward normal points away from the light — i.e. the ray from the
+ * light to the polygon centroid runs into the back of the face. `centroid`
+ * and `lightPos` are CSS-frame; `normal` is the CSS-frame outward normal.
+ */
+declare function isPointShadowCaster(centroid: Vec3, normal: Vec3, lightPos: Vec3): boolean;
 /**
  * Decides whether a polygon should cast a shadow given its outward
  * normal and the light's travel direction.
@@ -1500,6 +1246,73 @@ declare function ensureCcw2D(vertices: ReadonlyArray<readonly [number, number]>)
  */
 declare function projectCssVertexToGround(cssVertex: Vec3, lightDir: Vec3, groundCssZ: number): [number, number];
 
+/**
+ * Build the parametric silhouette loop for a caster lit by a directional light.
+ *
+ * @param worldVerts  Every caster vertex in the same world-CSS frame the
+ *                    receiver projector works in (e.g. `CasterPolyItem.wv`).
+ * @param lightDir    Directional light vector (to-source) in that frame.
+ * @param definition  Max loop points. The convex hull is decimated down to this
+ *                    by repeatedly dropping the lowest-area vertex (shape-
+ *                    preserving). `<= 2` is treated as 3.
+ * @returns A closed 3D loop (the silhouette vertices), or `null` if degenerate.
+ */
+declare function computeParametricShadowSilhouette(worldVerts: ReadonlyArray<Vec3>, lightDir: Vec3, definition: number): Vec3[] | null;
+
+/**
+ * Build concave coverage-contour silhouette loops for a caster lit by a
+ * directional light.
+ *
+ * @param polysWorldVerts  Each caster polygon's vertices in the world-CSS frame
+ *                         (e.g. `CasterPolyItem.wv`).
+ * @param lightDir         Directional light vector (to-source) in that frame.
+ * @param definition       Detail knob → coverage mask resolution.
+ * @param layers           Depth bands along the light. 1 (default) = one flat
+ *                         outline (cross-mesh casting). >1 = depth-stratified
+ *                         outlines for correct self-shadow.
+ * @returns Closed 3D loops, or `null`.
+ */
+declare function computeCoverageShadowSilhouette(polysWorldVerts: ReadonlyArray<ReadonlyArray<Vec3>>, lightDir: Vec3, definition: number, layers?: number, mode?: "contour" | "pixel"): Vec3[][] | null;
+
+/** True when every caster vertex lies in a single plane (a ground quad, a
+ *  billboard, etc.). Such casters have no coverage volume for the parametric
+ *  proxy — their tilted proxy would project garbage onto a coplanar receiver —
+ *  so the caller routes them through the exact path instead. */
+declare function isFlatCaster(polysWv: ReadonlyArray<ReadonlyArray<Vec3>>): boolean;
+/** Rubric: a CONVEX caster self-shadows nothing. The depth-band proxy still
+ *  leaks a little false self-shadow on convex meshes, so detect convexity and
+ *  skip self-shadow for them. Capped at `maxPolys` (O(faces × verts), and large
+ *  meshes are essentially never convex — they early-exit on the first concave
+ *  face anyway). */
+declare function isConvexCaster(polysWv: ReadonlyArray<ReadonlyArray<Vec3>>, maxPolys?: number): boolean;
+interface ParametricOverrideInput {
+    /** Caster polygons, each a vertex list in the world-CSS frame. */
+    polysWorldVerts: ReadonlyArray<ReadonlyArray<Vec3>>;
+    /** Directional light (to-source) in the world-CSS frame. */
+    lightDir: Vec3;
+    /** Effective definition (caller folds in per-mesh override + drag cap). */
+    definition: number;
+    /** True when the caster is also the receiver (self-shadow). */
+    isSelf: boolean;
+    /** `"pixel"` greedy-meshes the coverage into voxel rects; default contour. */
+    style?: "vector" | "pixel";
+    /** Shadow-casting point lights (CSS position + index in `allPointLights`). */
+    pointLights?: ReadonlyArray<{
+        position: Vec3;
+        index: number;
+    }>;
+}
+interface ParametricOverrideResult {
+    /** Directional override loops, or undefined to use the exact path. */
+    overrideSilhouette?: Vec3[][];
+    /** Per-point-light radial override loops (indexed by point light index). */
+    overridePointSilhouettes?: Array<Vec3[][] | undefined>;
+}
+/** Build the parametric override(s) for one caster — directional plus one
+ *  radial silhouette per shadow-casting point light. Returns empty overrides
+ *  (use the exact path) for flat casters and convex self-shadow. */
+declare function buildParametricCasterOverride(input: ParametricOverrideInput): ParametricOverrideResult;
+
 type Pt = readonly [number, number];
 /**
  * Clips `subject` against the convex polygon `clip`. Both polygons are
@@ -1690,18 +1503,6 @@ declare function buildEdgeOwners(polygons: readonly Polygon[]): Map<string, Edge
  *  TRAVELS in direction L, polygons are CCW-from-outside). Matches the
  *  light-backface cull's sign convention. */
 declare function classifyFacing(planeNormals: Array<Vec3 | null>, lightDir: Vec3): boolean[];
-/**
- * Walk silhouette edges into closed loops. An edge is silhouette iff
- * its two adjacent polygons disagree on `facing`. Boundary edges
- * (polyB === null) are silhouette iff their owner is front-facing —
- * the boundary is where the lit side ends.
- *
- * Returns one closed loop per connected silhouette cycle, each as a
- * Vec3[] sequence (last vertex equals first vertex implicitly; not
- * duplicated). For non-manifold or open meshes some edges may not form
- * a clean cycle; those edges are dropped and the remaining cycles are
- * returned best-effort.
- */
 declare function extractSilhouetteLoops(edgeOwners: ReadonlyMap<string, EdgeOwners>, facing: boolean[]): Vec3[][];
 
 /**
@@ -1774,6 +1575,15 @@ interface ReceiverCasterInput<T = unknown> {
      *  array is sized correctly even when atlas-plan / dedup filters drop
      *  some polygons from `items`. */
     casterPolygonCount?: number;
+    /** Parametric-shadow override: a precomputed world-frame silhouette loop set
+     *  (see `computeParametricShadowSilhouette`). When present it is projected
+     *  directly — skipping per-poly and silhouette extraction — so a cheap,
+     *  low-resolution outline casts onto every receiver via the normal pipeline. */
+    overrideSilhouette?: Vec3[][];
+    /** Per-point-light parametric override (indexed by the point light's index in
+     *  `allPointLights`). A point pass uses this RADIAL silhouette instead of the
+     *  directional `overrideSilhouette`; an undefined entry → exact point path. */
+    overridePointSilhouettes?: Array<Vec3[][] | undefined>;
 }
 /**
  * Build a polygon-adjacency map: polygonIndex → set of polygonIndex that
@@ -1815,6 +1625,15 @@ interface ReceiverShadowFaceSpec<T = unknown> {
      *  if applicable). */
     opacity: number;
     paths: Array<ReceiverShadowPath<T>>;
+    /** Full-lit face color C (all lights), for the multi-light merge: callers
+     *  multiply C by each pass's `fill/C` factor so overlaps composite to the
+     *  both-blocked color. Empty string for textured receivers (per-pixel base,
+     *  multiply can't be uniform — those fall back to cumulative-alpha). */
+    fullLitFill: string;
+    /** Every clipped caster polygon for this pass in absolute face-(u,v) space
+     *  (NOT offset by the tight bbox). The multi-light merge re-bases these to a
+     *  shared per-face bbox so all lights' shadows live in one SVG. */
+    facePolysUv: Array<Array<[number, number]>>;
 }
 /**
  * Build silhouette `edgeOwners` for a caster mesh in world-CSS frame.
@@ -1859,8 +1678,29 @@ interface ComputeReceiverShadowFacesInput<T = unknown> {
     receiverHasTexture: boolean;
     /** Per-caster items + caller id, in caller-defined order. */
     casters: ReceiverCasterInput<T>[];
-    /** Directional light vector in CSS frame. */
+    /** Light direction in CSS frame, pointing TOWARD the light (to-source).
+     *  For a point light this is a representative direction (used only for the
+     *  textured-receiver opacity ratio); per-vertex directions come from
+     *  `lightPos`. */
     lightDir: Vec3;
+    /** When set, the light is a point light at this CSS-frame position. The
+     *  shadow projection becomes radial (per-vertex direction from the light)
+     *  and the silhouette fast path is disabled (facing is per-polygon). */
+    lightPos?: Vec3;
+    /** Every point light in the scene (CSS-frame absolute positions), used to
+     *  compute the SHADED shadow color — a shadow shows the receiver lit by all
+     *  lights EXCEPT the blocked one, so a spot shadowed from one colored light
+     *  still shows the others' color (Three.js parity). Includes non-shadow-
+     *  casting lights, since they still illuminate the shadowed region. */
+    allPointLights?: ReadonlyArray<{
+        position: Vec3;
+        color?: string;
+        intensity?: number;
+    }>;
+    /** For a point-light pass, the index into `allPointLights` of the light
+     *  being shadowed (excluded from the remaining-light fill). Undefined for
+     *  the directional pass (which instead excludes the directional light). */
+    thisPointIndex?: number;
     /** Camera cull rotation (rotX/rotY + receiver mesh rotation) so back-
      *  facing receiver faces can be skipped. */
     cameraRot: CameraCullRotation;
@@ -1881,6 +1721,73 @@ interface ComputeReceiverShadowFacesInput<T = unknown> {
  * back-facing faces. Caller mounts SVGs per spec.
  */
 declare function computeReceiverShadowFaces<T = unknown>(input: ComputeReceiverShadowFacesInput<T>): ReceiverShadowFaceSpec<T>[];
+/** One path inside a merged face SVG. */
+interface MergedShadowLayer {
+    /** Path data (`M…L…Z`, already offset to the SVG's tight bbox). */
+    d: string;
+    /** Fill color (remaining-light color for a single layer, multiply factor for
+     *  a merged solid layer, dark shadow color for textured). */
+    fill: string;
+    /** Apply `mix-blend-mode: multiply` (merged solid layers only). */
+    multiply: boolean;
+    /** Per-path opacity (1 for merged solid layers, which carry strength on the
+     *  SVG; the pass's own opacity otherwise). */
+    opacity: number;
+}
+/** One receiver FACE's merged shadow, ready to mount as a single SVG. */
+interface MergedShadowFace {
+    faceIndex: number;
+    memberPolyIndices: number[];
+    matrixCss: string;
+    width: number;
+    height: number;
+    /** SVG-level opacity (shadow strength for merged solid faces, else 1). */
+    svgOpacity: number;
+    /** Full-lit base path (merged solid faces only); null otherwise. */
+    baseFill: string | null;
+    baseD: string | null;
+    layers: MergedShadowLayer[];
+}
+/** Inputs for `computeMergedReceiverShadows` — the full light set for one
+ *  receiver, plus its prepared face planes and casters. */
+interface MergedReceiverShadowInput<T = unknown> {
+    receiverPlanes: ReceiverFacePlane[];
+    receiverPolygons: readonly Polygon[];
+    receiverHasTexture: boolean;
+    casters: ReceiverCasterInput<T>[];
+    /** Directional light vector in CSS frame (to-source). */
+    lightDir: Vec3;
+    /** Run the directional pass (caller gates on a real, nonzero-intensity
+     *  directional light). */
+    runDirectional: boolean;
+    /** One pass per shadow-casting point light: CSS position + index into
+     *  `allPointLights`. Empty in dynamic mode (point lights are baked-only). */
+    pointPasses: ReadonlyArray<{
+        lightPos: Vec3;
+        index: number;
+    }>;
+    /** All point lights (CSS positions) for the shaded shadow color; empty in
+     *  dynamic mode. */
+    allPointLights?: ReadonlyArray<{
+        position: Vec3;
+        color?: string;
+        intensity?: number;
+    }>;
+    cameraRot: CameraCullRotation;
+    ambientLight?: PolyAmbientLight;
+    directionalLight?: PolyDirectionalLight;
+    shadow?: {
+        color?: string;
+        opacity?: number;
+        maxExtend?: number;
+    };
+}
+/**
+ * Run every light pass for one receiver and merge each face's passes into a
+ * single SVG descriptor. Shared by all three renderers so multi-light shadow
+ * overlap is identical everywhere.
+ */
+declare function computeMergedReceiverShadows<T = unknown>(input: MergedReceiverShadowInput<T>): MergedShadowFace[];
 
 /**
  * PolyAnimationMixer — three.js-shaped animation API for polycss.
@@ -2570,6 +2477,10 @@ interface SolidTrianglePlanOptions {
     tileSize?: number;
     layerElevation?: number;
     directionalLight?: PolyDirectionalLight;
+    /** Point lights in MESH-LOCAL frame (renderer pre-transforms each scene
+     *  point light by inverse-rotate(worldPos - meshPos) so positions match
+     *  the local cssPoints frame). Direction-only, per-face Lambert. */
+    pointLights?: PolyPointLight[];
     ambientLight?: PolyAmbientLight;
     textureLighting?: PolyTextureLightingMode;
     solidPaintDefaults?: SolidPaintDefaults;
@@ -2602,6 +2513,10 @@ interface ComputeTextureAtlasPlanOptions {
     tileSize?: number;
     layerElevation?: number;
     directionalLight?: PolyDirectionalLight;
+    /** Point lights in MESH-LOCAL frame (renderer pre-transforms each scene
+     *  point light by inverse-rotate(worldPos - meshPos) so positions match
+     *  the local cssPoints frame). Direction-only, per-face Lambert. */
+    pointLights?: PolyPointLight[];
     ambientLight?: PolyAmbientLight;
     /** Shared-edge set returned by {@link buildTextureEdgeRepairSets}. */
     textureEdgeRepairEdges?: Set<number>;
@@ -2674,9 +2589,20 @@ declare function rgbToHex({ r, g, b }: RGB): string;
  * (see applyTextureTint in the renderer). `directScale` is already
  * `intensity × max(n·L, 0)` (computed by the caller).
  */
-declare function textureTintFactors(directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number): RGBFactors;
+/**
+ * One point light's per-face contribution to a polygon: its color and the
+ * scalar `intensity × max(0, n·L̂)` already computed by the caller against the
+ * face normal + centroid (point lights are direction-only — no distance
+ * falloff). Multiple lights of different colours can't fold into one scalar,
+ * so the shading functions accumulate these per channel in linear space.
+ */
+interface PointLightContrib {
+    color: string;
+    scale: number;
+}
+declare function textureTintFactors(directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number, pointContribs?: readonly PointLightContrib[]): 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 shadePolygon(baseColor: string, directScale: number, lightColor: string, ambientColor: string, ambientIntensity: number, pointContribs?: readonly PointLightContrib[]): 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;
@@ -2852,4 +2778,4 @@ declare function packTextureAtlasPlansWithScaleCore(plans: Array<TextureAtlasPla
     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 CasterPolyItem, type ComputeReceiverShadowFacesInput, 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 EdgeOwners, 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 OptimizeMeshParseResultOptions, 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 ParseStlColor, type ParseStlSolid, type ParseStlTopology, type ParsedColor, type PlanePolygonsOptions, type PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, type PolyCameraProjection, type PolyCameraSceneTransformOptions, type PolyCameraSnapshot, type PolyCameraSnapshotOptions, type PolyCameraSnapshotSource, type PolyDirectionalLight, type PolyMaterial, type PolyMeshTransformInput, type PolyRenderStrategiesOption, type PolyRenderStrategy, type PolySceneTransformInput, type PolySeamBleed, type PolySeamBleedEdgeValue, type PolySeamBleedEdges, type PolyTextureAlphaMode, type PolyTextureBackend, type PolyTextureImageLighting, type PolyTextureImageRendering, type PolyTextureImageSource, type PolyTextureLeafGeometry, type PolyTextureLeafResolverOptions, type PolyTextureLeafSizing, type PolyTextureLeafSourceRect, type PolyTextureLightingMode, type PolyTexturePresentation, type PolyTextureProjection, 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, RECEIVER_NORMAL_TOL, RECEIVER_OFFSET_TOL, RECEIVER_OUTLINE_EXPAND, RECT_EPS, type RGB, type RGBFactors, type ReceiverCasterInput, type ReceiverFacePlane, type ReceiverPlaneGroup, type ReceiverShadowFaceSpec, type ReceiverShadowPath, type RectBrush, type RingPolygonsOptions, type RingQuadPolygonsOptions, SEAM_LIGHT_EPS, SOLID_QUAD_CANONICAL_SIZE, SOLID_TRIANGLE_BLEED, SOLID_TRIANGLE_CANONICAL_SIZE, SOLID_TRIANGLE_LARGE_BORDER_CANONICAL_SIZE, SURFACE_DISTANCE_EPS, SURFACE_NORMAL_EPS, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type ScreenToWorldOptions, type SeamBleedInsets, type SeamFacetSplitCandidate, type SeamFacetSplitCandidateReason, type SeamFacetSplitOptions, type SeamFacetSplitReport, type SeamOverlapCandidate, type SeamOverlapCandidateKind, type SeamOverlapDiagnostics, type SeamOverlapOptions, type SimplifyTriangleMeshPolygonsOptions, type SolidPaintDefaults, type SolidTextureSampleOptions, type SolidTriangleBasis, type SolidTriangleColorPlan, type SolidTriangleComputeOptions, type SolidTriangleFrame, type SolidTrianglePlan, type SolidTrianglePlanOptions, type SolidTrianglePrimitive, type SpherePolygonsOptions, type StablePlanBasis, type StableTriangleColorState, type StlParseOptions, 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, applyPackedAtlasLeafSizing, arrowPolygons, atlasArea, atlasBitmapMaxSide, atlasCanonicalSizeForEntry, atlasCanonicalSizeForTextureQuality, atlasDecodedBytes, atlasPadding, autoAtlasBudgetFactor, autoAtlasMaxDecodedBytes, autoAtlasScale, autoAtlasScaleCap, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, basisAxisKey, borderShapeBoundsFromPoints, borderShapeGeometryForPlan, boxPolygons, buildBakedShadowProjectionMatrix, buildBasisHints, buildEdgeOwners, buildPolyCameraSceneTransform, buildPolyMeshTransform, buildPolySceneTransform, buildSceneContext, buildSeamBleedPolygonEdges, buildSeamBleedPolygonSet, buildSharedEdgeMap, buildTextureEdgeRepairSets, cachedParsePureColor, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, capturePolyCameraSnapshot, chooseIslandXAxis, chooseLocalBasis, clampChannel, classifyFacing, clipPolygonToConvex2D, colorErrorScore, compatibleBleedSurface, compatibleSurface, computeLightVisibility, computePlanSeamBleedEdgeAmounts, computeProjectiveQuadCoefficients, computeProjectiveQuadMatrix, computeReceiverShadowFaces, computeSceneBbox, computeSeamBleedInsets, computeShapeLighting, computeSolidTriangleColorPlan, computeSolidTriangleColorPlanFromNormal, computeSolidTrianglePlan, computeSolidTrianglePlanFromCssPoints, computeSurfaceNormal, computeTextureAtlasPlan, computeTextureAtlasPlanPublic, computeTexturePaintMetrics, computeUvAffine, computeUvSampleRect, conePolygons, convexHull2D, cornerShapeDiagonal, cornerShapeGeometryForPlan, cornerShapePointSides, coverPlanarPolygons, createIsometricCamera, createPolyAnimationMixer, crossVec, cssBorderShapeForGeometry, cssBorderShapeForPlan, cssDistanceToWorld, cssPoints, cssPositionToWorld, cullInteriorPolygons, cylinderPolygons, dedupeOverlappingPolygons, dodecahedronPolygons, dominantCountKey, dotVec, ensureCcw2D, eulerXYZFromQuat, evaluateIslandAxis, expandClipPoints, expandConvexHullOutward, extractSilhouetteLoops, filterAtlasPlans, findOverlappingPolygonDuplicates, formatAffineMatrix3dColumns, formatAffineMatrix3dScalars, formatAffineMatrix3dTransformScalars, formatAtlasMatrix, formatBorderShapeElementStyle, formatBorderShapeEntryMatrix, formatBorderShapeMatrix, formatColor, formatCornerShapeElementStyle, formatCssLength, formatCssLengthPx, formatMatrix3d, formatMatrix3dValues, formatPercent, formatScaledMatrixFromPlan, formatSolidQuadEntryMatrix, formatSolidQuadMatrix, fullRectBounds, getPolygonBasisInfo, getSolidPaintDefaultsForPlansCore, groupReceiverFaceGroups, icosahedronPolygons, incrementCount, intersect2DLines, intersect2DLinesRaw, inverseRotateVec3, isAxisAlignedSurfaceNormal, isBakedShadowCaster, isBasisOptimizable, isConvexPolygonPoints, isFullRectBasis, isFullRectSolid, isProjectiveQuadPlan, isSolidTrianglePlan, isVoxelCameraCullableNormalGroups, loadMesh, makeLocalBasis, mergePolygons, meshScaleVec3, normalFacesCamera, normalizeAtlasScale, normalizeInvertMultiplier, normalizePolygons, normalizedSeamBleed, octahedronPolygons, offsetConvexPolygonPoints, offsetConvexPolygonPointsByEdgeAmounts, offsetStableTrianglePoints, offsetTrianglePoints, optimizeAnimatedMeshPolygons, optimizeMeshParseResult, optimizeMeshPolygons, packTextureAtlasPlans, packTextureAtlasPlansWithScaleCore, parseAlpha, parseColor, parseGltf, parseHex, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseStl, parseVox, planePolygons, polyCameraTargetToCss, polyCssDistanceToWorld, polyCssPositionToWorld, polygonContainsPoint, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, polygonSignedArea2D, prepareCasterEdgeOwners, prepareCasterPolyItems, prepareReceiverFacePlanes, projectCssVertexToGround, projectTextureTriangle, quantizeCssColor, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, repairMeshSeams, resolveAtlasLeafBox, resolveBleedRatio, resolvePolyCameraAppliedPerspectiveStyle, resolvePolyTextureImageRendering, resolvePolyTextureImageSource, resolvePolyTextureLeafGeometry, resolvePolyTexturePresentation, resolvePolyTextureUrl, resolveProjectiveQuadGuards, resolveSeamBleed, rgbEqual, rgbKey, rgbToCss, rgbToHex, ringPolygons, ringQuadPolygons, rotateVec3, rotateVec3InWrapperCssFrame, roundDecimal, safariCssProjectiveUnsupported, safePlanSeamBleedAmount, screenToWorldOnSphere, screenToWorldRay, seamBleedAmountArray, seamFacetSplitPolygons, seamFacetSplitReport, seamLightBrightness, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, shadePolygon, sharedCornerShapeSide, signedArea2D, simplifyCornerShapePoints, simplifyTriangleMeshPolygons, spherePolygons, stableBasisFromPlan, stableTriangleMatrixDecimals, stepRgbToward, tetrahedronPolygons, textureTintFactors, tintToCss, torusPolygons, worldCssForMesh, worldDirectionToCss, worldDirectionToPolyCss, worldDirectionalLightToCss, worldDirectionalLightToPolyCss, worldDistanceToCss, worldDistanceToPolyCss, worldPositionToCss, worldPositionToPolyCss };
+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 AxesHelperOptions, BAKED_SHADOW_MIN_UP, BAKED_SHADOW_Z_SQUASH, 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, CameraState, type CasterPolyItem, type ComputeReceiverShadowFacesInput, 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_LIGHT_COLOR, DEFAULT_LIGHT_DIR, DEFAULT_LIGHT_INTENSITY, DEFAULT_MATRIX_DECIMALS, DEFAULT_SEAM_BLEED, DEFAULT_SEAM_FACET_SPLIT_OPTIONS, DEFAULT_SEAM_OVERLAP_OPTIONS, DEFAULT_TILE, type DedupeOverlappingPolygonsOptions, type DodecahedronPolygonsOptions, type EdgeOwners, 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 MergedReceiverShadowInput, type MergedShadowFace, type MergedShadowLayer, MeshResolution, type MtlParseResult, type NormalizeResult, type ObjParseOptions, type OctahedronPolygonsOptions, type OptimizeAnimatedMeshPolygonsOptions, type OptimizeMeshParseResultOptions, 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 ParametricOverrideInput, type ParametricOverrideResult, type ParseAnimationClip, type ParseAnimationController, type ParseResult, type ParseStlColor, type ParseStlSolid, type ParseStlTopology, type ParsedColor, type PlanePolygonsOptions, PolyAmbientLight, type PolyAnimationAction, type ParseAnimationClip as PolyAnimationClip, type PolyAnimationMixer, type PolyAnimationTarget, PolyDirectionalLight, type PolyMeshTransformInput, PolyPointLight, type PolyRenderStrategiesOption, type PolyRenderStrategy, type PolySceneTransformInput, type PolySeamBleed, type PolySeamBleedEdgeValue, type PolySeamBleedEdges, PolyTextureBackend, PolyTextureImageLighting, PolyTextureImageRendering, PolyTextureImageSource, type PolyTextureLeafGeometry, type PolyTextureLeafResolverOptions, PolyTextureLeafSizing, type PolyTextureLeafSourceRect, PolyTextureLightingMode, PolyTexturePresentation, PolyTextureProjection, type PolyVoxelCell, type PolyVoxelSource, Polygon, type PolygonBasisInfo, type PolygonFace, type ProjectiveQuadCoefficients, type ProjectiveQuadGuardGlobal, type ProjectiveQuadGuardOverrides, type ProjectiveQuadGuardSettings, QUAT_IDENTITY, type Quat, RECEIVER_NORMAL_TOL, RECEIVER_OFFSET_TOL, RECEIVER_OUTLINE_EXPAND, RECT_EPS, type RGB, type RGBFactors, type ReceiverCasterInput, type ReceiverFacePlane, type ReceiverPlaneGroup, type ReceiverShadowFaceSpec, type ReceiverShadowPath, type RectBrush, type RingPolygonsOptions, type RingQuadPolygonsOptions, SEAM_LIGHT_EPS, SOLID_QUAD_CANONICAL_SIZE, SOLID_TRIANGLE_BLEED, SOLID_TRIANGLE_CANONICAL_SIZE, SOLID_TRIANGLE_LARGE_BORDER_CANONICAL_SIZE, SURFACE_DISTANCE_EPS, SURFACE_NORMAL_EPS, type SceneBbox, type SceneContext, type SceneContextBuildArgs, type SceneContextBuildResult, type ScreenToWorldOptions, type SeamBleedInsets, type SeamFacetSplitCandidate, type SeamFacetSplitCandidateReason, type SeamFacetSplitOptions, type SeamFacetSplitReport, type SeamOverlapCandidate, type SeamOverlapCandidateKind, type SeamOverlapDiagnostics, type SeamOverlapOptions, type SimplifyTriangleMeshPolygonsOptions, type SolidPaintDefaults, type SolidTextureSampleOptions, type SolidTriangleBasis, type SolidTriangleColorPlan, type SolidTriangleComputeOptions, type SolidTriangleFrame, type SolidTrianglePlan, type SolidTrianglePlanOptions, type SolidTrianglePrimitive, type SpherePolygonsOptions, type StablePlanBasis, type StableTriangleColorState, type StlParseOptions, 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, TextureTriangle, type TextureTrianglePlan, type TorusPolygonsOptions, type UvAffine, type UvSampleRect, VOXEL_CAMERA_CULL_AXIS_EPS, VOXEL_CAMERA_CULL_NORMAL_LIMIT, Vec2, Vec3, type VoxParseOptions, applyPackedAtlasCanonicalSize, applyPackedAtlasLeafSizing, arrowPolygons, atlasArea, atlasBitmapMaxSide, atlasCanonicalSizeForEntry, atlasCanonicalSizeForTextureQuality, atlasDecodedBytes, atlasPadding, autoAtlasBudgetFactor, autoAtlasMaxDecodedBytes, autoAtlasScale, autoAtlasScaleCap, axesHelperPolygons, bakeSolidTextureSampledPolygons, bakeSolidTextureSamples, basisAxisKey, borderShapeBoundsFromPoints, borderShapeGeometryForPlan, boxPolygons, buildBakedShadowProjectionMatrix, buildBasisHints, buildEdgeOwners, buildParametricCasterOverride, buildPolyMeshTransform, buildPolySceneTransform, buildSceneContext, buildSeamBleedPolygonEdges, buildSeamBleedPolygonSet, buildSharedEdgeMap, buildTextureEdgeRepairSets, cachedParsePureColor, cameraCullNormalGroups, cameraCullNormalGroupsFromPolygons, cameraCullNormalKey, cameraCullVisibleSignature, cameraFacingDepth, chooseIslandXAxis, chooseLocalBasis, clampChannel, classifyFacing, clipPolygonToConvex2D, colorErrorScore, compatibleBleedSurface, compatibleSurface, computeCoverageShadowSilhouette, computeLightVisibility, computeMergedReceiverShadows, computeParametricShadowSilhouette, computePlanSeamBleedEdgeAmounts, computeProjectiveQuadCoefficients, computeProjectiveQuadMatrix, computeReceiverShadowFaces, computeSceneBbox, computeSeamBleedInsets, computeShapeLighting, computeSolidTriangleColorPlan, computeSolidTriangleColorPlanFromNormal, computeSolidTrianglePlan, computeSolidTrianglePlanFromCssPoints, computeSurfaceNormal, computeTextureAtlasPlan, computeTextureAtlasPlanPublic, computeTexturePaintMetrics, computeUvAffine, computeUvSampleRect, conePolygons, convexHull2D, cornerShapeDiagonal, cornerShapeGeometryForPlan, cornerShapePointSides, coverPlanarPolygons, createPolyAnimationMixer, crossVec, cssBorderShapeForGeometry, cssBorderShapeForPlan, cssDistanceToWorld, cssPoints, cssPositionToWorld, cullInteriorPolygons, cylinderPolygons, dedupeOverlappingPolygons, dodecahedronPolygons, dominantCountKey, dotVec, ensureCcw2D, eulerXYZFromQuat, evaluateIslandAxis, expandClipPoints, expandConvexHullOutward, extractSilhouetteLoops, filterAtlasPlans, findOverlappingPolygonDuplicates, formatAffineMatrix3dColumns, formatAffineMatrix3dScalars, formatAffineMatrix3dTransformScalars, formatAtlasMatrix, formatBorderShapeElementStyle, formatBorderShapeEntryMatrix, formatBorderShapeMatrix, formatColor, formatCornerShapeElementStyle, formatCssLength, formatCssLengthPx, formatMatrix3d, formatMatrix3dValues, formatPercent, formatScaledMatrixFromPlan, formatSolidQuadEntryMatrix, formatSolidQuadMatrix, fullRectBounds, getPolygonBasisInfo, getSolidPaintDefaultsForPlansCore, groupReceiverFaceGroups, icosahedronPolygons, incrementCount, intersect2DLines, intersect2DLinesRaw, inverseRotateVec3, isAxisAlignedSurfaceNormal, isBakedShadowCaster, isBasisOptimizable, isConvexCaster, isConvexPolygonPoints, isFlatCaster, isFullRectBasis, isFullRectSolid, isPointShadowCaster, isProjectiveQuadPlan, isSolidTrianglePlan, isVoxelCameraCullableNormalGroups, loadMesh, makeLocalBasis, mergePolygons, meshScaleVec3, normalFacesCamera, normalizeAtlasScale, normalizePolygons, normalizedSeamBleed, octahedronPolygons, offsetConvexPolygonPoints, offsetConvexPolygonPointsByEdgeAmounts, offsetStableTrianglePoints, offsetTrianglePoints, optimizeAnimatedMeshPolygons, optimizeMeshParseResult, optimizeMeshPolygons, packTextureAtlasPlans, packTextureAtlasPlansWithScaleCore, parseAlpha, parseColor, parseGltf, parseHex, parseHexColor, parseMtl, parseObj, parsePureColor, parseRgbColor, parseStl, parseVox, planePolygons, polyCssDistanceToWorld, polyCssPositionToWorld, polygonContainsPoint, polygonCssSurfaceNormal, polygonFaces, polygonFacesCamera, polygonSignedArea2D, prepareCasterEdgeOwners, prepareCasterPolyItems, prepareReceiverFacePlanes, projectCssVertexToGround, projectCssVertexToGroundFromPoint, projectTextureTriangle, quantizeCssColor, quatFromAxisAngle, quatFromEulerXYZ, quatMultiply, repairMeshSeams, resolveAtlasLeafBox, resolveBleedRatio, resolvePolyTextureImageRendering, resolvePolyTextureImageSource, resolvePolyTextureLeafGeometry, resolvePolyTexturePresentation, resolvePolyTextureUrl, resolveProjectiveQuadGuards, resolveSeamBleed, rgbEqual, rgbKey, rgbToCss, rgbToHex, ringPolygons, ringQuadPolygons, rotateVec3, rotateVec3InWrapperCssFrame, roundDecimal, safariCssProjectiveUnsupported, safePlanSeamBleedAmount, screenToWorldOnSphere, screenToWorldRay, seamBleedAmountArray, seamFacetSplitPolygons, seamFacetSplitReport, seamLightBrightness, seamOverlapDiagnostics, seamOverlapPolygons, seamOverlapReport, shadeColor, shadePolygon, sharedCornerShapeSide, signedArea2D, simplifyCornerShapePoints, simplifyTriangleMeshPolygons, spherePolygons, stableBasisFromPlan, stableTriangleMatrixDecimals, stepRgbToward, tetrahedronPolygons, textureTintFactors, tintToCss, torusPolygons, worldCssForMesh, worldDirectionToCss, worldDirectionToPolyCss, worldDirectionalLightToCss, worldDirectionalLightToPolyCss, worldDistanceToCss, worldDistanceToPolyCss, worldPositionToCss, worldPositionToPolyCss };