@zkmake/three-audit 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as listMeshes, i as geometryCensus, n as findZFighting, o as findBadGeometry, r as countTriangles, s as triangleCount, t as auditScene } from "./audit-scene-D5ZaENGZ.js";
+import { _ as triangleCount, a as countTriangles, c as findBadGeometry, d as batchedTriangles, f as isBatched, g as pathOf, h as meshLabel, i as countDraws, l as findEmptyMeshes, m as isMesh, n as summarizeScene, o as geometryCensus, p as isInstanced, r as findZFighting, s as listMeshes, t as auditScene, u as asObject3D, v as walk } from "./audit-scene-CJG1DgRF.js";
 //#region src/patch.ts
 /** Swap `key` on `target` for `value`; the returned function puts back exactly what was there. */
 const patch = (target, key, value) => {
@@ -13,6 +13,13 @@ const patch = (target, key, value) => {
 //#endregion
 //#region src/black-frames.ts
 /**
+* Black-frame probe: after each frame, samples a grid of the drawing buffer and counts frames
+* where several samples are pure black. Catches the flash a NaN pixel makes once bloom spreads it,
+* which lasts one frame in twenty and never shows in a screenshot.
+*
+* WebGL only (`readPixels`). Each sample stalls the GPU pipeline, so watch, read, stop.
+*/
+/**
 * 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`.
@@ -72,9 +79,38 @@ const watchBlackFrames = (renderer, options = {}) => {
 	};
 };
 //#endregion
+//#region src/frames.ts
+/**
+* Waiting on animation frames without hanging: a tab in the background (an agent's browser, an
+* occluded window) gets none, so every wait gives up after a timeout and says why.
+*/
+/** Frames an agent-driven tab should see within this long, in ms. */
+const FRAME_TIMEOUT = 2e3;
+const noFrame = (caller, timeout, hint) => {
+	const hidden = typeof document !== "undefined" && document.hidden;
+	return /* @__PURE__ */ new Error(`three-audit: ${caller} got no animation frame in ${timeout / 1e3} s${hidden ? " (document.hidden is true: browsers pause requestAnimationFrame in background tabs)" : ""}. ${hint}`);
+};
+/** The next animation frame, or an error naming the cause when none comes within `timeout`. */
+const nextFrame = (caller, timeout, hint) => new Promise((resolve, reject) => {
+	if (typeof requestAnimationFrame !== "function") {
+		reject(/* @__PURE__ */ new Error(`three-audit: ${caller} needs requestAnimationFrame`));
+		return;
+	}
+	let frame = 0;
+	const timer = setTimeout(() => {
+		cancelAnimationFrame(frame);
+		reject(noFrame(caller, timeout, hint));
+	}, timeout);
+	frame = requestAnimationFrame(() => {
+		clearTimeout(timer);
+		resolve();
+	});
+});
+//#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}`;
+/** The object's name, or for an unnamed one its named ancestors, type and material. */
+const nameOf = (object, material) => object.name || `${[...pathOf(object, null, void 0, 2), object.type].join("/")} [${material.name || material.type}]`;
 const tally = (rows, name, pass) => {
 	const row = rows.get(name) ?? {
 		name,
@@ -86,6 +122,15 @@ const tally = (rows, name, pass) => {
 	rows.set(name, row);
 };
 const sorted = (rows) => [...rows.values()].sort((a, b) => b.total - a.total);
+/** Triangles one draw makes: its material group's range, times its instances. */
+const drawTriangles = (geometry, object, group) => {
+	const mesh = object;
+	if (mesh.isMesh !== true) return 0;
+	if (isBatched(mesh)) return batchedTriangles(mesh).triangles;
+	const range = group;
+	const elements = geometry.index?.count ?? geometry.attributes.position?.count ?? 0;
+	return (range && typeof range.count === "number" ? Math.floor(Math.max(0, Math.min(range.count, elements - (range.start ?? 0))) / 3) : triangleCount(geometry)) * (isInstanced(mesh) ? mesh.count : 1);
+};
 /** 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");
@@ -95,23 +140,89 @@ const beginDrawLedger = (renderer, options = {}) => {
 	const passes = [];
 	const objects = /* @__PURE__ */ new Map();
 	const groups = /* @__PURE__ */ new Map();
+	const stats = /* @__PURE__ */ new Map();
+	const calls = [];
 	let renders = 0;
 	let current = "direct";
 	let draws = 0;
+	let fullscreenPasses = 0;
+	let fullscreenPixels = 0;
+	const statOf = (pass) => {
+		let stat = stats.get(pass);
+		if (!stat) {
+			stat = {
+				name: pass,
+				draws: 0,
+				triangles: 0,
+				objects: /* @__PURE__ */ new Set(),
+				targets: /* @__PURE__ */ new Set(),
+				calls: 0,
+				fullscreenCalls: 0
+			};
+			stats.set(pass, stat);
+		}
+		return stat;
+	};
+	const sizeNow = () => {
+		const target = renderer.getRenderTarget?.();
+		if (target && typeof target.width === "number" && typeof target.height === "number") return {
+			width: target.width,
+			height: target.height,
+			screen: false
+		};
+		const gl = renderer.getContext?.();
+		return target === null && typeof gl?.drawingBufferWidth === "number" ? {
+			width: gl.drawingBufferWidth,
+			height: gl.drawingBufferHeight ?? 0,
+			screen: true
+		} : null;
+	};
 	const restoreRender = patch(renderer, "render", function(scene, camera) {
 		const outer = current;
 		renders += 1;
 		current = scene.name || `render ${renders}`;
+		const call = {
+			pass: current,
+			draws: 0,
+			orthographic: camera.isOrthographicCamera === true,
+			vertices: 0,
+			size: null
+		};
+		calls.push(call);
 		try {
 			render.call(this, scene, camera);
 		} finally {
+			calls.pop();
 			current = outer;
+			const stat = stats.get(call.pass);
+			if (stat) {
+				stat.calls += 1;
+				if (call.draws === 1 && call.orthographic && call.vertices <= 6) {
+					stat.fullscreenCalls += 1;
+					fullscreenPasses += 1;
+					fullscreenPixels += call.size ? call.size.width * call.size.height : 0;
+				}
+			}
 		}
 	});
 	const restoreDraw = patch(renderer, "renderBufferDirect", function(camera, scene, geometry, material, object, group) {
-		const pass = material.isMeshDepthMaterial === true || material.isMeshDistanceMaterial === true ? "shadow" : current;
+		const shadow = material.isMeshDepthMaterial === true || material.isMeshDistanceMaterial === true;
+		const pass = shadow ? "shadow" : current;
 		const name = nameOf(object, material);
 		if (!passes.includes(pass)) passes.push(pass);
+		const stat = statOf(pass);
+		const size = sizeNow();
+		const drawn = geometry;
+		stat.draws += 1;
+		stat.triangles += drawTriangles(drawn, object, group);
+		stat.objects.add(object);
+		if (size) stat.targets.add(`${size.screen ? "screen " : ""}${size.width}×${size.height}`);
+		const call = calls.at(-1);
+		if (call && !shadow) {
+			call.draws += 1;
+			call.vertices = drawn.attributes?.position?.count ?? Infinity;
+			call.size = size;
+		}
 		draws += 1;
 		tally(objects, name, pass);
 		tally(groups, groupOf(name), pass);
@@ -124,7 +235,20 @@ const beginDrawLedger = (renderer, options = {}) => {
 			passes,
 			groups: sorted(groups),
 			objects: sorted(objects),
-			draws
+			draws,
+			passStats: passes.map((pass) => {
+				const stat = stats.get(pass);
+				return {
+					name: pass,
+					draws: stat.draws,
+					objects: stat.objects.size,
+					triangles: stat.triangles,
+					targets: [...stat.targets],
+					fullscreen: stat.calls > 0 && stat.fullscreenCalls === stat.calls
+				};
+			}),
+			fullscreenPasses,
+			fullscreenPixels
 		};
 	} };
 };
@@ -132,21 +256,33 @@ const beginDrawLedger = (renderer, options = {}) => {
 * 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.
+*
+* With `render`, records one call of it instead, frames or not. Without, fails after `timeout`
+* when no frame comes (a background tab), rather than waiting for ever.
 */
-const recordDrawLedger = (renderer, options = {}) => new Promise((resolve, reject) => {
-	if (typeof requestAnimationFrame !== "function") {
-		reject(/* @__PURE__ */ new Error("three-audit: recordDrawLedger needs requestAnimationFrame"));
-		return;
-	}
-	requestAnimationFrame(() => {
+const recordDrawLedger = async (renderer, options = {}) => {
+	const { render, timeout = FRAME_TIMEOUT, ...ledgerOptions } = options;
+	if (render) {
+		const recording = beginDrawLedger(renderer, ledgerOptions);
 		try {
-			const recording = beginDrawLedger(renderer, options);
-			requestAnimationFrame(() => resolve(recording.end()));
+			await render();
 		} catch (error) {
-			reject(error);
+			recording.end();
+			throw error;
 		}
-	});
-});
+		return recording.end();
+	}
+	const hint = "Bring the tab to the front, or pass { render } to record one call of your own.";
+	await nextFrame("recordDrawLedger", timeout, hint);
+	const recording = beginDrawLedger(renderer, ledgerOptions);
+	try {
+		await nextFrame("recordDrawLedger", timeout, hint);
+	} catch (error) {
+		recording.end();
+		throw error;
+	}
+	return recording.end();
+};
 /** Rows shaped for `console.table`: one column per pass, then the total. */
 const ledgerTable = (rows, passes) => rows.map((row) => ({
 	name: row.name,
@@ -157,42 +293,314 @@ const ledgerTable = (rows, passes) => rows.map((row) => ({
 const printDrawLedger = (ledger) => {
 	console.group(`Draw ledger: ${ledger.draws} draws in one frame`);
 	console.table(ledgerTable(ledger.groups, ledger.passes));
+	console.table(ledger.passStats.map((pass) => ({
+		...pass,
+		targets: pass.targets.join(", ")
+	})));
+	if (ledger.fullscreenPasses > 0) console.log(`${ledger.fullscreenPasses} fullscreen passes: ${(ledger.fullscreenPixels / 1e6).toFixed(1)} Mpx shaded`);
 	console.groupCollapsed("Every object");
 	console.table(ledgerTable(ledger.objects, ledger.passes));
 	console.groupEnd();
 	console.groupEnd();
 };
 //#endregion
+//#region src/measure.ts
+const multiply = (a, b, out) => {
+	for (let row = 0; row < 4; row += 1) for (let column = 0; column < 4; column += 1) {
+		let sum = 0;
+		for (let k = 0; k < 4; k += 1) sum += a[k * 4 + row] * b[column * 4 + k];
+		out[column * 4 + row] = sum;
+	}
+	return out;
+};
+/** Every triangle a mesh draws, in world space: each instance of an instanced or batched mesh. */
+const eachTriangle = (mesh, visit) => {
+	const { index, attributes } = mesh.geometry;
+	const position = attributes.position;
+	if (!position) return;
+	const world = mesh.matrixWorld.elements;
+	const corner = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	const emit = (matrix, first, count, indexed) => {
+		for (let k = first; k + 2 < first + count; k += 3) {
+			for (let c = 0; c < 3; c += 1) {
+				const v = indexed ? 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) corner[c * 3 + axis] = matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12];
+			}
+			visit(...corner);
+		}
+	};
+	if (isBatched(mesh)) {
+		const batch = mesh;
+		const instance = Array.from({ length: 16 }, () => 0);
+		const matrix = Array.from({ length: 16 }, () => 0);
+		const target = { fromArray(array, offset = 0) {
+			for (let i = 0; i < 16; i += 1) instance[i] = array[offset + i];
+			return target;
+		} };
+		for (let id = 0; id < batch.maxInstanceCount; id += 1) {
+			let range;
+			try {
+				if (!batch.getVisibleAt(id)) continue;
+				range = batch.getGeometryRangeAt(batch.getGeometryIdAt(id));
+				batch.getMatrixAt(id, target);
+			} catch {
+				continue;
+			}
+			multiply(world, instance, matrix);
+			if (index) emit(matrix, range.indexStart, range.indexCount, true);
+			else emit(matrix, range.vertexStart, range.vertexCount, false);
+		}
+		return;
+	}
+	const { start, count } = mesh.geometry.drawRange;
+	const elements = index?.count ?? position.count;
+	const first = Math.min(start, elements);
+	const drawn = Math.min(elements, start + count) - first;
+	if (isInstanced(mesh)) {
+		const matrix = Array.from({ length: 16 }, () => 0);
+		const instances = mesh.instanceMatrix.array;
+		for (let i = 0; i < mesh.count; i += 1) {
+			multiply(world, Array.prototype.slice.call(instances, i * 16, i * 16 + 16), matrix);
+			emit(matrix, first, drawn, index !== null);
+		}
+		return;
+	}
+	emit(world, first, drawn, index !== null);
+};
+const emptyBox = () => [
+	Infinity,
+	Infinity,
+	Infinity,
+	-Infinity,
+	-Infinity,
+	-Infinity
+];
+const grow = (box, x, y, z) => {
+	box[0] = Math.min(box[0], x);
+	box[1] = Math.min(box[1], y);
+	box[2] = Math.min(box[2], z);
+	box[3] = Math.max(box[3], x);
+	box[4] = Math.max(box[4], y);
+	box[5] = Math.max(box[5], z);
+};
+/** Per axis, how far apart two boxes are (0 where they overlap). */
+const apart = (a, ai, b, bi, out) => {
+	for (let axis = 0; axis < 3; axis += 1) out[axis] = Math.max(0, a[ai + axis] - b[bi + axis + 3], b[bi + axis] - a[ai + axis + 3]);
+	return Math.hypot(out[0], out[1], out[2]);
+};
+const round = (value) => {
+	const rounded = Math.round(value * 1e3) / 1e3;
+	return rounded === 0 ? 0 : rounded;
+};
+/** The visible meshes a target stands for. */
+const meshesOf = (root, target, tagKey, role) => {
+	let objects;
+	if (typeof target === "string") {
+		const tagged = [];
+		const named = [];
+		walk(root, {}, (object) => {
+			const tag = object.userData[tagKey];
+			if (tag !== void 0 && tag !== null && String(tag) === target) tagged.push(object);
+			else if (object.name === target) named.push(object);
+		});
+		objects = tagged.length > 0 ? tagged : named;
+		if (objects.length === 0) throw new Error(`three-audit: ${role}: nothing is tagged userData.${tagKey} = "${target}" or named "${target}"`);
+	} else objects = [asObject3D(target)];
+	const meshes = /* @__PURE__ */ new Set();
+	for (const object of objects) walk(object, { visibleOnly: true }, (child) => {
+		if (isMesh(child)) meshes.add(child);
+	});
+	return meshes;
+};
+/** A target's world envelope, from its visible meshes' vertices; `null` when it draws nothing. */
+const measureBounds = (root, target, options = {}) => {
+	const scene = asObject3D(root);
+	scene.updateWorldMatrix(true, true);
+	const box = emptyBox();
+	for (const mesh of meshesOf(scene, target, options.tagKey ?? "studioObject", "bounds")) eachTriangle(mesh, (ax, ay, az, bx, by, bz, cx, cy, cz) => {
+		grow(box, ax, ay, az);
+		grow(box, bx, by, bz);
+		grow(box, cx, cy, cz);
+	});
+	if (box[0] > box[3]) return null;
+	return {
+		min: [
+			box[0],
+			box[1],
+			box[2]
+		].map(round),
+		max: [
+			box[3],
+			box[4],
+			box[5]
+		].map(round),
+		size: [
+			0,
+			1,
+			2
+		].map((axis) => round(box[axis + 3] - box[axis])),
+		centre: [
+			0,
+			1,
+			2
+		].map((axis) => round((box[axis] + box[axis + 3]) / 2))
+	};
+};
+/** Triangle boxes past this many pairs, a mesh pair is measured by its whole boxes instead. */
+const PAIR_LIMIT = 4e6;
+/**
+* The gap between two targets, and which of their meshes come closest. Throws when a target
+* matches nothing; `null` when either draws nothing. Meshes in both targets are left out of `a`.
+*/
+const measureClearance = (root, a, b, options = {}) => {
+	const scene = asObject3D(root);
+	const tagKey = options.tagKey ?? "studioObject";
+	scene.updateWorldMatrix(true, true);
+	const inB = meshesOf(scene, b, tagKey, "clearance b");
+	const inA = [...meshesOf(scene, a, tagKey, "clearance a")].filter((mesh) => !inB.has(mesh));
+	const measure = (mesh) => {
+		const box = emptyBox();
+		eachTriangle(mesh, (ax, ay, az, bx, by, bz, cx, cy, cz) => {
+			grow(box, ax, ay, az);
+			grow(box, bx, by, bz);
+			grow(box, cx, cy, cz);
+		});
+		return {
+			mesh,
+			box,
+			triangles: null
+		};
+	};
+	const sideA = inA.map(measure).filter(({ box }) => box[0] <= box[3]);
+	const sideB = [...inB].map(measure).filter(({ box }) => box[0] <= box[3]);
+	if (sideA.length === 0 || sideB.length === 0) return null;
+	const trianglesOf = (side) => {
+		if (!side.triangles) {
+			const boxes = [];
+			eachTriangle(side.mesh, (ax, ay, az, bx, by, bz, cx, cy, cz) => {
+				boxes.push(Math.min(ax, bx, cx), Math.min(ay, by, cy), Math.min(az, bz, cz), Math.max(ax, bx, cx), Math.max(ay, by, cy), Math.max(az, bz, cz));
+			});
+			side.triangles = Float64Array.from(boxes);
+		}
+		return side.triangles;
+	};
+	const axes = [
+		0,
+		0,
+		0
+	];
+	const pairs = sideA.flatMap((left) => sideB.map((right) => ({
+		left,
+		right,
+		distance: apart(left.box, 0, right.box, 0, axes)
+	}))).sort((x, y) => x.distance - y.distance);
+	let best = Infinity;
+	let bestAxes = [
+		0,
+		0,
+		0
+	];
+	let between = [pairs[0].left.mesh, pairs[0].right.mesh];
+	for (const { left, right, distance } of pairs) {
+		if (distance >= best) break;
+		const leftTriangles = trianglesOf(left);
+		const rightTriangles = trianglesOf(right);
+		const near = (triangles, other) => {
+			const kept = [];
+			for (let t = 0; t < triangles.length; t += 6) if (apart(triangles, t, other, 0, axes) < best) kept.push(t);
+			return kept;
+		};
+		const nearLeft = near(leftTriangles, right.box);
+		const nearRight = near(rightTriangles, left.box);
+		if (nearLeft.length * nearRight.length > PAIR_LIMIT) {
+			if (distance < best) {
+				best = distance;
+				apart(left.box, 0, right.box, 0, axes);
+				bestAxes = [...axes];
+				between = [left.mesh, right.mesh];
+			}
+			continue;
+		}
+		for (const i of nearLeft) for (const j of nearRight) {
+			const gap = apart(leftTriangles, i, rightTriangles, j, axes);
+			if (gap < best) {
+				best = gap;
+				bestAxes = [...axes];
+				between = [left.mesh, right.mesh];
+			}
+		}
+	}
+	const separated = bestAxes.flatMap((value, axis) => value > 0 ? [axis] : []);
+	return {
+		gap: round(best),
+		axis: separated.length === 1 ? [
+			"x",
+			"y",
+			"z"
+		][separated[0]] : null,
+		between: [meshLabel(between[0], scene, tagKey), meshLabel(between[1], scene, tagKey)]
+	};
+};
+//#endregion
 //#region src/console-helpers.ts
+const NAMESPACE = "threeAudit";
 const NAMES = [
 	"auditRoot",
+	"summary",
 	"tris",
 	"meshes",
 	"census",
 	"audit",
 	"zfight",
 	"report",
+	"bbox",
+	"clearance",
 	"ledger",
+	"beginLedger",
 	"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.
+* Put the helpers on `globalThis`, and on `globalThis.threeAudit`. 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 { renderer, skip, batchLabel } = options;
 	const tagKey = options.tagKey ?? "studioObject";
 	const helpers = {
 		auditRoot: root,
+		summary: (tag, summaryOptions = {}) => summarizeScene(root, {
+			skip,
+			tagKey,
+			...summaryOptions,
+			...tag === void 0 ? {} : { tag }
+		}),
 		tris: () => countTriangles(root, { skip }),
 		meshes: () => listMeshes(root, { skip }),
-		census: () => geometryCensus(root, { skip }),
+		census: (censusOptions = {}) => geometryCensus(root, {
+			skip,
+			label: batchLabel,
+			...censusOptions
+		}),
 		audit: () => findBadGeometry(root, {
 			skip,
 			tagKey
@@ -203,33 +611,50 @@ const installAuditHelpers = (root, options = {}) => {
 			...gap === void 0 ? {} : { gap },
 			...self === void 0 ? {} : { self }
 		}),
-		report: () => auditScene(root, {
+		report: (tag) => auditScene(root, {
 			skip,
-			tagKey
+			tagKey,
+			...tag === void 0 ? {} : { tag }
 		}),
-		ledger: renderer ? async () => {
-			const ledger = await recordDrawLedger(renderer);
+		bbox: (target) => measureBounds(root, target, { tagKey }),
+		clearance: (a, b) => measureClearance(root, a, b, { tagKey }),
+		ledger: renderer ? async (ledgerOptions) => {
+			const ledger = await recordDrawLedger(renderer, ledgerOptions);
 			printDrawLedger(ledger);
 			return ledger;
 		} : needsRenderer("ledger"),
-		blackFrames: renderer ? (seconds = 10) => new Promise((resolve) => {
+		beginLedger: renderer ? (ledgerOptions) => {
+			const recording = beginDrawLedger(renderer, ledgerOptions);
+			return { end: () => {
+				const ledger = recording.end();
+				printDrawLedger(ledger);
+				return ledger;
+			} };
+		} : needsRenderer("beginLedger"),
+		blackFrames: renderer ? async (seconds = 10) => {
+			await nextFrame("blackFrames()", FRAME_TIMEOUT, "Black frames only show in a visible tab: bring it to the front.");
 			const watch = watchBlackFrames(renderer);
-			setTimeout(() => {
-				watch.stop();
-				resolve({
-					frames: watch.frames,
-					blackFrames: watch.blackFrames
-				});
-			}, seconds * 1e3);
-		}) : needsRenderer("blackFrames")
+			return new Promise((resolve) => {
+				setTimeout(() => {
+					watch.stop();
+					resolve({
+						frames: watch.frames,
+						blackFrames: watch.blackFrames
+					});
+				}, seconds * 1e3);
+			});
+		} : needsRenderer("blackFrames")
 	};
-	Object.assign(globalThis, helpers);
+	const namespace = { ...helpers };
+	const scope = globalThis;
+	if (options.globals !== false) Object.assign(scope, helpers);
+	scope[NAMESPACE] = namespace;
 	return () => {
-		const scope = globalThis;
 		for (const name of NAMES) if (scope[name] === helpers[name]) delete scope[name];
+		if (scope[NAMESPACE] === namespace) delete scope[NAMESPACE];
 	};
 };
 //#endregion
-export { auditScene, beginDrawLedger, countTriangles, findBadGeometry, findZFighting, geometryCensus, installAuditHelpers, ledgerTable, listMeshes, printDrawLedger, recordDrawLedger, triangleCount, watchBlackFrames };
+export { auditScene, beginDrawLedger, countDraws, countTriangles, findBadGeometry, findEmptyMeshes, findZFighting, geometryCensus, installAuditHelpers, ledgerTable, listMeshes, measureBounds, measureClearance, printDrawLedger, recordDrawLedger, summarizeScene, triangleCount, watchBlackFrames };
 
 //# sourceMappingURL=index.js.map