@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/primitives/triangulate.d.ts

@@ -0,0 +1,2 @@
+import type { Vec2 } from '../core/index.js';
+export declare function triangulate(poly: readonly Vec2[]): [number, number, number][];

package/dist/primitives/value-noise.d.ts

@@ -0,0 +1,10 @@
+import type { Rng } from '../core/index.js';
+import type { Field } from './sdf-ops.js';
+/**
+ * Seeded fractal value noise in [−1, 1]: `scale` = metres per feature, `octaves` halve the scale
+ * and amplitude each time. Same Rng state → same field, bit for bit.
+ */
+export declare function valueNoise(rng: Rng, o?: {
+    readonly scale?: number;
+    readonly octaves?: number;
+}): Field;

package/dist/qa/checks.d.ts

@@ -0,0 +1,11 @@
+import type { Check, CheckFinding } from '../core/index.js';
+/** Nothing matching `a` sinks into anything matching `b` (closed solids), with optional min gap. */
+export declare const clear: (a: string, b: string, minGap?: number) => Check;
+/** No two parts matching the selector interpenetrate (interleaved wheels, stacked crates). */
+export declare const noOverlap: (selector: string) => Check;
+/** `a` must touch `b` (surface within 2 cm): a turret sits on its ring, a lamp on its post. */
+export declare const touches: (a: string, b: string, eps?: number) => Check;
+/** Every part containing `left` has a mirror part (with `right`) reflected across the axis plane. */
+export declare const symmetric: (left: string, right: string, axis?: 'x' | 'y' | 'z', tol?: number) => Check;
+/** Run a recipe's checks; the QA gate calls this. */
+export declare const runChecks: (asset: Parameters<Check>[0]) => CheckFinding[];

package/dist/qa/clash.d.ts

@@ -0,0 +1,2 @@
+import { type Gate } from './types.js';
+export declare const clashes: Gate;

package/dist/qa/floating.d.ts

@@ -0,0 +1,5 @@
+import { type Mesh } from '../core/index.js';
+import { TriangleGrid } from './geometry.js';
+import { type Gate } from './types.js';
+export declare function touching(a: Mesh, b: Mesh, grid: TriangleGrid, eps?: number): boolean;
+export declare const floatingParts: Gate;

package/dist/qa/gates.d.ts

@@ -0,0 +1,12 @@
+import { type CompiledAsset } from '../core/index.js';
+import type { Finding, Gate } from './types.js';
+export declare const triangleBudget: Gate;
+export declare const partNames: Gate;
+/** Overall bounding box vs the recipe's `real` dimensions: catches a 6 m tank modelled at 7.4 m. */
+export declare const proportions: Gate;
+/** Planned gates, signatures fixed: docs/idea/06-qa.md. */
+export declare const silhouetteIoU: (_asset: CompiledAsset, _referencePng: Uint8Array) => number;
+/** The recipe's own `checks`, each finding reported under the gate name `check`. */
+export declare const recipeChecks: Gate;
+export declare const DEFAULT_GATES: readonly Gate[];
+export declare function runQa(asset: CompiledAsset, gates?: readonly Gate[]): Finding[];

package/dist/qa/geometry.d.ts

@@ -0,0 +1,21 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+export declare function triangle(m: Mesh, t: number): [Vec3, Vec3, Vec3];
+/** Distance from p to triangle abc (Ericson, Real-Time Collision Detection §5.1.5). */
+export declare function pointTriangleDistance(p: Vec3, a: Vec3, b: Vec3, c: Vec3): number;
+/** Triangles bucketed by a uniform grid, so a point only tests its neighbourhood. */
+export declare class TriangleGrid {
+    private readonly cells;
+    /** Cell edge: 25 cm for props and vehicles, growing with big meshes (a 330 m tower) so one
+     *  long triangle never lands in 10⁵ cells. */
+    private readonly cell;
+    private readonly tris;
+    /** Per-triangle AABB (min xyz, max xyz) for a cheap reject before the exact distance. */
+    private readonly boxes;
+    private readonly stamp;
+    private query;
+    constructor(mesh: Mesh);
+    /** Distance from p to the nearest triangle, if one is within `radius`; else Infinity. */
+    nearest(p: Vec3, radius: number): number;
+}
+/** Vertices plus points along every edge every `step` metres (catches crossing members). */
+export declare function surfaceSamples(m: Mesh, step?: number, maxPerEdge?: number): Vec3[];

package/dist/qa/index.d.ts

@@ -0,0 +1,12 @@
+export { clear, noOverlap, runChecks, symmetric, touches } from './checks.js';
+export { clashes } from './clash.js';
+export { floatingParts, touching } from './floating.js';
+export { DEFAULT_GATES, partNames, proportions, runQa, silhouetteIoU, triangleBudget, } from './gates.js';
+export { pointTriangleDistance, surfaceSamples, TriangleGrid } from './geometry.js';
+export { insideSolid } from './inside.js';
+export { glob, type Inspector, inspect, type Penetration } from './inspect.js';
+export { DEFAULT_LOD_GATES, type LodGate, lodPivots, lodSilhouette, lodTriangles, runLodQa, } from './lods.js';
+export { measure, measures } from './measures.js';
+export { hiddenParts, zFighting } from './occlusion.js';
+export { degenerateTriangles, nonFinite, normalsMatchWinding, vertexColors } from './sanity.js';
+export { CLASH_EPS, CONTACT_EPS, type Finding, type Gate } from './types.js';

package/dist/qa/index.js

@@ -0,0 +1,78 @@
+import {
+  pointTriangleDistance2,
+  TriangleGrid2,
+  surfaceSamples2,
+  insideSolid2,
+  glob2,
+  inspect2,
+  clear2,
+  noOverlap2,
+  touches2,
+  symmetric2,
+  runChecks2,
+  CONTACT_EPS2,
+  CLASH_EPS2,
+  clashes2,
+  touching2,
+  floatingParts2,
+  measure2,
+  measures2,
+  zFighting2,
+  hiddenParts2,
+  nonFinite2,
+  vertexColors2,
+  normalsMatchWinding2,
+  degenerateTriangles2,
+  triangleBudget2,
+  partNames2,
+  proportions2,
+  silhouetteIoU2,
+  DEFAULT_GATES2,
+  runQa2,
+  lodTriangles2,
+  lodSilhouette2,
+  lodPivots2,
+  DEFAULT_LOD_GATES2,
+  runLodQa2
+} from "../chunk-w1zyhj40.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  CLASH_EPS2 as CLASH_EPS,
+  CONTACT_EPS2 as CONTACT_EPS,
+  DEFAULT_GATES2 as DEFAULT_GATES,
+  DEFAULT_LOD_GATES2 as DEFAULT_LOD_GATES,
+  TriangleGrid2 as TriangleGrid,
+  clashes2 as clashes,
+  clear2 as clear,
+  degenerateTriangles2 as degenerateTriangles,
+  floatingParts2 as floatingParts,
+  glob2 as glob,
+  hiddenParts2 as hiddenParts,
+  insideSolid2 as insideSolid,
+  inspect2 as inspect,
+  lodPivots2 as lodPivots,
+  lodSilhouette2 as lodSilhouette,
+  lodTriangles2 as lodTriangles,
+  measure2 as measure,
+  measures2 as measures,
+  noOverlap2 as noOverlap,
+  nonFinite2 as nonFinite,
+  normalsMatchWinding2 as normalsMatchWinding,
+  partNames2 as partNames,
+  pointTriangleDistance2 as pointTriangleDistance,
+  proportions2 as proportions,
+  runChecks2 as runChecks,
+  runLodQa2 as runLodQa,
+  runQa2 as runQa,
+  silhouetteIoU2 as silhouetteIoU,
+  surfaceSamples2 as surfaceSamples,
+  symmetric2 as symmetric,
+  touches2 as touches,
+  touching2 as touching,
+  triangleBudget2 as triangleBudget,
+  vertexColors2 as vertexColors,
+  zFighting2 as zFighting
+};
+
+//# debugId=D85390BDB209BC4364756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/qa/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "D85390BDB209BC4364756E2164756E21",
+  "names": []
+}

package/dist/qa/inside.d.ts

@@ -0,0 +1,12 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+export declare class SolidIndex {
+    private readonly tri;
+    private readonly columns;
+    private readonly cell;
+    constructor(mesh: Mesh);
+    /** Odd number of crossings of the ray from p along +axis ⇒ inside (for that ray). */
+    private parity;
+    inside(point: Vec3): boolean;
+}
+/** One-off query; build a SolidIndex yourself when testing many points against one mesh. */
+export declare const insideSolid: (p: Vec3, m: Mesh) => boolean;

package/dist/qa/inspect.d.ts

@@ -0,0 +1,18 @@
+import { type Bounds, type CompiledAsset, type Mesh } from '../core/index.js';
+export declare const glob: (pattern: string) => RegExp;
+export interface Penetration {
+    /** Deepest sampled point of A inside B's solid, metres (0 = none). */
+    readonly depth: number;
+    readonly samples: number;
+}
+export interface Inspector {
+    readonly asset: CompiledAsset;
+    parts(selector: string): string[];
+    mesh(selector: string): Mesh | null;
+    bounds(selector: string): Bounds | null;
+    /** Smallest surface-to-surface distance (0 when touching or intersecting), capped at `max`. */
+    distance(a: string, b: string, max?: number): number;
+    /** How deep A's surface goes inside B's closed solid. */
+    penetration(a: string, b: string): Penetration;
+}
+export declare function inspect(asset: CompiledAsset): Inspector;

package/dist/qa/lods.d.ts

@@ -0,0 +1,12 @@
+import { type CompiledAsset } from '../core/index.js';
+import type { Finding } from './types.js';
+/** A gate over the whole LOD chain, index = LOD. */
+export type LodGate = (lods: readonly CompiledAsset[]) => Finding[];
+export declare const lodTriangles: LodGate;
+/** LOD1/LOD2 overall box within `tol` of LOD0's span per side (min 5 cm). */
+export declare const lodSilhouette: (tol?: number) => LodGate;
+export declare const lodPivots: LodGate;
+/** Default chain gates: only what every gallery recipe passes today. `lodSilhouette` and
+ *  `lodPivots` are opt-in until the recipes they flag are fixed (see their findings). */
+export declare const DEFAULT_LOD_GATES: readonly LodGate[];
+export declare function runLodQa(lods: readonly CompiledAsset[], gates?: readonly LodGate[]): Finding[];

package/dist/qa/measures.d.ts

@@ -0,0 +1,4 @@
+import { type CompiledAsset, type Measure } from '../core/index.js';
+import type { Gate } from './types.js';
+export declare function measure(asset: CompiledAsset, m: Measure): number | null;
+export declare const measures: Gate;

package/dist/qa/occlusion.d.ts

@@ -0,0 +1,3 @@
+import type { Gate } from './types.js';
+export declare const zFighting: Gate;
+export declare const hiddenParts: Gate;

package/dist/qa/sanity.d.ts

@@ -0,0 +1,7 @@
+import type { Gate } from './types.js';
+export declare const nonFinite: Gate;
+export declare const vertexColors: Gate;
+/** Shading normals must agree with the winding (the side a renderer culls/lights). */
+export declare const normalsMatchWinding: Gate;
+/** Zero-area triangles: invisible, but they cost index bandwidth and skew QA sampling. */
+export declare const degenerateTriangles: Gate;

package/dist/qa/types.d.ts

@@ -0,0 +1,12 @@
+import type { CompiledAsset } from '../core/index.js';
+export interface Finding {
+    readonly gate: string;
+    readonly part?: string;
+    readonly message: string;
+    readonly fix: string;
+}
+export type Gate = (asset: CompiledAsset) => Finding[];
+/** Contact tolerance: surfaces closer than this touch (metres). */
+export declare const CONTACT_EPS = 0.02;
+/** Clash tolerance: penetration deeper than this is a clash (metres). */
+export declare const CLASH_EPS = 0.01;

package/dist/render/beauty.d.ts

@@ -0,0 +1,40 @@
+import { type CompiledAsset } from '../core/index.js';
+import type { PaintedSheet } from '../material/index.js';
+import { type PerspectiveCamera } from './camera.js';
+export interface BeautyOptions {
+    /** Output size in pixels. Default 1600 × 900. */
+    readonly width?: number;
+    readonly height?: number;
+    /** Camera orbit, degrees: azimuth about Z from the front (+X), −35 = front-left 3/4. */
+    readonly azDeg?: number;
+    /** Elevation above the horizon, degrees (−10…89). Default 18. */
+    readonly elDeg?: number;
+    /** Vertical field of view, degrees. Default 30. */
+    readonly fovDeg?: number;
+    /** Samples per pixel edge (1–4). Default 2 (4 samples per pixel). */
+    readonly supersample?: number;
+    /** The painted trim sheet; default paints `DEFAULT_SHEET` at 512² once per process. */
+    readonly sheet?: PaintedSheet;
+    /** Zoom into the default framing: window centre (0–1, 0–1) of the full shot and a zoom ≥ 1. */
+    readonly window?: {
+        readonly x: number;
+        readonly y: number;
+        readonly zoom: number;
+    };
+    /** Frame with this asset instead (e.g. LOD0's framing for a LOD2 render, so they line up). */
+    readonly frameFrom?: CompiledAsset;
+}
+export interface BeautyRender {
+    readonly width: number;
+    readonly height: number;
+    /** RGBA8, sRGB, opaque. */
+    readonly rgba: Uint8Array;
+    /** Asset coverage per pixel, 0–255 (the silhouette, antialiased). */
+    readonly mask: Uint8Array;
+    /** Distinct triangles visible per cell of a 16 × 9 grid — where the detail is. */
+    readonly detail: Uint32Array;
+}
+export declare function cameraFor(asset: CompiledAsset, o?: BeautyOptions): PerspectiveCamera;
+export declare function renderBeauty(asset: CompiledAsset, o?: BeautyOptions): BeautyRender;
+/** The beauty render as PNG bytes. */
+export declare function beauty(asset: CompiledAsset, o?: BeautyOptions): Uint8Array;

package/dist/render/camera.d.ts

@@ -0,0 +1,33 @@
+export interface PerspectiveCamera {
+    readonly eye: readonly [number, number, number];
+    /** Unit right, up, forward (view direction). */
+    readonly r: readonly [number, number, number];
+    readonly u: readonly [number, number, number];
+    readonly f: readonly [number, number, number];
+    /** Pixels per unit of tan(angle) — the focal length in pixels. */
+    readonly focal: number;
+    readonly cx: number;
+    readonly cy: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface Orbit {
+    readonly azDeg: number;
+    readonly elDeg: number;
+    readonly fovDeg: number;
+    /** Fraction of the frame the asset may fill (0–1). */
+    readonly fill: number;
+}
+type V3 = [number, number, number];
+/** Project world xyz → [screen x, screen y, view depth]. Depth ≤ 0 means behind the eye. */
+export declare function project(c: PerspectiveCamera, x: number, y: number, z: number): V3;
+/**
+ * Orbit camera framing `points` (xyz triples, world) in a width × height image. Iterates a few
+ * times: re-centre on the projected extent, then dolly so the larger axis fills `fill`.
+ */
+export declare function frameOrbit(points: Float32Array, o: Orbit, width: number, height: number): PerspectiveCamera;
+/** The same shot through a zoomed window: (nx, ny) ∈ [0,1]² is the window centre, k the zoom. */
+export declare function zoomWindow(c: PerspectiveCamera, nx: number, ny: number, k: number): PerspectiveCamera;
+/** Same camera at another resolution (supersampling): every pixel quantity scales by s. */
+export declare function scaled(c: PerspectiveCamera, s: number): PerspectiveCamera;
+export {};

package/dist/render/depth-map.d.ts

@@ -0,0 +1,38 @@
+import type { Scene } from './scene.js';
+export interface DepthMap {
+    readonly size: number;
+    /** −Infinity where nothing was drawn. */
+    readonly data: Float32Array;
+    readonly dir: readonly [number, number, number];
+    readonly r: readonly [number, number, number];
+    readonly u: readonly [number, number, number];
+    /** Texel coordinate = (dot(p, r) − r0) · k, (u1 − dot(p, u)) · k. */
+    readonly r0: number;
+    readonly u1: number;
+    readonly k: number;
+}
+/** Map frame in the map's own (r, u) coordinates: centre and half-extent, metres. */
+export interface MapFrame {
+    readonly cr: number;
+    readonly cu: number;
+    readonly half: number;
+}
+export type MapAlpha = (tri: number, b1: number, b2: number) => boolean;
+export declare function mapAxes(dir: readonly [number, number, number]): {
+    r: [number, number, number];
+    u: [number, number, number];
+};
+/** The frame that just contains the scene seen along `dir`, with a 2% margin. */
+export declare function fitFrame(s: Scene, dir: readonly [number, number, number]): MapFrame;
+export declare function depthMap(s: Scene, dir: readonly [number, number, number], size: number, frame?: MapFrame, alpha?: MapAlpha): DepthMap;
+/**
+ * Fraction of `taps` (pairs of texel offsets) at which world point (x,y,z) sees past the map —
+ * 1 = fully lit/open, 0 = fully occluded. `bias` in metres along the map direction.
+ */
+export declare function visibility(m: DepthMap, x: number, y: number, z: number, bias: number, taps: Float32Array): number;
+/**
+ * Ambient openness at (x,y,z) along the map direction, 0…1: an occluder `reach` metres or more
+ * away counts for nothing, nearer ones linearly more — AO with a falloff, so a few sky directions
+ * give a soft contact shadow instead of long streaks.
+ */
+export declare function openness(m: DepthMap, x: number, y: number, z: number, bias: number, reach: number): number;

package/dist/render/font.d.ts

@@ -0,0 +1 @@
+export declare function drawText(px: Uint8Array, width: number, x: number, y: number, text: string, scale: number, rgb: readonly [number, number, number]): void;

package/dist/render/ground.d.ts

@@ -0,0 +1,13 @@
+import type { PerspectiveCamera } from './camera.js';
+import { type ShadeContext } from './shade.js';
+export interface FloorGrid {
+    readonly z: number;
+    readonly x0: number;
+    readonly y0: number;
+    readonly cell: number;
+    readonly size: number;
+    readonly light: Float32Array;
+}
+export declare function floorGrid(c: ShadeContext, size: number): FloorGrid;
+/** Floor light where the eye ray through pixel (px, py) meets the floor; 1 off the grid/above. */
+export declare function floorLight(g: FloorGrid, cam: PerspectiveCamera, px: number, py: number): number;

package/dist/render/index.d.ts

@@ -0,0 +1,10 @@
+export { type BeautyOptions, type BeautyRender, beauty, cameraFor, renderBeauty, } from './beauty.js';
+export type { PerspectiveCamera } from './camera.js';
+export { type LodStripOptions, lodStrip } from './lod-strip.js';
+export { type ExposureStats, exposure, type MaskStats, maskIoU, maskStats, poolMask, type Silhouette, silhouette, viewFrame, } from './metrics.js';
+export { checkBeautyOptions, parseSize } from './options.js';
+export { type PhotoCamera, type PhotoMatchOptions, photoMatch } from './photo-match.js';
+export { detailWindows, type ReviewOptions, type ReviewPack, reviewPack } from './review.js';
+export { REVIEW_THRESHOLDS, type ReviewMetrics, type ReviewWarning, type ViewMetrics, } from './review-warnings.js';
+export { contactSheet, type SheetOptions, VIEWS } from './sheet.js';
+export { type ThumbnailOptions, thumbnail } from './thumbnail.js';

package/dist/render/index.js

@@ -0,0 +1,47 @@
+import {
+  checkBeautyOptions2,
+  parseSize2,
+  cameraFor2,
+  renderBeauty2,
+  beauty2,
+  lodStrip2,
+  viewFrame2,
+  silhouette2,
+  maskIoU2,
+  poolMask2,
+  maskStats2,
+  exposure2,
+  photoMatch2,
+  REVIEW_THRESHOLDS2,
+  VIEWS2,
+  contactSheet2,
+  detailWindows2,
+  reviewPack2,
+  thumbnail2
+} from "../chunk-11v28977.js";
+import"../chunk-kvcep7ft.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  REVIEW_THRESHOLDS2 as REVIEW_THRESHOLDS,
+  VIEWS2 as VIEWS,
+  beauty2 as beauty,
+  cameraFor2 as cameraFor,
+  checkBeautyOptions2 as checkBeautyOptions,
+  contactSheet2 as contactSheet,
+  detailWindows2 as detailWindows,
+  exposure2 as exposure,
+  lodStrip2 as lodStrip,
+  maskIoU2 as maskIoU,
+  maskStats2 as maskStats,
+  parseSize2 as parseSize,
+  photoMatch2 as photoMatch,
+  poolMask2 as poolMask,
+  renderBeauty2 as renderBeauty,
+  reviewPack2 as reviewPack,
+  silhouette2 as silhouette,
+  thumbnail2 as thumbnail,
+  viewFrame2 as viewFrame
+};
+
+//# debugId=ACEDB64D436D758764756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/render/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "ACEDB64D436D758764756E2164756E21",
+  "names": []
+}

package/dist/render/lighting.d.ts

@@ -0,0 +1,20 @@
+export type V3 = [number, number, number];
+export interface Rig {
+    /** Unit vector toward the sun. */
+    readonly sun: V3;
+    readonly sunColor: V3;
+    readonly sky: V3;
+    readonly bounce: V3;
+    /** Unit vectors toward the sky, upper hemisphere, for the AO maps. */
+    readonly skyDirs: readonly V3[];
+    readonly exposure: number;
+}
+export declare function studioRig(cameraAzDeg: number): Rig;
+export declare function pcfTaps(radius: number): Float32Array[];
+/**
+ * Tone curve, linear in → linear display out: identity up to 0.6 (mid-tones and the palette stay
+ * true), then a smooth exponential shoulder that rolls highlights into 1 without clipping.
+ */
+export declare function tone(x: number): number;
+export declare const toSrgb8: (v: number) => number;
+export declare const fromSrgb: (v: number) => number;

package/dist/render/lod-strip.d.ts

@@ -0,0 +1,5 @@
+import { type CompiledAsset } from '../core/index.js';
+import { type BeautyOptions } from './beauty.js';
+export interface LodStripOptions extends Omit<BeautyOptions, 'frameFrom' | 'window'> {
+}
+export declare function lodStrip(lods: readonly CompiledAsset[], o?: LodStripOptions): Uint8Array;

package/dist/render/metrics.d.ts

@@ -0,0 +1,37 @@
+import { type CompiledAsset } from '../core/index.js';
+import { type MapFrame } from './depth-map.js';
+import type { View } from './raster.js';
+export interface Silhouette {
+    readonly size: number;
+    /** 1 = asset, 0 = empty. */
+    readonly mask: Uint8Array;
+}
+export interface MaskStats {
+    /** Fraction of the image the silhouette covers. */
+    readonly coverage: number;
+    /** Fraction of the silhouette's own bounding box it fills (low = spindly or scattered). */
+    readonly bboxFill: number;
+}
+/** The frame that fits `asset` seen along `view` — pass it to silhouettes of other LODs. */
+export declare function viewFrame(asset: CompiledAsset, view: View): MapFrame;
+export declare function silhouette(asset: CompiledAsset, view: View, size?: number, frame?: MapFrame): Silhouette;
+/** Intersection over union of two same-sized masks (nonzero = inside). Two empty masks → 1. */
+export declare function maskIoU(a: Uint8Array, b: Uint8Array): number;
+/** Max-pool a mask by `f` (any covered texel covers the block): the silhouette as seen from afar,
+ * where lattice gaps and leaf holes close up — what LOD2 has to match. */
+export declare function poolMask(s: Silhouette, f: number): Silhouette;
+export declare function maskStats(s: Silhouette): MaskStats;
+export interface ExposureStats {
+    /** Fraction of the frame the asset covers. */
+    readonly coverage: number;
+    /** The asset's screen bounding box as a fraction of the frame, larger axis (≈ 0.8 when framed). */
+    readonly span: number;
+    /** Mean relative luminance (0–1, sRGB-encoded values) over asset pixels. */
+    readonly mean: number;
+    /** Standard deviation of that luminance — low = flat, unreadable shading. */
+    readonly contrast: number;
+    readonly nearBlack: number;
+    readonly nearWhite: number;
+}
+/** Exposure of a rendered RGBA image (`width` px wide) over the pixels where `mask` ≥ 128. */
+export declare function exposure(rgba: Uint8Array, mask: Uint8Array, width: number): ExposureStats;

package/dist/render/options.d.ts

@@ -0,0 +1,28 @@
+export interface CheckedBeauty {
+    readonly width: number;
+    readonly height: number;
+    readonly azDeg: number;
+    readonly elDeg: number;
+    readonly fovDeg: number;
+    readonly supersample: number;
+}
+interface Raw {
+    readonly width?: number;
+    readonly height?: number;
+    readonly azDeg?: number;
+    readonly elDeg?: number;
+    readonly fovDeg?: number;
+    readonly supersample?: number;
+    readonly window?: {
+        readonly x: number;
+        readonly y: number;
+        readonly zoom: number;
+    };
+}
+export declare function checkBeautyOptions(o: Raw): CheckedBeauty;
+/** Parse a `WxH` size flag ("1600x900"). */
+export declare function parseSize(text: string): {
+    width: number;
+    height: number;
+};
+export {};

package/dist/render/photo-match.d.ts

@@ -0,0 +1,19 @@
+import { type CompiledAsset, type Vec3 } from '../core/index.js';
+export interface PhotoCamera {
+    /** Camera position and look-at target in asset space (metres, Z up). */
+    readonly eye: Vec3;
+    readonly target: Vec3;
+    /** Vertical field of view, degrees. */
+    readonly fovDeg: number;
+}
+export interface PhotoMatchOptions {
+    readonly photo: Uint8Array;
+    /** Solve the camera from ≥ 4 marked correspondences instead of passing it (planned with it). */
+    readonly camera: PhotoCamera;
+    readonly width?: number;
+}
+/** Returns a PNG: photo on top, model in the middle, overlay at the bottom; plus silhouette IoU. */
+export declare function photoMatch(_asset: CompiledAsset, _o: PhotoMatchOptions): {
+    png: Uint8Array;
+    iou: number;
+};

package/dist/render/raster.d.ts

@@ -0,0 +1,25 @@
+import type { CompiledAsset, Vec3 } from '../core/index.js';
+export interface View {
+    readonly label: string;
+    /** Direction the camera looks along (world, Z up). */
+    readonly dir: Vec3;
+    readonly up: Vec3;
+}
+export interface Target {
+    readonly px: Uint8Array;
+    readonly depth: Float32Array;
+    readonly width: number;
+    readonly height: number;
+}
+export interface Camera {
+    project(p: Vec3): Vec3;
+}
+export declare function orthoCamera(view: View, centre: Vec3, extent: number, size: number): Camera;
+export declare function worldParts(asset: CompiledAsset): {
+    positions: Float32Array;
+    normals: Float32Array;
+    colors: Float32Array;
+    indices: Uint32Array;
+}[];
+export declare function drawAsset(t: Target, cam: Camera, asset: CompiledAsset): void;
+export declare function line(t: Target, a: Vec3, b: Vec3, rgb: Vec3): void;

package/dist/render/resolve.d.ts

@@ -0,0 +1,11 @@
+import type { FloorGrid } from './ground.js';
+import { type ShadeContext } from './shade.js';
+import type { VisBuffer } from './vis-buffer.js';
+export interface Resolved {
+    readonly width: number;
+    readonly height: number;
+    readonly rgba: Uint8Array;
+    readonly mask: Uint8Array;
+    readonly detail: Uint32Array;
+}
+export declare function resolve(ctx: ShadeContext, vis: VisBuffer, floor: FloorGrid, width: number, height: number, ss: number): Resolved;

package/dist/render/review-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { ReviewMetrics } from './review-warnings.js';
+export declare function reviewPrompt(m: ReviewMetrics, files: readonly string[], refs?: string): string;