@zkmake/three-audit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zubin Khavarian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# @zkmake/three-audit
+
+Checks for a three.js scene: what it costs and what's wrong with it. Triangle counts, the meshes and
+geometries behind them, z-fighting, NaN geometry, black frames, and a ledger of every draw call in
+one frame. Zero dependencies. The geometry checks need no renderer, so they run in a unit test as
+well as the browser console.
+
+```sh
+bun add -d @zkmake/three-audit   # or npm i -D / pnpm add -D
+```
+
+## In a test
+
+Build the object the way the app does and assert it's clean:
+
+```ts
+import { findBadGeometry, findZFighting } from "@zkmake/three-audit";
+import { expect, test } from "vitest";
+
+import { buildWindmill } from "../src/windmill.ts";
+
+test("windmill has no z-fighting and no NaN geometry", () => {
+  const windmill = buildWindmill();
+
+  expect(findZFighting(windmill)).toEqual([]);
+  expect(findBadGeometry(windmill)).toEqual([]);
+});
+```
+
+A failure lists each pair of meshes with faces in one plane, facing the same way, overlapping:
+
+```
+[{ a: "windmill/plinth [stone] @ (0, 0.1, 0)", b: "windmill/wall [plaster] @ (0, 0.5, 0)", triangles: 4 }]
+```
+
+## In the console
+
+```ts
+import { installAuditHelpers } from "@zkmake/three-audit";
+
+installAuditHelpers(scene, { renderer }); // returns a function that removes them
+```
+
+React Three Fiber:
+
+```tsx
+const { scene, gl } = useThree();
+
+useLayoutEffect(() => installAuditHelpers(scene, { renderer: gl }), [scene, gl]);
+```
+
+| Global                | Returns                                                                             |
+| --------------------- | ----------------------------------------------------------------------------------- |
+| `tris()`              | Triangles one pass draws: visible meshes, instances and batches counted, no culling |
+| `meshes()`            | Every visible mesh: triangles, instances, total, most first                         |
+| `census()`            | Geometries by triangles drawn, hidden meshes included                               |
+| `audit()`             | Meshes with NaN positions or normals, or zero-length normals                        |
+| `zfight(gap?, self?)` | Pairs of meshes that z-fight                                                        |
+| `report()`            | All of the above in one JSON-safe object                                            |
+| `ledger()`            | One frame's draw calls by object and pass, printed as tables (WebGL)                |
+| `blackFrames(10)`     | Frames in the next 10 s that came out black (WebGL)                                 |
+
+From a headless browser: `agent-browser eval 'JSON.stringify(report())'`.
+
+## The checks
+
+### `findZFighting(root, options?)`
+
+Triangles are bucketed by plane (normal and offset), then tested for overlap in their shared plane.
+World space, so parent transforms count.
+
+- `gap` (default `0.004`): how close two planes count as one, in world units. 4 mm at 1 unit = 1 m is
+  about what depth precision loses with a camera ~50 m out. Scale it with your units.
+- `self`: also compare triangles within one mesh, for merged geometry.
+- `tagged`: only meshes inside an object with `userData.studioObject` (or `tagKey`). Defaults to on
+  when anything under the root is tagged, so a studio's ground and props stay out.
+- `skip(object)`: leave an object and its subtree out, e.g. a merged copy whose sources are still in
+  the scene: `skip: (o) => o.userData.bakedResult === true`.
+
+Instanced and batched meshes are skipped: check their source parts as plain meshes.
+
+Typical fixes: stand the smaller part 5 mm off, shorten it inside the larger one, or fit panels
+between each other instead of over each other's ends.
+
+### `findBadGeometry(root, options?)`
+
+Vertices with a non-finite position or normal, and zero-length normals on triangles with area.
+Either lights a pixel NaN, and bloom smears one NaN pixel into a black block.
+
+### `countTriangles`, `listMeshes`, `geometryCensus`
+
+Where a triangle budget goes. Name meshes and geometries (`mesh.name`, `geometry.name`) so the rows
+say something. Draw ranges are respected; a shadow pass adds roughly as much again per light.
+
+### `recordDrawLedger(renderer)` / `beginDrawLedger(renderer)`
+
+Wraps `WebGLRenderer.renderBufferDirect` and counts every draw by object name, by group (the name up
+to its first `:` or `#`), and by pass: `shadow`, then each `render()` call by scene name, or
+`render 1`, `render 2`… `recordDrawLedger` records exactly one animation frame; `beginDrawLedger`
+returns `{ end() }` for any span. `printDrawLedger` prints the tables.
+
+### `watchBlackFrames(renderer)`
+
+After each render to the screen, reads a 3 × 3 grid of pixels and counts frames where three or more
+are pure black. Use a visible browser: headless ones haven't reproduced black frames. Each read
+stalls the GPU, so watch, read `blackFrames`, `stop()`.
+
+### `auditScene(root, options?)`
+
+`{ triangles, zFighting, badGeometry, meshes }` in one call. Rows carry the live mesh as a
+non-enumerable property (`row.mesh`, `row.meshes`), so they print and serialise without dragging the
+scene along.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,209 @@
+import { BufferGeometry, Camera, Material, Mesh, Object3D, Scene } from "three";
+//#region src/scene.d.ts
+/** Leave an object and everything under it out of a check. */
+type Skip = (object: Object3D) => boolean;
+/** Triangles one draw of this geometry makes: indexed or not, within its draw range. */
+export declare const triangleCount: (geometry: BufferGeometry) => number;
+//#endregion
+//#region src/bad-geometry.d.ts
+type BadGeometryOptions = {
+  skip?: Skip | undefined;
+  /** `userData` key naming the part a mesh belongs to, for the `under` column. */
+  tagKey?: string;
+};
+type BadGeometryRow = {
+  mesh: string;
+  /** The tagged part it sits in, or its parent's name. */
+  under: string;
+  /** Vertices with a NaN or infinite position or normal component. */
+  nonFinite: number;
+  /** Vertices of triangles with area whose normal has no length. */
+  zeroNormals: number;
+  /** Not enumerable: kept out of JSON and `console.table`. */
+  readonly object: Mesh;
+};
+/** Meshes with geometry that renders NaN, hidden ones included. `[]` is a pass. */
+export declare const findBadGeometry: (root: Object3D, options?: BadGeometryOptions) => BadGeometryRow[];
+//#endregion
+//#region src/triangles.d.ts
+type TriangleOptions = {
+  skip?: Skip | undefined;
+};
+type MeshRow = {
+  name: string;
+  /** Triangles in one copy (a batch's average). */
+  triangles: number;
+  instances: number;
+  total: number;
+  /** Not enumerable: kept out of JSON and `console.table`. */
+  readonly mesh: Mesh;
+};
+type GeometryRow = {
+  /** `geometry.name`, or its type and the start of its uuid. */
+  geometry: string;
+  /** Copies drawn: every mesh using it, instances counted. */
+  uses: number;
+  triangles: number;
+  total: number;
+};
+/**
+ * Triangles one pass draws: visible meshes, instances counted, no frustum culling. A shadow pass
+ * adds roughly as much again for each shadow-casting light.
+ */
+export declare const countTriangles: (root: Object3D, options?: TriangleOptions) => number;
+/** Every visible mesh, most triangles drawn first. */
+export declare const listMeshes: (root: Object3D, options?: TriangleOptions) => MeshRow[];
+/**
+ * Geometries by triangles drawn, hidden meshes included, most first. Name geometries
+ * (`geometry.name`) to make this readable. Batches are left out: their shared buffer is not one
+ * geometry; `listMeshes` counts them.
+ */
+export declare const geometryCensus: (root: Object3D, options?: TriangleOptions) => GeometryRow[];
+//#endregion
+//#region src/z-fighting.d.ts
+type ZFightingOptions = {
+  /**
+   * How close two planes count as one, in world units. 0.004 (4 mm at 1 unit = 1 m) is about what
+   * depth precision loses with a camera ~50 m out. Scale it with your units.
+   */
+  gap?: number;
+  /** Also compare triangles within one mesh: for merged geometry whose parts share a buffer. */
+  self?: boolean;
+  /**
+   * Only meshes inside a tagged object (`userData[tagKey]`), so a studio's ground and props stay
+   * out. Defaults to true when anything under the root is tagged, false otherwise.
+   */
+  tagged?: boolean;
+  tagKey?: string;
+  skip?: Skip | undefined;
+};
+type ZFightingRow = {
+  /** `tag/mesh [material] @ (x, y, z)`, the centre in world space. */
+  a: string;
+  b: string;
+  /** Overlapping triangle pairs between the two. */
+  triangles: number;
+  /** Not enumerable: kept out of JSON and `console.table`. */
+  readonly meshes: readonly [Mesh, Mesh];
+};
+/** Pairs of meshes that z-fight, most overlapping triangles first. `[]` is a pass. */
+export declare const findZFighting: (root: Object3D, options?: ZFightingOptions) => ZFightingRow[];
+//#endregion
+//#region src/audit-scene.d.ts
+type AuditSceneOptions = Pick<ZFightingOptions, "gap" | "self" | "tagged"> & {
+  skip?: Skip | undefined;
+  tagKey?: string;
+  /** How many of the costliest meshes to list. */
+  top?: number;
+};
+type AuditReport = {
+  triangles: number;
+  zFighting: ZFightingRow[];
+  badGeometry: BadGeometryRow[];
+  /** The costliest meshes, most triangles first. */
+  meshes: MeshRow[];
+};
+/**
+ * Every check at once, JSON-safe: what a test asserts on or a headless browser prints. A clean
+ * scene has `zFighting` and `badGeometry` both `[]`.
+ */
+export declare const auditScene: (root: Object3D, options?: AuditSceneOptions) => AuditReport;
+//#endregion
+//#region src/black-frames.d.ts
+/** The `WebGLRenderer` methods the probe uses. */
+type ProbeRenderer = {
+  render(scene: Object3D, camera: Camera): void;
+  getContext(): unknown;
+  getRenderTarget(): unknown;
+};
+type BlackFrameOptions = {
+  /** Samples per side: 3 reads a 3 × 3 grid at the quarter lines. */
+  grid?: number;
+  /** Black samples that make a frame black. */
+  threshold?: number;
+};
+type BlackFrameWatch = {
+  /** Frames sampled since the start or the last `reset()`. */
+  readonly frames: number;
+  /** Which of those frames (1-based) were black. */
+  readonly blackFrames: readonly number[];
+  reset: () => void;
+  /** Restore the renderer and stop sampling. */
+  stop: () => void;
+};
+/**
+ * Sample every frame the app draws to the screen. Several screen renders in one frame (an overlay
+ * redrawn after the composer) count once, as the last of them: the image the display shows.
+ * Browser only: frames are told apart by `requestAnimationFrame`.
+ */
+export declare const watchBlackFrames: (renderer: ProbeRenderer, options?: BlackFrameOptions) => BlackFrameWatch;
+//#endregion
+//#region src/draw-ledger.d.ts
+/** The two `WebGLRenderer` methods the ledger wraps. */
+type LedgerRenderer = {
+  render(scene: Object3D, camera: Camera): void;
+  renderBufferDirect(camera: Camera, scene: Scene | null, geometry: BufferGeometry, material: Material, object: Object3D, group: unknown): void;
+};
+type DrawLedgerOptions = {
+  /**
+   * The group an object name files under. Default: up to the first `:` or `#`, so a bake's
+   * `wagon:paint` and a strip's `grass#3` group as `wagon` and `grass`.
+   */
+  groupOf?: (name: string) => string;
+};
+type LedgerRow = {
+  name: string;
+  total: number;
+  /** Draws per pass name. */
+  passes: Record<string, number>;
+};
+type DrawLedger = {
+  /**
+   * Pass names in the order they first drew: `shadow`, then each `render()` call as its scene's
+   * name, or `render 1`, `render 2`… when unnamed (a post-processing chain is several).
+   */
+  passes: string[];
+  /** By group, most draws first. */
+  groups: LedgerRow[];
+  /** By object name, most draws first. */
+  objects: LedgerRow[];
+  draws: number;
+};
+type DrawLedgerRecording = {
+  /** Restore the renderer and return what was drawn since `beginDrawLedger`. */
+  end: () => DrawLedger;
+};
+/** Start counting every draw. Call `end()` after the frame to restore the renderer and read it. */
+export declare const beginDrawLedger: (renderer: LedgerRenderer, options?: DrawLedgerOptions) => DrawLedgerRecording;
+/**
+ * Record exactly one frame of an app that renders from `requestAnimationFrame` (three's
+ * `setAnimationLoop`, React Three Fiber): from one animation frame to the next. A demand-driven
+ * loop that renders nothing that frame gives an empty ledger. Browser only.
+ */
+export declare const recordDrawLedger: (renderer: LedgerRenderer, options?: DrawLedgerOptions) => Promise<DrawLedger>;
+/** Rows shaped for `console.table`: one column per pass, then the total. */
+export declare const ledgerTable: (rows: LedgerRow[], passes: string[]) => {
+  name: string;
+  total: number;
+}[];
+/** The ledger as two console tables: by group, and every object collapsed beneath. */
+export declare const printDrawLedger: (ledger: DrawLedger) => void;
+//#endregion
+//#region src/console-helpers.d.ts
+type AuditHelpersOptions = {
+  /** A `WebGLRenderer`, for `ledger()` and `blackFrames()`. */
+  renderer?: (LedgerRenderer & ProbeRenderer) | undefined;
+  skip?: Skip | undefined;
+  tagKey?: string;
+};
+/**
+ * Put the helpers on `globalThis`. Returns a function that removes them.
+ *
+ *   vanilla: installAuditHelpers(scene, { renderer })
+ *   R3F:     const { scene, gl } = useThree();
+ *            useLayoutEffect(() => installAuditHelpers(scene, { renderer: gl }), [scene, gl]);
+ */
+export declare const installAuditHelpers: (root: Object3D, options?: AuditHelpersOptions) => () => void;
+//#endregion
+export type { AuditHelpersOptions, AuditReport, AuditSceneOptions, BadGeometryOptions, BadGeometryRow, BlackFrameOptions, BlackFrameWatch, DrawLedger, DrawLedgerOptions, DrawLedgerRecording, GeometryRow, LedgerRenderer, LedgerRow, MeshRow, ProbeRenderer, Skip, TriangleOptions, ZFightingOptions, ZFightingRow };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,645 @@
+//#region src/scene.ts
+/** Depth-first, in child order. A skipped (or, with `visibleOnly`, hidden) object prunes its subtree. */
+const walk = (root, options, visit) => {
+	const stack = [root];
+	while (stack.length > 0) {
+		const object = stack.pop();
+		if (options.visibleOnly === true && !object.visible || options.skip?.(object) === true) continue;
+		visit(object);
+		for (let i = object.children.length - 1; i >= 0; i -= 1) stack.push(object.children[i]);
+	}
+};
+const isMesh = (object) => object.isMesh === true;
+const isInstanced = (mesh) => mesh.isInstancedMesh === true;
+const isBatched = (mesh) => mesh.isBatchedMesh === true;
+/** Triangles one draw of this geometry makes: indexed or not, within its draw range. */
+const triangleCount = (geometry) => {
+	const elements = geometry.index?.count ?? geometry.attributes.position?.count ?? 0;
+	const { start, count } = geometry.drawRange;
+	const drawn = Math.min(elements, start + count) - start;
+	return Math.max(0, Math.floor(drawn / 3));
+};
+/** Triangles a batch draws across its visible instances, and how many instances that is. */
+const batchedTriangles = (batch) => {
+	let triangles = 0;
+	let instances = 0;
+	for (let id = 0; id < batch.maxInstanceCount; id += 1) {
+		let geometryId;
+		try {
+			if (!batch.getVisibleAt(id)) continue;
+			geometryId = batch.getGeometryIdAt(id);
+		} catch {
+			continue;
+		}
+		const range = batch.getGeometryRangeAt(geometryId);
+		const elements = range.count ?? (batch.geometry.index ? range.indexCount : range.vertexCount);
+		triangles += Math.floor(elements / 3);
+		instances += 1;
+	}
+	return {
+		instances,
+		triangles
+	};
+};
+/** The tag of the nearest tagged ancestor (the object itself included), or `null`. */
+const tagOf = (object, tagKey) => {
+	for (let at = object; at; at = at.parent) {
+		const tag = at.userData[tagKey];
+		if (tag !== void 0 && tag !== null) return String(tag);
+	}
+	return null;
+};
+const hasTag = (root, tagKey, skip) => {
+	let found = false;
+	walk(root, { skip }, (object) => {
+		found ||= object.userData[tagKey] !== void 0 && object.userData[tagKey] !== null;
+	});
+	return found;
+};
+const meshName = (mesh) => mesh.name || mesh.geometry.name || mesh.geometry.type;
+const materialName = (mesh) => {
+	const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+	return material ? material.name || material.type : "none";
+};
+/** Adds a property JSON and `console.table` leave out: a live object that would serialise the scene. */
+const withHidden = (row, key, value) => Object.defineProperty(row, key, {
+	value,
+	enumerable: false
+});
+//#endregion
+//#region src/bad-geometry.ts
+const corner = (geometry, k) => geometry.index?.getX(k) ?? k;
+const check = (geometry) => {
+	const position = geometry.attributes.position;
+	const normal = geometry.attributes.normal;
+	const flagged = new Uint8Array(position.count);
+	let nonFinite = 0;
+	let zeroNormals = 0;
+	for (let v = 0; v < position.count; v += 1) if (!(Number.isFinite(position.getX(v)) && Number.isFinite(position.getY(v)) && Number.isFinite(position.getZ(v)) && (!normal || Number.isFinite(normal.getX(v)) && Number.isFinite(normal.getY(v)) && Number.isFinite(normal.getZ(v))))) {
+		flagged[v] = 1;
+		nonFinite += 1;
+	}
+	if (!normal) return {
+		nonFinite,
+		zeroNormals
+	};
+	const corners = geometry.index?.count ?? position.count;
+	for (let k = 0; k + 2 < corners; k += 3) {
+		const a = corner(geometry, k);
+		const b = corner(geometry, k + 1);
+		const c = corner(geometry, k + 2);
+		const ux = position.getX(b) - position.getX(a);
+		const uy = position.getY(b) - position.getY(a);
+		const uz = position.getZ(b) - position.getZ(a);
+		const vx = position.getX(c) - position.getX(a);
+		const vy = position.getY(c) - position.getY(a);
+		const vz = position.getZ(c) - position.getZ(a);
+		if (!(Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx) > 1e-8)) continue;
+		for (const v of [
+			a,
+			b,
+			c
+		]) if (flagged[v] === 0 && Math.hypot(normal.getX(v), normal.getY(v), normal.getZ(v)) < 1e-4) {
+			flagged[v] = 1;
+			zeroNormals += 1;
+		}
+	}
+	return {
+		nonFinite,
+		zeroNormals
+	};
+};
+/** Meshes with geometry that renders NaN, hidden ones included. `[]` is a pass. */
+const findBadGeometry = (root, options = {}) => {
+	const tagKey = options.tagKey ?? "studioObject";
+	const rows = [];
+	walk(root, { skip: options.skip }, (object) => {
+		if (!isMesh(object) || !object.geometry.attributes.position) return;
+		const { nonFinite, zeroNormals } = check(object.geometry);
+		if (nonFinite > 0 || zeroNormals > 0) {
+			const under = tagOf(object, tagKey) ?? object.parent?.name ?? "";
+			rows.push(withHidden({
+				mesh: meshName(object),
+				under,
+				nonFinite,
+				zeroNormals
+			}, "object", object));
+		}
+	});
+	return rows;
+};
+//#endregion
+//#region src/triangles.ts
+const cost = (mesh) => {
+	if (isBatched(mesh)) return batchedTriangles(mesh);
+	const instances = isInstanced(mesh) ? mesh.count : 1;
+	return {
+		instances,
+		triangles: triangleCount(mesh.geometry) * instances
+	};
+};
+/**
+* Triangles one pass draws: visible meshes, instances counted, no frustum culling. A shadow pass
+* adds roughly as much again for each shadow-casting light.
+*/
+const countTriangles = (root, options = {}) => {
+	let total = 0;
+	walk(root, {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (isMesh(object)) total += cost(object).triangles;
+	});
+	return total;
+};
+/** Every visible mesh, most triangles drawn first. */
+const listMeshes = (root, options = {}) => {
+	const rows = [];
+	walk(root, {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (!isMesh(object)) return;
+		const { instances, triangles } = cost(object);
+		const row = {
+			name: meshName(object),
+			triangles: instances > 0 ? Math.round(triangles / instances) : 0,
+			instances,
+			total: triangles
+		};
+		rows.push(withHidden(row, "mesh", object));
+	});
+	return rows.sort((a, b) => b.total - a.total);
+};
+/**
+* Geometries by triangles drawn, hidden meshes included, most first. Name geometries
+* (`geometry.name`) to make this readable. Batches are left out: their shared buffer is not one
+* geometry; `listMeshes` counts them.
+*/
+const geometryCensus = (root, options = {}) => {
+	const rows = /* @__PURE__ */ new Map();
+	walk(root, { skip: options.skip }, (object) => {
+		if (!isMesh(object) || isBatched(object) || !object.geometry.attributes.position) return;
+		const geometry = object.geometry;
+		const key = geometry.name || `${geometry.type}:${geometry.uuid.slice(0, 6)}`;
+		const triangles = triangleCount(geometry);
+		const uses = isInstanced(object) ? object.count : 1;
+		const row = rows.get(key) ?? {
+			geometry: key,
+			uses: 0,
+			triangles,
+			total: 0
+		};
+		row.uses += uses;
+		row.total += triangles * uses;
+		rows.set(key, row);
+	});
+	return [...rows.values()].sort((a, b) => b.total - a.total);
+};
+//#endregion
+//#region src/z-fighting.ts
+/** Normals quantised to 1/40: neighbouring buckets are searched, so this only sets bucket size. */
+const QUANT = 40;
+/** Normals this aligned count as parallel (about 2.6°). */
+const PARALLEL = .999;
+const round = (value) => Math.round(value * 100) / 100;
+const labelOf = (part) => {
+	const centre = part.min.map((low, axis) => round((low + part.max[axis]) / 2));
+	return `${part.tag === null ? "" : `${part.tag}/`}${meshName(part.mesh)} [${materialName(part.mesh)}] @ (${centre.join(", ")})`;
+};
+/** Pairs of meshes that z-fight, most overlapping triangles first. `[]` is a pass. */
+const findZFighting = (root, options = {}) => {
+	const gap = options.gap ?? .004;
+	const self = options.self ?? false;
+	const tagKey = options.tagKey ?? "studioObject";
+	const tagged = options.tagged ?? hasTag(root, tagKey, options.skip);
+	root.updateWorldMatrix(true, true);
+	const parts = [];
+	const owner = [];
+	const planes = [];
+	const corners = [];
+	const keys = [];
+	const buckets = /* @__PURE__ */ new Map();
+	const keyOf = (x, y, z, d) => `${x},${y},${z},${d}`;
+	walk(root, { skip: options.skip }, (object) => {
+		if (!isMesh(object) || isInstanced(object) || isBatched(object) || !object.geometry.attributes.position) return;
+		const tag = tagOf(object, tagKey);
+		if (tagged && tag === null) return;
+		const part = parts.length;
+		const { index, attributes } = object.geometry;
+		const position = attributes.position;
+		const e = object.matrixWorld.elements;
+		const min = [
+			Infinity,
+			Infinity,
+			Infinity
+		];
+		const max = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		];
+		const count = index?.count ?? position.count;
+		const world = [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		];
+		parts.push({
+			mesh: object,
+			tag,
+			min,
+			max
+		});
+		for (let k = 0; k + 2 < count; k += 3) {
+			for (let c = 0; c < 3; c += 1) {
+				const v = index?.getX(k + c) ?? k + c;
+				const x = position.getX(v);
+				const y = position.getY(v);
+				const z = position.getZ(v);
+				for (let axis = 0; axis < 3; axis += 1) {
+					const value = e[axis] * x + e[axis + 4] * y + e[axis + 8] * z + e[axis + 12];
+					world[c * 3 + axis] = value;
+					min[axis] = Math.min(min[axis], value);
+					max[axis] = Math.max(max[axis], value);
+				}
+			}
+			const [ax, ay, az, bx, by, bz, cx, cy, cz] = world;
+			const ux = bx - ax;
+			const uy = by - ay;
+			const uz = bz - az;
+			const vx = cx - ax;
+			const vy = cy - ay;
+			const vz = cz - az;
+			let nx = uy * vz - uz * vy;
+			let ny = uz * vx - ux * vz;
+			let nz = ux * vy - uy * vx;
+			const length = Math.hypot(nx, ny, nz);
+			if (!(length / 2 >= 1e-5)) continue;
+			nx /= length;
+			ny /= length;
+			nz /= length;
+			const d = nx * ax + ny * ay + nz * az;
+			const id = owner.length;
+			const key = [
+				Math.round(nx * QUANT),
+				Math.round(ny * QUANT),
+				Math.round(nz * QUANT),
+				Math.round(d / gap)
+			];
+			const bucket = buckets.get(keyOf(...key));
+			owner.push(part);
+			planes.push(nx, ny, nz, d);
+			corners.push(...world);
+			keys.push(key);
+			if (bucket) bucket.push(id);
+			else buckets.set(keyOf(...key), [id]);
+		}
+	});
+	const margin = gap / 2;
+	const flat = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	const overlaps = (s, t) => {
+		const S = s * 9;
+		const T = t * 9;
+		let ux = corners[S + 3] - corners[S];
+		let uy = corners[S + 4] - corners[S + 1];
+		let uz = corners[S + 5] - corners[S + 2];
+		const length = Math.hypot(ux, uy, uz) || 1;
+		ux /= length;
+		uy /= length;
+		uz /= length;
+		const nx = planes[s * 4];
+		const ny = planes[s * 4 + 1];
+		const nz = planes[s * 4 + 2];
+		const vx = ny * uz - nz * uy;
+		const vy = nz * ux - nx * uz;
+		const vz = nx * uy - ny * ux;
+		for (let i = 0; i < 6; i += 1) {
+			const at = i < 3 ? S + i * 3 : T + (i - 3) * 3;
+			const px = corners[at];
+			const py = corners[at + 1];
+			const pz = corners[at + 2];
+			flat[i * 2] = px * ux + py * uy + pz * uz;
+			flat[i * 2 + 1] = px * vx + py * vy + pz * vz;
+		}
+		for (let edge = 0; edge < 6; edge += 1) {
+			const from = edge;
+			const to = edge < 3 ? (edge + 1) % 3 : 3 + (edge + 1) % 3;
+			const ex = flat[to * 2] - flat[from * 2];
+			const ey = flat[to * 2 + 1] - flat[from * 2 + 1];
+			const edgeLength = Math.hypot(ex, ey) || 1;
+			const axisX = -ey / edgeLength;
+			const axisY = ex / edgeLength;
+			let p0 = Infinity;
+			let p1 = -Infinity;
+			let q0 = Infinity;
+			let q1 = -Infinity;
+			for (let i = 0; i < 6; i += 1) {
+				const value = flat[i * 2] * axisX + flat[i * 2 + 1] * axisY;
+				if (i < 3) {
+					p0 = Math.min(p0, value);
+					p1 = Math.max(p1, value);
+				} else {
+					q0 = Math.min(q0, value);
+					q1 = Math.max(q1, value);
+				}
+			}
+			if (Math.min(p1, q1) - Math.max(p0, q0) < margin) return false;
+		}
+		return true;
+	};
+	const pairs = /* @__PURE__ */ new Map();
+	for (let s = 0; s < owner.length; s += 1) {
+		const [kx, ky, kz, kd] = keys[s];
+		for (let i = -1; i <= 1; i += 1) for (let j = -1; j <= 1; j += 1) for (let k = -1; k <= 1; k += 1) for (let l = -1; l <= 1; l += 1) for (const t of buckets.get(keyOf(kx + i, ky + j, kz + k, kd + l)) ?? []) {
+			const a = owner[s];
+			const b = owner[t];
+			if (t <= s || a === b && !self || planes[s * 4] * planes[t * 4] + planes[s * 4 + 1] * planes[t * 4 + 1] + planes[s * 4 + 2] * planes[t * 4 + 2] < PARALLEL || Math.abs(planes[s * 4 + 3] - planes[t * 4 + 3]) > gap || !overlaps(s, t)) continue;
+			const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+			const pair = pairs.get(key) ?? {
+				a: Math.min(a, b),
+				b: Math.max(a, b),
+				triangles: 0
+			};
+			pair.triangles += 1;
+			pairs.set(key, pair);
+		}
+	}
+	return [...pairs.values()].sort((x, y) => y.triangles - x.triangles).map(({ a, b, triangles }) => withHidden({
+		a: labelOf(parts[a]),
+		b: labelOf(parts[b]),
+		triangles
+	}, "meshes", [parts[a].mesh, parts[b].mesh]));
+};
+//#endregion
+//#region src/audit-scene.ts
+/**
+* Every check at once, JSON-safe: what a test asserts on or a headless browser prints. A clean
+* scene has `zFighting` and `badGeometry` both `[]`.
+*/
+const auditScene = (root, options = {}) => {
+	const { skip, tagKey } = options;
+	return {
+		triangles: countTriangles(root, { skip }),
+		zFighting: findZFighting(root, options),
+		badGeometry: findBadGeometry(root, tagKey === void 0 ? { skip } : {
+			skip,
+			tagKey
+		}),
+		meshes: listMeshes(root, { skip }).slice(0, options.top ?? 10)
+	};
+};
+//#endregion
+//#region src/patch.ts
+/** Swap `key` on `target` for `value`; the returned function puts back exactly what was there. */
+const patch = (target, key, value) => {
+	const own = Object.hasOwn(target, key);
+	const original = target[key];
+	target[key] = value;
+	return () => {
+		if (own) target[key] = original;
+		else delete target[key];
+	};
+};
+//#endregion
+//#region src/black-frames.ts
+/**
+* Sample every frame the app draws to the screen. Several screen renders in one frame (an overlay
+* redrawn after the composer) count once, as the last of them: the image the display shows.
+* Browser only: frames are told apart by `requestAnimationFrame`.
+*/
+const watchBlackFrames = (renderer, options = {}) => {
+	const context = renderer.getContext();
+	if (typeof context?.readPixels !== "function") throw new TypeError("three-audit: the black-frame probe needs a WebGLRenderer");
+	if (typeof requestAnimationFrame !== "function") throw new TypeError("three-audit: the black-frame probe needs requestAnimationFrame");
+	const gl = context;
+	const grid = options.grid ?? 3;
+	const threshold = options.threshold ?? 3;
+	const pixel = /* @__PURE__ */ new Uint8Array(4);
+	const render = renderer.render;
+	let frames = 0;
+	let black = [];
+	let pending = null;
+	const isBlack = () => {
+		let count = 0;
+		for (let i = 1; i <= grid; i += 1) for (let j = 1; j <= grid; j += 1) {
+			const x = Math.floor(gl.drawingBufferWidth * i / (grid + 1));
+			const y = Math.floor(gl.drawingBufferHeight * j / (grid + 1));
+			gl.readPixels(x, y, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+			if (pixel[0] < 4 && pixel[1] < 4 && pixel[2] < 4 && pixel[3] > 250) count += 1;
+		}
+		return count >= threshold;
+	};
+	let raf = 0;
+	const commit = () => {
+		if (pending !== null) {
+			frames += 1;
+			if (pending) black.push(frames);
+			pending = null;
+		}
+		raf = requestAnimationFrame(commit);
+	};
+	raf = requestAnimationFrame(commit);
+	const restore = patch(renderer, "render", function(scene, camera) {
+		render.call(this, scene, camera);
+		if (renderer.getRenderTarget() === null) pending = isBlack();
+	});
+	return {
+		get frames() {
+			return frames;
+		},
+		get blackFrames() {
+			return black;
+		},
+		reset: () => {
+			frames = 0;
+			black = [];
+			pending = null;
+		},
+		stop: () => {
+			cancelAnimationFrame(raf);
+			restore();
+		}
+	};
+};
+//#endregion
+//#region src/draw-ledger.ts
+const defaultGroupOf = (name) => name.split(/[:#]/)[0] || name;
+const nameOf = (object, material) => object.name || `${object.type}:${material.name || material.type}`;
+const tally = (rows, name, pass) => {
+	const row = rows.get(name) ?? {
+		name,
+		total: 0,
+		passes: {}
+	};
+	row.total += 1;
+	row.passes[pass] = (row.passes[pass] ?? 0) + 1;
+	rows.set(name, row);
+};
+const sorted = (rows) => [...rows.values()].sort((a, b) => b.total - a.total);
+/** Start counting every draw. Call `end()` after the frame to restore the renderer and read it. */
+const beginDrawLedger = (renderer, options = {}) => {
+	if (typeof renderer.renderBufferDirect !== "function") throw new TypeError("three-audit: the draw ledger needs a WebGLRenderer");
+	const groupOf = options.groupOf ?? defaultGroupOf;
+	const render = renderer.render;
+	const renderBufferDirect = renderer.renderBufferDirect;
+	const passes = [];
+	const objects = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
+	let renders = 0;
+	let current = "direct";
+	let draws = 0;
+	const restoreRender = patch(renderer, "render", function(scene, camera) {
+		const outer = current;
+		renders += 1;
+		current = scene.name || `render ${renders}`;
+		try {
+			render.call(this, scene, camera);
+		} finally {
+			current = outer;
+		}
+	});
+	const restoreDraw = patch(renderer, "renderBufferDirect", function(camera, scene, geometry, material, object, group) {
+		const pass = material.isMeshDepthMaterial === true || material.isMeshDistanceMaterial === true ? "shadow" : current;
+		const name = nameOf(object, material);
+		if (!passes.includes(pass)) passes.push(pass);
+		draws += 1;
+		tally(objects, name, pass);
+		tally(groups, groupOf(name), pass);
+		renderBufferDirect.call(this, camera, scene, geometry, material, object, group);
+	});
+	return { end: () => {
+		restoreDraw();
+		restoreRender();
+		return {
+			passes,
+			groups: sorted(groups),
+			objects: sorted(objects),
+			draws
+		};
+	} };
+};
+/**
+* Record exactly one frame of an app that renders from `requestAnimationFrame` (three's
+* `setAnimationLoop`, React Three Fiber): from one animation frame to the next. A demand-driven
+* loop that renders nothing that frame gives an empty ledger. Browser only.
+*/
+const recordDrawLedger = (renderer, options = {}) => new Promise((resolve, reject) => {
+	if (typeof requestAnimationFrame !== "function") {
+		reject(/* @__PURE__ */ new Error("three-audit: recordDrawLedger needs requestAnimationFrame"));
+		return;
+	}
+	requestAnimationFrame(() => {
+		try {
+			const recording = beginDrawLedger(renderer, options);
+			requestAnimationFrame(() => resolve(recording.end()));
+		} catch (error) {
+			reject(error);
+		}
+	});
+});
+/** Rows shaped for `console.table`: one column per pass, then the total. */
+const ledgerTable = (rows, passes) => rows.map((row) => ({
+	name: row.name,
+	...Object.fromEntries(passes.map((pass) => [pass, row.passes[pass] ?? 0])),
+	total: row.total
+}));
+/** The ledger as two console tables: by group, and every object collapsed beneath. */
+const printDrawLedger = (ledger) => {
+	console.group(`Draw ledger: ${ledger.draws} draws in one frame`);
+	console.table(ledgerTable(ledger.groups, ledger.passes));
+	console.groupCollapsed("Every object");
+	console.table(ledgerTable(ledger.objects, ledger.passes));
+	console.groupEnd();
+	console.groupEnd();
+};
+//#endregion
+//#region src/console-helpers.ts
+const NAMES = [
+	"auditRoot",
+	"tris",
+	"meshes",
+	"census",
+	"audit",
+	"zfight",
+	"report",
+	"ledger",
+	"blackFrames"
+];
+const needsRenderer = (name) => () => {
+	throw new Error(`three-audit: ${name}() needs installAuditHelpers(scene, { renderer })`);
+};
+/**
+* Put the helpers on `globalThis`. Returns a function that removes them.
+*
+*   vanilla: installAuditHelpers(scene, { renderer })
+*   R3F:     const { scene, gl } = useThree();
+*            useLayoutEffect(() => installAuditHelpers(scene, { renderer: gl }), [scene, gl]);
+*/
+const installAuditHelpers = (root, options = {}) => {
+	const { renderer, skip } = options;
+	const tagKey = options.tagKey ?? "studioObject";
+	const helpers = {
+		auditRoot: root,
+		tris: () => countTriangles(root, { skip }),
+		meshes: () => listMeshes(root, { skip }),
+		census: () => geometryCensus(root, { skip }),
+		audit: () => findBadGeometry(root, {
+			skip,
+			tagKey
+		}),
+		zfight: (gap, self) => findZFighting(root, {
+			skip,
+			tagKey,
+			...gap === void 0 ? {} : { gap },
+			...self === void 0 ? {} : { self }
+		}),
+		report: () => auditScene(root, {
+			skip,
+			tagKey
+		}),
+		ledger: renderer ? async () => {
+			const ledger = await recordDrawLedger(renderer);
+			printDrawLedger(ledger);
+			return ledger;
+		} : needsRenderer("ledger"),
+		blackFrames: renderer ? (seconds = 10) => new Promise((resolve) => {
+			const watch = watchBlackFrames(renderer);
+			setTimeout(() => {
+				watch.stop();
+				resolve({
+					frames: watch.frames,
+					blackFrames: watch.blackFrames
+				});
+			}, seconds * 1e3);
+		}) : needsRenderer("blackFrames")
+	};
+	Object.assign(globalThis, helpers);
+	return () => {
+		const scope = globalThis;
+		for (const name of NAMES) if (scope[name] === helpers[name]) delete scope[name];
+	};
+};
+//#endregion
+export { auditScene, beginDrawLedger, countTriangles, findBadGeometry, findZFighting, geometryCensus, installAuditHelpers, ledgerTable, listMeshes, printDrawLedger, recordDrawLedger, triangleCount, watchBlackFrames };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/scene.ts","../src/bad-geometry.ts","../src/triangles.ts","../src/z-fighting.ts","../src/audit-scene.ts","../src/patch.ts","../src/black-frames.ts","../src/draw-ledger.ts","../src/console-helpers.ts"],"sourcesContent":["/**\n * Scene-graph plumbing every check shares: the walk, mesh kinds, triangle counts, tags and names.\n *\n * Nothing here imports three at runtime; objects are recognised by three's own `is*` flags, so the\n * checks work on whatever copy of three the app bundles.\n */\nimport type { BatchedMesh, BufferGeometry, InstancedMesh, Material, Mesh, Object3D } from \"three\";\n\n/** Leave an object and everything under it out of a check. */\nexport type Skip = (object: Object3D) => boolean;\n\nexport type WalkOptions = {\n  skip?: Skip | undefined;\n  /** Prune hidden objects and their subtrees, as the renderer does. */\n  visibleOnly?: boolean;\n};\n\n/** Depth-first, in child order. A skipped (or, with `visibleOnly`, hidden) object prunes its subtree. */\nexport const walk = (root: Object3D, options: WalkOptions, visit: (object: Object3D) => void) => {\n  const stack = [root];\n\n  while (stack.length > 0) {\n    const object = stack.pop()!;\n\n    if ((options.visibleOnly === true && !object.visible) || options.skip?.(object) === true) {\n      continue;\n    }\n\n    visit(object);\n\n    for (let i = object.children.length - 1; i >= 0; i -= 1) {\n      stack.push(object.children[i]!);\n    }\n  }\n};\n\nexport const isMesh = (object: Object3D): object is Mesh => (object as Mesh).isMesh === true;\n\nexport const isInstanced = (mesh: Mesh): mesh is InstancedMesh =>\n  (mesh as InstancedMesh).isInstancedMesh === true;\n\nexport const isBatched = (mesh: Mesh): mesh is BatchedMesh =>\n  (mesh as unknown as BatchedMesh).isBatchedMesh === true;\n\n/** Triangles one draw of this geometry makes: indexed or not, within its draw range. */\nexport const triangleCount = (geometry: BufferGeometry) => {\n  const elements = geometry.index?.count ?? geometry.attributes.position?.count ?? 0;\n  const { start, count } = geometry.drawRange;\n  const drawn = Math.min(elements, start + count) - start;\n\n  return Math.max(0, Math.floor(drawn / 3));\n};\n\n/** Triangles a batch draws across its visible instances, and how many instances that is. */\nexport const batchedTriangles = (batch: BatchedMesh) => {\n  let triangles = 0;\n  let instances = 0;\n\n  for (let id = 0; id < batch.maxInstanceCount; id += 1) {\n    let geometryId: number;\n\n    // Deleted and never-used ids throw.\n    try {\n      if (!batch.getVisibleAt(id)) {\n        continue;\n      }\n\n      geometryId = batch.getGeometryIdAt(id);\n    } catch {\n      continue;\n    }\n\n    const range = batch.getGeometryRangeAt(geometryId) as {\n      count?: number;\n      indexCount: number;\n      vertexCount: number;\n    };\n    const elements = range.count ?? (batch.geometry.index ? range.indexCount : range.vertexCount);\n\n    triangles += Math.floor(elements / 3);\n    instances += 1;\n  }\n\n  return { instances, triangles };\n};\n\n/** The tag of the nearest tagged ancestor (the object itself included), or `null`. */\nexport const tagOf = (object: Object3D, tagKey: string) => {\n  for (let at: Object3D | null = object; at; at = at.parent) {\n    const tag: unknown = at.userData[tagKey];\n\n    if (tag !== undefined && tag !== null) {\n      return String(tag);\n    }\n  }\n\n  return null;\n};\n\nexport const hasTag = (root: Object3D, tagKey: string, skip?: Skip) => {\n  let found = false;\n\n  walk(root, { skip }, (object) => {\n    found ||= object.userData[tagKey] !== undefined && object.userData[tagKey] !== null;\n  });\n\n  return found;\n};\n\nexport const meshName = (mesh: Mesh) => mesh.name || mesh.geometry.name || mesh.geometry.type;\n\nexport const materialName = (mesh: Mesh) => {\n  const material = (Array.isArray(mesh.material) ? mesh.material[0] : mesh.material) as\n    | Material\n    | undefined;\n\n  return material ? material.name || material.type : \"none\";\n};\n\n/** Adds a property JSON and `console.table` leave out: a live object that would serialise the scene. */\nexport const withHidden = <Row extends object, Key extends string, Value>(\n  row: Row,\n  key: Key,\n  value: Value,\n) => Object.defineProperty(row, key, { value, enumerable: false }) as Row & Record<Key, Value>;\n","/**\n * Geometry that lights a pixel NaN: a non-finite position or normal, or a zero-length normal on a\n * triangle with area. Bloom and other blurs spread one NaN pixel into a black block.\n */\nimport type { BufferGeometry, Mesh, Object3D } from \"three\";\n\nimport { isMesh, meshName, type Skip, tagOf, walk, withHidden } from \"./scene.ts\";\n\nexport type BadGeometryOptions = {\n  skip?: Skip | undefined;\n  /** `userData` key naming the part a mesh belongs to, for the `under` column. */\n  tagKey?: string;\n};\n\nexport type BadGeometryRow = {\n  mesh: string;\n  /** The tagged part it sits in, or its parent's name. */\n  under: string;\n  /** Vertices with a NaN or infinite position or normal component. */\n  nonFinite: number;\n  /** Vertices of triangles with area whose normal has no length. */\n  zeroNormals: number;\n  /** Not enumerable: kept out of JSON and `console.table`. */\n  readonly object: Mesh;\n};\n\nconst corner = (geometry: BufferGeometry, k: number) => geometry.index?.getX(k) ?? k;\n\nconst check = (geometry: BufferGeometry) => {\n  const position = geometry.attributes.position!;\n  const normal = geometry.attributes.normal;\n  const flagged = new Uint8Array(position.count);\n  let nonFinite = 0;\n  let zeroNormals = 0;\n\n  for (let v = 0; v < position.count; v += 1) {\n    const finite =\n      Number.isFinite(position.getX(v)) &&\n      Number.isFinite(position.getY(v)) &&\n      Number.isFinite(position.getZ(v)) &&\n      (!normal ||\n        (Number.isFinite(normal.getX(v)) &&\n          Number.isFinite(normal.getY(v)) &&\n          Number.isFinite(normal.getZ(v))));\n\n    if (!finite) {\n      flagged[v] = 1;\n      nonFinite += 1;\n    }\n  }\n\n  if (!normal) {\n    return { nonFinite, zeroNormals };\n  }\n\n  const corners = geometry.index?.count ?? position.count;\n\n  for (let k = 0; k + 2 < corners; k += 3) {\n    const a = corner(geometry, k);\n    const b = corner(geometry, k + 1);\n    const c = corner(geometry, k + 2);\n    const ux = position.getX(b) - position.getX(a);\n    const uy = position.getY(b) - position.getY(a);\n    const uz = position.getZ(b) - position.getZ(a);\n    const vx = position.getX(c) - position.getX(a);\n    const vy = position.getY(c) - position.getY(a);\n    const vz = position.getZ(c) - position.getZ(a);\n    const area = Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);\n\n    if (!(area > 1e-8)) {\n      continue;\n    }\n\n    for (const v of [a, b, c]) {\n      if (flagged[v] === 0 && Math.hypot(normal.getX(v), normal.getY(v), normal.getZ(v)) < 1e-4) {\n        flagged[v] = 1;\n        zeroNormals += 1;\n      }\n    }\n  }\n\n  return { nonFinite, zeroNormals };\n};\n\n/** Meshes with geometry that renders NaN, hidden ones included. `[]` is a pass. */\nexport const findBadGeometry = (\n  root: Object3D,\n  options: BadGeometryOptions = {},\n): BadGeometryRow[] => {\n  const tagKey = options.tagKey ?? \"studioObject\";\n  const rows: BadGeometryRow[] = [];\n\n  walk(root, { skip: options.skip }, (object) => {\n    if (!isMesh(object) || !object.geometry.attributes.position) {\n      return;\n    }\n\n    const { nonFinite, zeroNormals } = check(object.geometry);\n\n    if (nonFinite > 0 || zeroNormals > 0) {\n      const under = tagOf(object, tagKey) ?? object.parent?.name ?? \"\";\n\n      rows.push(\n        withHidden({ mesh: meshName(object), under, nonFinite, zeroNormals }, \"object\", object),\n      );\n    }\n  });\n\n  return rows;\n};\n","/**\n * Where a triangle budget goes: the total one pass draws, the meshes drawing it, and the\n * geometries behind them.\n */\nimport type { Mesh, Object3D } from \"three\";\n\nimport {\n  batchedTriangles,\n  isBatched,\n  isInstanced,\n  isMesh,\n  meshName,\n  type Skip,\n  triangleCount,\n  walk,\n  withHidden,\n} from \"./scene.ts\";\n\nexport type TriangleOptions = { skip?: Skip | undefined };\n\nexport type MeshRow = {\n  name: string;\n  /** Triangles in one copy (a batch's average). */\n  triangles: number;\n  instances: number;\n  total: number;\n  /** Not enumerable: kept out of JSON and `console.table`. */\n  readonly mesh: Mesh;\n};\n\nexport type GeometryRow = {\n  /** `geometry.name`, or its type and the start of its uuid. */\n  geometry: string;\n  /** Copies drawn: every mesh using it, instances counted. */\n  uses: number;\n  triangles: number;\n  total: number;\n};\n\nconst cost = (mesh: Mesh) => {\n  if (isBatched(mesh)) {\n    return batchedTriangles(mesh);\n  }\n\n  const instances = isInstanced(mesh) ? mesh.count : 1;\n\n  return { instances, triangles: triangleCount(mesh.geometry) * instances };\n};\n\n/**\n * Triangles one pass draws: visible meshes, instances counted, no frustum culling. A shadow pass\n * adds roughly as much again for each shadow-casting light.\n */\nexport const countTriangles = (root: Object3D, options: TriangleOptions = {}) => {\n  let total = 0;\n\n  walk(root, { skip: options.skip, visibleOnly: true }, (object) => {\n    if (isMesh(object)) {\n      total += cost(object).triangles;\n    }\n  });\n\n  return total;\n};\n\n/** Every visible mesh, most triangles drawn first. */\nexport const listMeshes = (root: Object3D, options: TriangleOptions = {}): MeshRow[] => {\n  const rows: MeshRow[] = [];\n\n  walk(root, { skip: options.skip, visibleOnly: true }, (object) => {\n    if (!isMesh(object)) {\n      return;\n    }\n\n    const { instances, triangles } = cost(object);\n    const row = {\n      name: meshName(object),\n      triangles: instances > 0 ? Math.round(triangles / instances) : 0,\n      instances,\n      total: triangles,\n    };\n\n    rows.push(withHidden(row, \"mesh\", object));\n  });\n\n  return rows.sort((a, b) => b.total - a.total);\n};\n\n/**\n * Geometries by triangles drawn, hidden meshes included, most first. Name geometries\n * (`geometry.name`) to make this readable. Batches are left out: their shared buffer is not one\n * geometry; `listMeshes` counts them.\n */\nexport const geometryCensus = (root: Object3D, options: TriangleOptions = {}): GeometryRow[] => {\n  const rows = new Map<string, GeometryRow>();\n\n  walk(root, { skip: options.skip }, (object) => {\n    if (!isMesh(object) || isBatched(object) || !object.geometry.attributes.position) {\n      return;\n    }\n\n    const geometry = object.geometry;\n    const key = geometry.name || `${geometry.type}:${geometry.uuid.slice(0, 6)}`;\n    const triangles = triangleCount(geometry);\n    const uses = isInstanced(object) ? object.count : 1;\n    const row = rows.get(key) ?? { geometry: key, uses: 0, triangles, total: 0 };\n\n    row.uses += uses;\n    row.total += triangles * uses;\n    rows.set(key, row);\n  });\n\n  return [...rows.values()].sort((a, b) => b.total - a.total);\n};\n","/**\n * Z-fighting found by geometry instead of by eye: pairs of meshes with triangles in (nearly) one\n * plane, facing the same way, overlapping. Those flicker wherever depth precision runs out.\n *\n * Triangles are bucketed by their quantised plane (normal and offset), so only triangles in\n * neighbouring buckets are compared; overlap in the shared plane is a separating-axis test.\n */\nimport type { Mesh, Object3D } from \"three\";\n\nimport {\n  hasTag,\n  isBatched,\n  isInstanced,\n  isMesh,\n  materialName,\n  meshName,\n  type Skip,\n  tagOf,\n  walk,\n  withHidden,\n} from \"./scene.ts\";\n\nexport type ZFightingOptions = {\n  /**\n   * How close two planes count as one, in world units. 0.004 (4 mm at 1 unit = 1 m) is about what\n   * depth precision loses with a camera ~50 m out. Scale it with your units.\n   */\n  gap?: number;\n  /** Also compare triangles within one mesh: for merged geometry whose parts share a buffer. */\n  self?: boolean;\n  /**\n   * Only meshes inside a tagged object (`userData[tagKey]`), so a studio's ground and props stay\n   * out. Defaults to true when anything under the root is tagged, false otherwise.\n   */\n  tagged?: boolean;\n  tagKey?: string;\n  skip?: Skip | undefined;\n};\n\nexport type ZFightingRow = {\n  /** `tag/mesh [material] @ (x, y, z)`, the centre in world space. */\n  a: string;\n  b: string;\n  /** Overlapping triangle pairs between the two. */\n  triangles: number;\n  /** Not enumerable: kept out of JSON and `console.table`. */\n  readonly meshes: readonly [Mesh, Mesh];\n};\n\n/** Normals quantised to 1/40: neighbouring buckets are searched, so this only sets bucket size. */\nconst QUANT = 40;\n/** Normals this aligned count as parallel (about 2.6°). */\nconst PARALLEL = 0.999;\n\ntype Part = { mesh: Mesh; tag: string | null; min: number[]; max: number[] };\n\nconst round = (value: number) => Math.round(value * 100) / 100;\n\nconst labelOf = (part: Part) => {\n  const centre = part.min.map((low, axis) => round((low + part.max[axis]!) / 2));\n  const tag = part.tag === null ? \"\" : `${part.tag}/`;\n\n  return `${tag}${meshName(part.mesh)} [${materialName(part.mesh)}] @ (${centre.join(\", \")})`;\n};\n\n/** Pairs of meshes that z-fight, most overlapping triangles first. `[]` is a pass. */\nexport const findZFighting = (root: Object3D, options: ZFightingOptions = {}): ZFightingRow[] => {\n  const gap = options.gap ?? 0.004;\n  const self = options.self ?? false;\n  const tagKey = options.tagKey ?? \"studioObject\";\n  const tagged = options.tagged ?? hasTag(root, tagKey, options.skip);\n\n  root.updateWorldMatrix(true, true);\n\n  const parts: Part[] = [];\n  // Per triangle: its part, plane (nx, ny, nz, d) and world corners (9 numbers).\n  const owner: number[] = [];\n  const planes: number[] = [];\n  const corners: number[] = [];\n  const keys: [number, number, number, number][] = [];\n  const buckets = new Map<string, number[]>();\n  const keyOf = (x: number, y: number, z: number, d: number) => `${x},${y},${z},${d}`;\n\n  walk(root, { skip: options.skip }, (object) => {\n    if (\n      !isMesh(object) ||\n      isInstanced(object) ||\n      isBatched(object) ||\n      !object.geometry.attributes.position\n    ) {\n      return;\n    }\n\n    const tag = tagOf(object, tagKey);\n\n    if (tagged && tag === null) {\n      return;\n    }\n\n    const part = parts.length;\n    const { index, attributes } = object.geometry;\n    const position = attributes.position!;\n    const e = object.matrixWorld.elements;\n    const min = [Infinity, Infinity, Infinity];\n    const max = [-Infinity, -Infinity, -Infinity];\n    const count = index?.count ?? position.count;\n    const world = [0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n    parts.push({ mesh: object, tag, min, max });\n\n    for (let k = 0; k + 2 < count; k += 3) {\n      for (let c = 0; c < 3; c += 1) {\n        const v = index?.getX(k + c) ?? k + c;\n        const x = position.getX(v);\n        const y = position.getY(v);\n        const z = position.getZ(v);\n\n        for (let axis = 0; axis < 3; axis += 1) {\n          const value = e[axis]! * x + e[axis + 4]! * y + e[axis + 8]! * z + e[axis + 12]!;\n\n          world[c * 3 + axis] = value;\n          min[axis] = Math.min(min[axis]!, value);\n          max[axis] = Math.max(max[axis]!, value);\n        }\n      }\n\n      const [ax, ay, az, bx, by, bz, cx, cy, cz] = world as [\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n      ];\n      const ux = bx - ax;\n      const uy = by - ay;\n      const uz = bz - az;\n      const vx = cx - ax;\n      const vy = cy - ay;\n      const vz = cz - az;\n      let nx = uy * vz - uz * vy;\n      let ny = uz * vx - ux * vz;\n      let nz = ux * vy - uy * vx;\n      const length = Math.hypot(nx, ny, nz);\n\n      // Slivers under ~1e-5 m² show nothing.\n      if (!(length / 2 >= 1e-5)) {\n        continue;\n      }\n\n      nx /= length;\n      ny /= length;\n      nz /= length;\n\n      const d = nx * ax + ny * ay + nz * az;\n      const id = owner.length;\n      const key: [number, number, number, number] = [\n        Math.round(nx * QUANT),\n        Math.round(ny * QUANT),\n        Math.round(nz * QUANT),\n        Math.round(d / gap),\n      ];\n      const bucket = buckets.get(keyOf(...key));\n\n      owner.push(part);\n      planes.push(nx, ny, nz, d);\n      corners.push(...world);\n      keys.push(key);\n\n      if (bucket) {\n        bucket.push(id);\n      } else {\n        buckets.set(keyOf(...key), [id]);\n      }\n    }\n  });\n\n  // Overlap in s's plane, with a margin so triangles merely sharing an edge don't count.\n  const margin = gap / 2;\n  const flat = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n  const overlaps = (s: number, t: number) => {\n    const S = s * 9;\n    const T = t * 9;\n    let ux = corners[S + 3]! - corners[S]!;\n    let uy = corners[S + 4]! - corners[S + 1]!;\n    let uz = corners[S + 5]! - corners[S + 2]!;\n    const length = Math.hypot(ux, uy, uz) || 1;\n\n    ux /= length;\n    uy /= length;\n    uz /= length;\n\n    const nx = planes[s * 4]!;\n    const ny = planes[s * 4 + 1]!;\n    const nz = planes[s * 4 + 2]!;\n    const vx = ny * uz - nz * uy;\n    const vy = nz * ux - nx * uz;\n    const vz = nx * uy - ny * ux;\n\n    // Corners 0–2 are s, 3–5 are t, as (x, y) in the plane.\n    for (let i = 0; i < 6; i += 1) {\n      const at = i < 3 ? S + i * 3 : T + (i - 3) * 3;\n      const px = corners[at]!;\n      const py = corners[at + 1]!;\n      const pz = corners[at + 2]!;\n\n      flat[i * 2] = px * ux + py * uy + pz * uz;\n      flat[i * 2 + 1] = px * vx + py * vy + pz * vz;\n    }\n\n    for (let edge = 0; edge < 6; edge += 1) {\n      const from = edge;\n      const to = edge < 3 ? (edge + 1) % 3 : 3 + ((edge + 1) % 3);\n      const ex = flat[to * 2]! - flat[from * 2]!;\n      const ey = flat[to * 2 + 1]! - flat[from * 2 + 1]!;\n      const edgeLength = Math.hypot(ex, ey) || 1;\n      const axisX = -ey / edgeLength;\n      const axisY = ex / edgeLength;\n      let p0 = Infinity;\n      let p1 = -Infinity;\n      let q0 = Infinity;\n      let q1 = -Infinity;\n\n      for (let i = 0; i < 6; i += 1) {\n        const value = flat[i * 2]! * axisX + flat[i * 2 + 1]! * axisY;\n\n        if (i < 3) {\n          p0 = Math.min(p0, value);\n          p1 = Math.max(p1, value);\n        } else {\n          q0 = Math.min(q0, value);\n          q1 = Math.max(q1, value);\n        }\n      }\n\n      if (Math.min(p1, q1) - Math.max(p0, q0) < margin) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  const pairs = new Map<string, { a: number; b: number; triangles: number }>();\n\n  // Every neighbouring bucket, so near-equal planes that round apart still meet.\n  for (let s = 0; s < owner.length; s += 1) {\n    const [kx, ky, kz, kd] = keys[s]!;\n\n    for (let i = -1; i <= 1; i += 1) {\n      for (let j = -1; j <= 1; j += 1) {\n        for (let k = -1; k <= 1; k += 1) {\n          for (let l = -1; l <= 1; l += 1) {\n            for (const t of buckets.get(keyOf(kx + i, ky + j, kz + k, kd + l)) ?? []) {\n              const a = owner[s]!;\n              const b = owner[t]!;\n\n              if (\n                t <= s ||\n                (a === b && !self) ||\n                planes[s * 4]! * planes[t * 4]! +\n                  planes[s * 4 + 1]! * planes[t * 4 + 1]! +\n                  planes[s * 4 + 2]! * planes[t * 4 + 2]! <\n                  PARALLEL ||\n                Math.abs(planes[s * 4 + 3]! - planes[t * 4 + 3]!) > gap ||\n                !overlaps(s, t)\n              ) {\n                continue;\n              }\n\n              const key = a < b ? `${a}:${b}` : `${b}:${a}`;\n              const pair = pairs.get(key) ?? { a: Math.min(a, b), b: Math.max(a, b), triangles: 0 };\n\n              pair.triangles += 1;\n              pairs.set(key, pair);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return [...pairs.values()]\n    .sort((x, y) => y.triangles - x.triangles)\n    .map(({ a, b, triangles }) =>\n      withHidden({ a: labelOf(parts[a]!), b: labelOf(parts[b]!), triangles }, \"meshes\", [\n        parts[a]!.mesh,\n        parts[b]!.mesh,\n      ] as const),\n    );\n};\n","import type { Object3D } from \"three\";\n\nimport { type BadGeometryRow, findBadGeometry } from \"./bad-geometry.ts\";\nimport type { Skip } from \"./scene.ts\";\nimport { countTriangles, listMeshes, type MeshRow } from \"./triangles.ts\";\nimport { findZFighting, type ZFightingOptions, type ZFightingRow } from \"./z-fighting.ts\";\n\nexport type AuditSceneOptions = Pick<ZFightingOptions, \"gap\" | \"self\" | \"tagged\"> & {\n  skip?: Skip | undefined;\n  tagKey?: string;\n  /** How many of the costliest meshes to list. */\n  top?: number;\n};\n\nexport type AuditReport = {\n  triangles: number;\n  zFighting: ZFightingRow[];\n  badGeometry: BadGeometryRow[];\n  /** The costliest meshes, most triangles first. */\n  meshes: MeshRow[];\n};\n\n/**\n * Every check at once, JSON-safe: what a test asserts on or a headless browser prints. A clean\n * scene has `zFighting` and `badGeometry` both `[]`.\n */\nexport const auditScene = (root: Object3D, options: AuditSceneOptions = {}): AuditReport => {\n  const { skip, tagKey } = options;\n\n  return {\n    triangles: countTriangles(root, { skip }),\n    zFighting: findZFighting(root, options),\n    badGeometry: findBadGeometry(root, tagKey === undefined ? { skip } : { skip, tagKey }),\n    meshes: listMeshes(root, { skip }).slice(0, options.top ?? 10),\n  };\n};\n","/** Swap `key` on `target` for `value`; the returned function puts back exactly what was there. */\nexport const patch = <Target extends object, Key extends keyof Target>(\n  target: Target,\n  key: Key,\n  value: Target[Key],\n) => {\n  const own = Object.hasOwn(target, key);\n  const original = target[key];\n\n  target[key] = value;\n\n  return () => {\n    if (own) {\n      target[key] = original;\n    } else {\n      delete target[key];\n    }\n  };\n};\n","/**\n * Black-frame probe: after each frame, samples a grid of the drawing buffer and counts frames\n * where several samples are pure black. Catches the flash a NaN pixel makes once bloom spreads it,\n * which lasts one frame in twenty and never shows in a screenshot.\n *\n * WebGL only (`readPixels`). Each sample stalls the GPU pipeline, so watch, read, stop.\n */\nimport type { Camera, Object3D } from \"three\";\n\nimport { patch } from \"./patch.ts\";\n\n/** The `WebGLRenderer` methods the probe uses. */\nexport type ProbeRenderer = {\n  render(scene: Object3D, camera: Camera): void;\n  getContext(): unknown;\n  getRenderTarget(): unknown;\n};\n\nexport type BlackFrameOptions = {\n  /** Samples per side: 3 reads a 3 × 3 grid at the quarter lines. */\n  grid?: number;\n  /** Black samples that make a frame black. */\n  threshold?: number;\n};\n\nexport type BlackFrameWatch = {\n  /** Frames sampled since the start or the last `reset()`. */\n  readonly frames: number;\n  /** Which of those frames (1-based) were black. */\n  readonly blackFrames: readonly number[];\n  reset: () => void;\n  /** Restore the renderer and stop sampling. */\n  stop: () => void;\n};\n\ntype ReadPixels = Pick<\n  WebGLRenderingContext,\n  \"RGBA\" | \"UNSIGNED_BYTE\" | \"drawingBufferHeight\" | \"drawingBufferWidth\" | \"readPixels\"\n>;\n\n/**\n * Sample every frame the app draws to the screen. Several screen renders in one frame (an overlay\n * redrawn after the composer) count once, as the last of them: the image the display shows.\n * Browser only: frames are told apart by `requestAnimationFrame`.\n */\nexport const watchBlackFrames = (\n  renderer: ProbeRenderer,\n  options: BlackFrameOptions = {},\n): BlackFrameWatch => {\n  const context = renderer.getContext() as Partial<ReadPixels> | null;\n\n  if (typeof context?.readPixels !== \"function\") {\n    throw new TypeError(\"three-audit: the black-frame probe needs a WebGLRenderer\");\n  }\n\n  if (typeof requestAnimationFrame !== \"function\") {\n    throw new TypeError(\"three-audit: the black-frame probe needs requestAnimationFrame\");\n  }\n\n  const gl = context as ReadPixels;\n  const grid = options.grid ?? 3;\n  const threshold = options.threshold ?? 3;\n  const pixel = new Uint8Array(4);\n  const render = renderer.render;\n  let frames = 0;\n  let black: number[] = [];\n  let pending: boolean | null = null;\n\n  const isBlack = () => {\n    let count = 0;\n\n    for (let i = 1; i <= grid; i += 1) {\n      for (let j = 1; j <= grid; j += 1) {\n        const x = Math.floor((gl.drawingBufferWidth * i) / (grid + 1));\n        const y = Math.floor((gl.drawingBufferHeight * j) / (grid + 1));\n\n        gl.readPixels(x, y, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);\n\n        if (pixel[0]! < 4 && pixel[1]! < 4 && pixel[2]! < 4 && pixel[3]! > 250) {\n          count += 1;\n        }\n      }\n    }\n\n    return count >= threshold;\n  };\n\n  // Commit the frame's last screen sample once per animation frame.\n  let raf = 0;\n  const commit = () => {\n    if (pending !== null) {\n      frames += 1;\n\n      if (pending) {\n        black.push(frames);\n      }\n\n      pending = null;\n    }\n\n    raf = requestAnimationFrame(commit);\n  };\n\n  raf = requestAnimationFrame(commit);\n\n  const restore = patch(renderer, \"render\", function (this: unknown, scene, camera) {\n    render.call(this, scene, camera);\n\n    // Read before the browser presents (and, without preserveDrawingBuffer, clears) the buffer.\n    if (renderer.getRenderTarget() === null) {\n      pending = isBlack();\n    }\n  });\n\n  return {\n    get frames() {\n      return frames;\n    },\n    get blackFrames() {\n      return black;\n    },\n    reset: () => {\n      frames = 0;\n      black = [];\n      pending = null;\n    },\n    stop: () => {\n      cancelAnimationFrame(raf);\n      restore();\n    },\n  };\n};\n","/**\n * A ledger of every draw call over one frame: which object drew, in which pass. Exact counts from\n * the renderer itself, where `renderer.info` gives one total (and resets it every `render()`).\n *\n * WebGL only: it wraps `WebGLRenderer.renderBufferDirect`, which every draw goes through, and\n * `render()`, to tell passes apart. Draws with a depth or distance material are the shadow maps.\n */\nimport type { BufferGeometry, Camera, Material, Object3D, Scene } from \"three\";\n\nimport { patch } from \"./patch.ts\";\n\n/** The two `WebGLRenderer` methods the ledger wraps. */\nexport type LedgerRenderer = {\n  render(scene: Object3D, camera: Camera): void;\n  renderBufferDirect(\n    camera: Camera,\n    scene: Scene | null,\n    geometry: BufferGeometry,\n    material: Material,\n    object: Object3D,\n    group: unknown,\n  ): void;\n};\n\nexport type DrawLedgerOptions = {\n  /**\n   * The group an object name files under. Default: up to the first `:` or `#`, so a bake's\n   * `wagon:paint` and a strip's `grass#3` group as `wagon` and `grass`.\n   */\n  groupOf?: (name: string) => string;\n};\n\nexport type LedgerRow = {\n  name: string;\n  total: number;\n  /** Draws per pass name. */\n  passes: Record<string, number>;\n};\n\nexport type DrawLedger = {\n  /**\n   * Pass names in the order they first drew: `shadow`, then each `render()` call as its scene's\n   * name, or `render 1`, `render 2`… when unnamed (a post-processing chain is several).\n   */\n  passes: string[];\n  /** By group, most draws first. */\n  groups: LedgerRow[];\n  /** By object name, most draws first. */\n  objects: LedgerRow[];\n  draws: number;\n};\n\nexport type DrawLedgerRecording = {\n  /** Restore the renderer and return what was drawn since `beginDrawLedger`. */\n  end: () => DrawLedger;\n};\n\nconst defaultGroupOf = (name: string) => name.split(/[:#]/)[0] || name;\n\nconst nameOf = (object: Object3D, material: Material) =>\n  object.name || `${object.type}:${material.name || material.type}`;\n\nconst tally = (rows: Map<string, LedgerRow>, name: string, pass: string) => {\n  const row = rows.get(name) ?? { name, total: 0, passes: {} };\n\n  row.total += 1;\n  row.passes[pass] = (row.passes[pass] ?? 0) + 1;\n  rows.set(name, row);\n};\n\nconst sorted = (rows: Map<string, LedgerRow>) =>\n  [...rows.values()].sort((a, b) => b.total - a.total);\n\n/** Start counting every draw. Call `end()` after the frame to restore the renderer and read it. */\nexport const beginDrawLedger = (\n  renderer: LedgerRenderer,\n  options: DrawLedgerOptions = {},\n): DrawLedgerRecording => {\n  if (typeof renderer.renderBufferDirect !== \"function\") {\n    throw new TypeError(\"three-audit: the draw ledger needs a WebGLRenderer\");\n  }\n\n  const groupOf = options.groupOf ?? defaultGroupOf;\n  const render = renderer.render;\n  const renderBufferDirect = renderer.renderBufferDirect;\n  const passes: string[] = [];\n  const objects = new Map<string, LedgerRow>();\n  const groups = new Map<string, LedgerRow>();\n  let renders = 0;\n  let current = \"direct\";\n  let draws = 0;\n\n  const restoreRender = patch(renderer, \"render\", function (this: unknown, scene, camera) {\n    const outer = current;\n\n    renders += 1;\n    current = scene.name || `render ${renders}`;\n\n    try {\n      render.call(this, scene, camera);\n    } finally {\n      current = outer;\n    }\n  });\n\n  const restoreDraw = patch(\n    renderer,\n    \"renderBufferDirect\",\n    function (this: unknown, camera, scene, geometry, material, object, group) {\n      const shadow =\n        (material as { isMeshDepthMaterial?: boolean }).isMeshDepthMaterial === true ||\n        (material as { isMeshDistanceMaterial?: boolean }).isMeshDistanceMaterial === true;\n      const pass = shadow ? \"shadow\" : current;\n      const name = nameOf(object, material);\n\n      if (!passes.includes(pass)) {\n        passes.push(pass);\n      }\n\n      draws += 1;\n      tally(objects, name, pass);\n      tally(groups, groupOf(name), pass);\n      renderBufferDirect.call(this, camera, scene, geometry, material, object, group);\n    },\n  );\n\n  return {\n    end: () => {\n      restoreDraw();\n      restoreRender();\n\n      return { passes, groups: sorted(groups), objects: sorted(objects), draws };\n    },\n  };\n};\n\n/**\n * Record exactly one frame of an app that renders from `requestAnimationFrame` (three's\n * `setAnimationLoop`, React Three Fiber): from one animation frame to the next. A demand-driven\n * loop that renders nothing that frame gives an empty ledger. Browser only.\n */\nexport const recordDrawLedger = (renderer: LedgerRenderer, options: DrawLedgerOptions = {}) =>\n  new Promise<DrawLedger>((resolve, reject) => {\n    if (typeof requestAnimationFrame !== \"function\") {\n      reject(new Error(\"three-audit: recordDrawLedger needs requestAnimationFrame\"));\n\n      return;\n    }\n\n    requestAnimationFrame(() => {\n      try {\n        const recording = beginDrawLedger(renderer, options);\n\n        requestAnimationFrame(() => resolve(recording.end()));\n      } catch (error) {\n        reject(error);\n      }\n    });\n  });\n\n/** Rows shaped for `console.table`: one column per pass, then the total. */\nexport const ledgerTable = (rows: LedgerRow[], passes: string[]) =>\n  rows.map((row) => ({\n    name: row.name,\n    ...Object.fromEntries(passes.map((pass) => [pass, row.passes[pass] ?? 0])),\n    total: row.total,\n  }));\n\n/** The ledger as two console tables: by group, and every object collapsed beneath. */\nexport const printDrawLedger = (ledger: DrawLedger) => {\n  /* oxlint-disable no-console -- printing is this function's job */\n  console.group(`Draw ledger: ${ledger.draws} draws in one frame`);\n  console.table(ledgerTable(ledger.groups, ledger.passes));\n  console.groupCollapsed(\"Every object\");\n  console.table(ledgerTable(ledger.objects, ledger.passes));\n  console.groupEnd();\n  console.groupEnd();\n  /* oxlint-enable no-console */\n};\n","/**\n * The checks as short console globals, for a dev page or a headless browser's `eval`:\n * `tris()`, `meshes()`, `census()`, `audit()`, `zfight()`, `report()`, and with a renderer\n * `ledger()` and `blackFrames()`.\n */\nimport type { Object3D } from \"three\";\n\nimport { auditScene } from \"./audit-scene.ts\";\nimport { findBadGeometry } from \"./bad-geometry.ts\";\nimport { type ProbeRenderer, watchBlackFrames } from \"./black-frames.ts\";\nimport { type LedgerRenderer, printDrawLedger, recordDrawLedger } from \"./draw-ledger.ts\";\nimport type { Skip } from \"./scene.ts\";\nimport { countTriangles, geometryCensus, listMeshes } from \"./triangles.ts\";\nimport { findZFighting } from \"./z-fighting.ts\";\n\nexport type AuditHelpersOptions = {\n  /** A `WebGLRenderer`, for `ledger()` and `blackFrames()`. */\n  renderer?: (LedgerRenderer & ProbeRenderer) | undefined;\n  skip?: Skip | undefined;\n  tagKey?: string;\n};\n\nconst NAMES = [\n  \"auditRoot\",\n  \"tris\",\n  \"meshes\",\n  \"census\",\n  \"audit\",\n  \"zfight\",\n  \"report\",\n  \"ledger\",\n  \"blackFrames\",\n] as const;\n\nconst needsRenderer = (name: string) => () => {\n  throw new Error(`three-audit: ${name}() needs installAuditHelpers(scene, { renderer })`);\n};\n\n/**\n * Put the helpers on `globalThis`. Returns a function that removes them.\n *\n *   vanilla: installAuditHelpers(scene, { renderer })\n *   R3F:     const { scene, gl } = useThree();\n *            useLayoutEffect(() => installAuditHelpers(scene, { renderer: gl }), [scene, gl]);\n */\nexport const installAuditHelpers = (root: Object3D, options: AuditHelpersOptions = {}) => {\n  const { renderer, skip } = options;\n  const tagKey = options.tagKey ?? \"studioObject\";\n\n  const helpers: Record<(typeof NAMES)[number], unknown> = {\n    auditRoot: root,\n    tris: () => countTriangles(root, { skip }),\n    meshes: () => listMeshes(root, { skip }),\n    census: () => geometryCensus(root, { skip }),\n    audit: () => findBadGeometry(root, { skip, tagKey }),\n    zfight: (gap?: number, self?: boolean) =>\n      findZFighting(root, {\n        skip,\n        tagKey,\n        ...(gap === undefined ? {} : { gap }),\n        ...(self === undefined ? {} : { self }),\n      }),\n    report: () => auditScene(root, { skip, tagKey }),\n    ledger: renderer\n      ? async () => {\n          const ledger = await recordDrawLedger(renderer);\n\n          printDrawLedger(ledger);\n\n          return ledger;\n        }\n      : needsRenderer(\"ledger\"),\n    blackFrames: renderer\n      ? (seconds = 10) =>\n          new Promise<{ frames: number; blackFrames: readonly number[] }>((resolve) => {\n            const watch = watchBlackFrames(renderer);\n\n            setTimeout(() => {\n              watch.stop();\n              resolve({ frames: watch.frames, blackFrames: watch.blackFrames });\n            }, seconds * 1000);\n          })\n      : needsRenderer(\"blackFrames\"),\n  };\n\n  Object.assign(globalThis, helpers);\n\n  return () => {\n    const scope = globalThis as Record<string, unknown>;\n\n    for (const name of NAMES) {\n      if (scope[name] === helpers[name]) {\n        delete scope[name];\n      }\n    }\n  };\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@zkmake/three-audit",
+  "version": "0.1.0",
+  "description": "Scene checks for three.js: triangle counts, cost census, NaN normals, z-fighting, black frames and a one-frame draw-call ledger. Zero dependencies.",
+  "keywords": [
+    "audit",
+    "devtools",
+    "draw-calls",
+    "lint",
+    "r3f",
+    "three",
+    "threejs",
+    "triangles",
+    "z-fighting"
+  ],
+  "homepage": "https://github.com/zkmake/three-kit/tree/main/packages/three-audit#readme",
+  "bugs": "https://github.com/zkmake/three-kit/issues",
+  "license": "MIT",
+  "author": "Zubin Khavarian",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zkmake/three-kit.git",
+    "directory": "packages/three-audit"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "ci:test": "vitest run",
+    "ci:typecheck": "tsc",
+    "pack:check": "npm pack --dry-run",
+    "test": "vitest watch",
+    "typecheck": "tsc"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "catalog:",
+    "@types/three": "catalog:",
+    "publint": "catalog:",
+    "three": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "peerDependencies": {
+    "three": ">=0.160"
+  },
+  "engines": {
+    "node": ">=20.19"
+  }
+}