@developerz.ai/ts23d 0.0.0-stage → 0.2.0

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 1024² 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-f6yme003.js";
+import"../chunk-y63c6zcv.js";
+import"../chunk-hg7pf34j.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,27 @@
+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;
+/**
+ * The studio environment a reflection sees, channel `k`, along a reflection vector with up
+ * component `rz`: a bright cyclorama horizon fading to a cooler zenith, a dark band where the
+ * floor meets the wall, the lit floor below. Roughness pre-blurs it toward its mean, so polished
+ * metal shows the horizon line and rough metal a soft gradient — what makes metal read as metal.
+ */
+export declare function envRadiance(rz: number, rough: number, k: number): number;
+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;

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

@@ -0,0 +1,34 @@
+import type { ExposureStats, MaskStats } from './metrics.js';
+export interface ViewMetrics {
+    readonly view: string;
+    readonly lod0: MaskStats;
+    readonly lod2: MaskStats;
+    /** Silhouette IoU LOD0 ↔ LOD2 as seen from afar (64² max-pooled masks, same frame). Low = popping. */
+    readonly lodIoU: number;
+    /** The same at full mask resolution (256²): lattices and foliage score low here by nature. */
+    readonly lodIoUExact: number;
+}
+export interface ReviewWarning {
+    readonly code: string;
+    readonly message: string;
+    readonly fix: string;
+}
+export interface ReviewMetrics {
+    readonly asset: string;
+    readonly triangles: readonly number[];
+    readonly hero: ExposureStats;
+    readonly views: readonly ViewMetrics[];
+    readonly warnings: readonly ReviewWarning[];
+}
+export declare const REVIEW_THRESHOLDS: {
+    /** LOD0 ↔ LOD2 silhouette IoU below this in any view = visible popping. */
+    readonly lodIoU: 0.8;
+    readonly heroMeanMin: 0.18;
+    readonly heroMeanMax: 0.85;
+    readonly heroContrastMin: 0.06;
+    readonly nearBlackMax: 0.2;
+    readonly nearWhiteMax: 0.1;
+    /** Asset spanning less of the hero frame than this: something stretches the bounds. */
+    readonly heroSpanMin: 0.5;
+};
+export declare function warningsOf(m: Omit<ReviewMetrics, 'warnings'>): ReviewWarning[];

package/dist/render/review.d.ts

@@ -0,0 +1,24 @@
+import { type Asset } from '../core/index.js';
+import type { PaintedSheet } from '../material/index.js';
+import { type ReviewMetrics } from './review-warnings.js';
+export interface ReviewOptions {
+    readonly sheet?: PaintedSheet;
+    readonly width?: number;
+    readonly height?: number;
+    readonly azDeg?: number;
+    readonly elDeg?: number;
+    readonly fovDeg?: number;
+    /** Path of the reference dossier (recipes/<name>/README.md) the prompt points the reviewer at. */
+    readonly refs?: string;
+}
+export interface ReviewPack {
+    /** File name (inside the review folder) → contents. */
+    readonly files: ReadonlyMap<string, Uint8Array | string>;
+    readonly metrics: ReviewMetrics;
+}
+/** Two zoom windows centred on the densest cells of the hero's 16 × 9 detail grid, ≥ 4 cells apart. */
+export declare function detailWindows(detail: Uint32Array): {
+    x: number;
+    y: number;
+}[];
+export declare function reviewPack(asset: Asset, o?: ReviewOptions): ReviewPack;

package/dist/render/scene.d.ts

@@ -0,0 +1,18 @@
+import { type CompiledAsset, type Surface } from '../core/index.js';
+export declare const SURFACE_CODE: Readonly<Record<Surface, number>>;
+export interface Scene {
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly uvs: Float32Array;
+    readonly colors: Float32Array;
+    /** Three global vertex indices per triangle. */
+    readonly indices: Uint32Array;
+    /** SURFACE_CODE per triangle. */
+    readonly surface: Uint8Array;
+    /** Per-triangle tangent frame for the normal map, 6 floats: T = dP/dU, B = −dP/dV (glTF +Y). */
+    readonly tangents: Float32Array;
+    readonly min: readonly [number, number, number];
+    readonly max: readonly [number, number, number];
+    readonly triangles: number;
+}
+export declare function sceneOf(asset: CompiledAsset): Scene;

package/dist/render/shade.d.ts

@@ -0,0 +1,22 @@
+import type { PerspectiveCamera } from './camera.js';
+import { type DepthMap } from './depth-map.js';
+import { type Rig } from './lighting.js';
+import type { Scene } from './scene.js';
+import { type SheetTextures } from './texture.js';
+export interface ShadeContext {
+    readonly scene: Scene;
+    readonly cam: PerspectiveCamera;
+    readonly tex: SheetTextures;
+    readonly rig: Rig;
+    readonly sunMap: DepthMap;
+    readonly aoMaps: readonly DepthMap[];
+    readonly pcf: readonly Float32Array[];
+    /** AO falloff distance, metres: occluders farther than this along a sky direction don't count. */
+    readonly reach: number;
+}
+/** Sky openness at p for a surface facing n: cosine-weighted share of unoccluded sky directions. */
+export declare function skyOpen(c: ShadeContext, p: readonly number[], n: readonly number[]): number;
+/** Sun visibility at p (geometric normal n), PCF with one of four rotated tap sets. */
+export declare function sunVisible(c: ShadeContext, p: readonly number[], n: readonly number[], set: number): number;
+/** Linear radiance of triangle `t` at barycentrics (b1, b2) into out[0..2]. */
+export declare function shadeSample(c: ShadeContext, t: number, b1: number, b2: number, mip: number, set: number, out: Float32Array): void;

package/dist/render/sheet.d.ts

@@ -0,0 +1,15 @@
+import { type CompiledAsset, type Vec3 } from '../core/index.js';
+import { type View } from './raster.js';
+export declare const VIEWS: readonly View[];
+export declare function bounds(asset: CompiledAsset): {
+    centre: Vec3;
+    extent: number;
+    min: Vec3;
+    max: Vec3;
+};
+export interface SheetOptions {
+    readonly cell?: number;
+    /** The far view's asset — compile the same recipe at LOD 2 and pass it here. */
+    readonly far?: CompiledAsset;
+}
+export declare function contactSheet(asset: CompiledAsset, o?: SheetOptions): Uint8Array;

package/dist/render/texture.d.ts

@@ -0,0 +1,15 @@
+import type { PaintedSheet } from '../material/index.js';
+export interface Mip {
+    readonly size: number;
+    /** 4 floats per texel. */
+    readonly data: Float32Array;
+}
+export interface SheetTextures {
+    readonly size: number;
+    readonly albedo: readonly Mip[];
+    readonly normal: readonly Mip[];
+    readonly orm: readonly Mip[];
+}
+export declare function sheetTextures(sheet: PaintedSheet): SheetTextures;
+/** Bilinear sample of mip `level` at (u, v) into out[0..3]. */
+export declare function sample(mips: readonly Mip[], level: number, u: number, v: number, out: Float32Array): void;

package/dist/render/thumbnail.d.ts

@@ -0,0 +1,8 @@
+import { type CompiledAsset } from '../core/index.js';
+import { type View } from './raster.js';
+export interface ThumbnailOptions {
+    /** Output edge in pixels (square). Default 512. */
+    readonly size?: number;
+    readonly view?: View;
+}
+export declare function thumbnail(asset: CompiledAsset, o?: ThumbnailOptions): Uint8Array;

package/dist/render/vis-buffer.d.ts

@@ -0,0 +1,18 @@
+import type { PerspectiveCamera } from './camera.js';
+import type { Scene } from './scene.js';
+export interface VisBuffer {
+    readonly width: number;
+    readonly height: number;
+    /** Triangle id per pixel, −1 = background. */
+    readonly tri: Int32Array;
+    /** Perspective-correct barycentrics of vertices 1 and 2 (vertex 0 = 1 − b1 − b2). */
+    readonly b1: Float32Array;
+    readonly b2: Float32Array;
+    /** 1 / view depth (larger = nearer). */
+    readonly invw: Float32Array;
+    /** Per-triangle texture mip level from its texel : pixel footprint. */
+    readonly mip: Uint8Array;
+}
+/** Return false to discard a fragment (alpha-tested cutouts). */
+export type AlphaTest = (tri: number, b1: number, b2: number, mip: number) => boolean;
+export declare function rasteriseVis(s: Scene, cam: PerspectiveCamera, texSize: number, alpha?: AlphaTest): VisBuffer;

package/dist/testing/assert.d.ts

@@ -0,0 +1,21 @@
+import type { Asset, Lod, Measure } from '../core/index.js';
+import { type Gate, type LodGate } from '../qa/index.js';
+import { type LodOptions } from './compiled.js';
+export interface QaOptions extends LodOptions {
+    /** Per-LOD gates. Default the build's DEFAULT_GATES. */
+    readonly gates?: readonly Gate[];
+    /** Chain gates over all compiled LODs. Default DEFAULT_LOD_GATES. */
+    readonly lodGates?: readonly LodGate[];
+}
+/** The same gate `t3d build` runs: every LOD passes QA, plus the LOD-chain gates. */
+export declare function assertQaPass(asset: Asset, o?: QaOptions): void;
+/** Triangles per LOD at or under `caps` (default: the asset's own budget). */
+export declare function assertBudget(asset: Asset, caps?: readonly [number, number, number], o?: LodOptions): void;
+/** Each selector (name or glob) matches at least one part at every LOD checked. */
+export declare function assertParts(asset: Asset, selectors: readonly string[], o?: LodOptions): void;
+/** One spec dimension at LOD0, the way the `measures` gate checks `real.measures`. */
+export declare function assertMeasure(asset: Asset, m: Measure, o?: {
+    lod?: Lod;
+}): number;
+/** Every moving part sweeps clear of everything else (the `clashes` gate), at every LOD. */
+export declare function assertMotionClear(asset: Asset, o?: LodOptions): void;

package/dist/testing/compiled.d.ts

@@ -0,0 +1,15 @@
+import { type Asset, type CompiledAsset, type Lod } from '../core/index.js';
+import type { Finding } from '../qa/index.js';
+export interface LodOptions {
+    /** LODs to check. Default all three. */
+    readonly lods?: readonly Lod[];
+    readonly seed?: number;
+}
+export declare const ALL_LODS: readonly Lod[];
+export declare const compileLods: (asset: Asset, o?: LodOptions) => CompiledAsset[];
+export declare const describeFinding: (f: Finding, lod?: Lod) => string;
+/** Throw T3D_QA_FAILED listing every finding; no-op when there are none. */
+export declare function failOn(what: string, found: ReadonlyArray<{
+    finding: Finding;
+    lod?: Lod;
+}>): void;

package/dist/testing/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashBytes(bytes: Uint8Array): string;

package/dist/testing/index.d.ts

@@ -0,0 +1,4 @@
+export { assertBudget, assertMeasure, assertMotionClear, assertParts, assertQaPass, type QaOptions, } from './assert.js';
+export { ALL_LODS, compileLods, describeFinding, type LodOptions } from './compiled.js';
+export { hashBytes } from './hash.js';
+export { assertDeterministic, type SnapshotOptions, snapshotHash } from './snapshot.js';