@aura3d/debug 1.0.6

package/src/PhysicsDebugAdapter.ts

@@ -0,0 +1,86 @@
+import { PhysicsDebugDraw, type DebugLine, type PhysicsWorld } from "@aura3d/physics";
+
+export type PhysicsDebugSnapshot = {
+  readonly bodyCount: number;
+  readonly colliderCount: number;
+  readonly contactCount: number;
+  readonly lines: readonly DebugLine[];
+};
+
+export type PhysicsStackEvidence = {
+  readonly bodyCount: number;
+  readonly dynamicBodyCount: number;
+  readonly contactCount: number;
+  readonly lineCount: number;
+  readonly minY: number;
+  readonly maxY: number;
+  readonly settledCount: number;
+  readonly bodyPositions: readonly {
+    readonly id: number;
+    readonly type: string;
+    readonly position: readonly [number, number, number];
+  }[];
+  readonly stableHash: string;
+};
+
+export class PhysicsDebugAdapter {
+  private readonly draw = new PhysicsDebugDraw();
+
+  buildLines(world: Pick<PhysicsWorld, "colliders" | "getBody">): readonly DebugLine[] {
+    return this.draw.buildLines(world);
+  }
+
+  snapshot(world: Pick<PhysicsWorld, "colliders" | "bodies" | "getBody" | "snapshot">): PhysicsDebugSnapshot {
+    return {
+      bodyCount: world.bodies().length,
+      colliderCount: world.colliders().length,
+      contactCount: world.snapshot().contacts.length,
+      lines: this.buildLines(world)
+    };
+  }
+
+  stackEvidence(world: Pick<PhysicsWorld, "colliders" | "bodies" | "getBody" | "snapshot">, velocityEpsilon = 0.05): PhysicsStackEvidence {
+    const snapshot = world.snapshot();
+    const lines = this.buildLines(world);
+    const bodyPositions = snapshot.bodies.map((body) => ({
+      id: body.id,
+      type: body.type,
+      position: roundVec3(body.position)
+    }));
+    const dynamicBodies = snapshot.bodies.filter((body) => body.type === "dynamic");
+    const settledCount = dynamicBodies.filter((body) => Math.hypot(body.velocity[0], body.velocity[1], body.velocity[2]) <= velocityEpsilon).length;
+    const ys = snapshot.bodies.map((body) => body.position[1]);
+    const evidenceWithoutHash = {
+      bodyCount: snapshot.stats.bodies,
+      dynamicBodyCount: dynamicBodies.length,
+      contactCount: snapshot.contacts.length,
+      lineCount: lines.length,
+      minY: roundNumber(ys.length > 0 ? Math.min(...ys) : 0),
+      maxY: roundNumber(ys.length > 0 ? Math.max(...ys) : 0),
+      settledCount,
+      bodyPositions
+    };
+    return {
+      ...evidenceWithoutHash,
+      stableHash: stableHash(evidenceWithoutHash)
+    };
+  }
+}
+
+function roundNumber(value: number, places = 6): number {
+  return Number(value.toFixed(places));
+}
+
+function roundVec3(value: readonly [number, number, number]): [number, number, number] {
+  return [roundNumber(value[0]), roundNumber(value[1]), roundNumber(value[2])];
+}
+
+function stableHash(value: unknown): string {
+  const input = JSON.stringify(value);
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}

package/src/Profiler.ts

@@ -0,0 +1,77 @@
+export interface ProfilerMarker {
+  readonly name: string;
+  readonly startMs: number;
+  readonly endMs: number;
+  readonly durationMs: number;
+  readonly depth: number;
+}
+
+export interface ProfilerSnapshot {
+  readonly markerCount: number;
+  readonly totalDurationMs: number;
+  readonly markers: readonly ProfilerMarker[];
+}
+
+interface ActiveMarker {
+  readonly name: string;
+  readonly startMs: number;
+  readonly depth: number;
+}
+
+export class Profiler {
+  private readonly active: ActiveMarker[] = [];
+  private readonly markers: ProfilerMarker[] = [];
+
+  constructor(private readonly now: () => number = () => performance.now()) {}
+
+  begin(name: string): void {
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+      throw new Error("Profiler marker name is required");
+    }
+    this.active.push({ name: trimmed, startMs: this.now(), depth: this.active.length });
+  }
+
+  end(name?: string): ProfilerMarker {
+    const active = this.active.pop();
+    if (!active) {
+      throw new Error("Cannot end profiler marker because no marker is active");
+    }
+    if (name !== undefined && active.name !== name) {
+      throw new Error(`Profiler marker mismatch: expected ${active.name}, received ${name}`);
+    }
+    const endMs = this.now();
+    const marker: ProfilerMarker = {
+      name: active.name,
+      startMs: active.startMs,
+      endMs,
+      durationMs: endMs - active.startMs,
+      depth: active.depth
+    };
+    this.markers.push(marker);
+    return marker;
+  }
+
+  measure<T>(name: string, fn: () => T): T {
+    this.begin(name);
+    try {
+      return fn();
+    } finally {
+      this.end(name);
+    }
+  }
+
+  snapshot(): ProfilerSnapshot {
+    const markers = [...this.markers];
+    return Object.freeze({
+      markerCount: markers.length,
+      totalDurationMs: markers.reduce((total, marker) => total + marker.durationMs, 0),
+      markers
+    });
+  }
+
+  reset(): void {
+    this.active.length = 0;
+    this.markers.length = 0;
+  }
+}

package/src/RenderStateInspector.ts

@@ -0,0 +1,45 @@
+export type RenderStateValue = string | number | boolean | null;
+export type RenderStateSnapshot = ReadonlyMap<string, RenderStateValue>;
+
+export interface RenderStateDiff {
+  readonly key: string;
+  readonly before: RenderStateValue | undefined;
+  readonly after: RenderStateValue | undefined;
+}
+
+export class RenderStateInspector {
+  capture(source: { captureState(): RenderStateSnapshot }): RenderStateSnapshot {
+    return new Map(source.captureState());
+  }
+
+  diff(before: RenderStateSnapshot, after: RenderStateSnapshot): readonly RenderStateDiff[] {
+    const keys = new Set([...before.keys(), ...after.keys()]);
+    const diffs: RenderStateDiff[] = [];
+    for (const key of keys) {
+      const beforeValue = before.get(key);
+      const afterValue = after.get(key);
+      if (beforeValue !== afterValue) {
+        diffs.push({ key, before: beforeValue, after: afterValue });
+      }
+    }
+    return diffs;
+  }
+
+  assertNoLeak(before: RenderStateSnapshot, after: RenderStateSnapshot, ignoredKeys: readonly string[] = []): void {
+    const ignored = new Set(ignoredKeys);
+    const leaks = this.diff(before, after).filter((diff) => !ignored.has(diff.key));
+    if (leaks.length > 0) {
+      throw new RenderStateLeakError("Render state leak detected", leaks);
+    }
+  }
+}
+
+export class RenderStateLeakError extends Error {
+  constructor(
+    message: string,
+    public readonly leaks: readonly RenderStateDiff[]
+  ) {
+    super(message);
+    this.name = "RenderStateLeakError";
+  }
+}

package/src/ReportExporter.ts

@@ -0,0 +1,32 @@
+export interface DebugReport {
+  readonly generatedAt: string;
+  readonly name: string;
+  readonly data: unknown;
+}
+
+export class ReportExporter {
+  constructor(private readonly now: () => Date = () => new Date()) {}
+
+  create(name: string, data: unknown): DebugReport {
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+      throw new Error("Report name is required");
+    }
+    return {
+      generatedAt: this.now().toISOString(),
+      name: trimmed,
+      data
+    };
+  }
+
+  toJson(report: DebugReport): string {
+    return `${JSON.stringify(report, sortKeys, 2)}\n`;
+  }
+}
+
+function sortKeys(_key: string, value: unknown): unknown {
+  if (value === null || Array.isArray(value) || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value as Record<string, unknown>).sort(([left], [right]) => left.localeCompare(right)));
+}

package/src/ResourceTracker.ts

@@ -0,0 +1,59 @@
+export interface TrackedResource {
+  readonly id: string;
+  readonly type: string;
+  readonly disposed: boolean;
+}
+
+export interface ResourceLeakReport {
+  readonly total: number;
+  readonly leaked: number;
+  readonly resources: readonly TrackedResource[];
+  readonly leaks: readonly TrackedResource[];
+}
+
+export class ResourceTracker {
+  private readonly resources = new Map<string, TrackedResource>();
+
+  track(id: string, type: string): void {
+    if (this.resources.has(id)) {
+      throw new Error(`Resource already tracked: ${id}`);
+    }
+    this.resources.set(id, { id, type, disposed: false });
+  }
+
+  dispose(id: string): void {
+    const resource = this.resources.get(id);
+    if (!resource) {
+      throw new Error(`Unknown resource: ${id}`);
+    }
+    this.resources.set(id, { ...resource, disposed: true });
+  }
+
+  report(): ResourceLeakReport {
+    const resources = [...this.resources.values()].sort((a, b) => a.id.localeCompare(b.id));
+    const leaks = resources.filter((resource) => !resource.disposed);
+    return {
+      total: resources.length,
+      leaked: leaks.length,
+      resources,
+      leaks
+    };
+  }
+
+  assertNoLeaks(): void {
+    const report = this.report();
+    if (report.leaked > 0) {
+      throw new ResourceLeakError("Resource leaks detected", report);
+    }
+  }
+}
+
+export class ResourceLeakError extends Error {
+  constructor(
+    message: string,
+    public readonly report: ResourceLeakReport
+  ) {
+    super(message);
+    this.name = "ResourceLeakError";
+  }
+}

package/src/SceneHelpers.ts

@@ -0,0 +1,188 @@
+import type { DebugRenderLine } from "./DebugLineCanvasRenderer.js";
+
+export type DebugVec3 = readonly [number, number, number];
+export type DebugColor = readonly [number, number, number, number];
+
+export interface AxesHelperOptions {
+  readonly size?: number;
+  readonly origin?: DebugVec3;
+}
+
+export interface GridHelperOptions {
+  readonly size?: number;
+  readonly divisions?: number;
+  readonly y?: number;
+  readonly color?: DebugColor;
+  readonly centerColor?: DebugColor;
+}
+
+export interface BoundsHelperOptions {
+  readonly min: DebugVec3;
+  readonly max: DebugVec3;
+  readonly color?: DebugColor;
+}
+
+export interface CameraFrustumHelperOptions {
+  readonly nearHalfWidth: number;
+  readonly nearHalfHeight: number;
+  readonly farHalfWidth: number;
+  readonly farHalfHeight: number;
+  readonly nearZ?: number;
+  readonly farZ?: number;
+  readonly color?: DebugColor;
+}
+
+export interface DirectionalLightHelperOptions {
+  readonly direction: DebugVec3;
+  readonly origin?: DebugVec3;
+  readonly length?: number;
+  readonly color?: DebugColor;
+}
+
+export interface SkeletonHelperJoint {
+  readonly id: string;
+  readonly parentId?: string;
+  readonly position: DebugVec3;
+}
+
+const AXIS_X: DebugColor = [1, 0.18, 0.14, 1];
+const AXIS_Y: DebugColor = [0.18, 0.86, 0.28, 1];
+const AXIS_Z: DebugColor = [0.2, 0.48, 1, 1];
+const DEFAULT_GRID: DebugColor = [0.38, 0.46, 0.58, 1];
+const DEFAULT_CENTER: DebugColor = [0.72, 0.78, 0.86, 1];
+const DEFAULT_HELPER: DebugColor = [1, 0.84, 0.28, 1];
+
+export function buildAxesHelper(options: AxesHelperOptions = {}): readonly DebugRenderLine[] {
+  const size = positive(options.size ?? 1, "Axes helper size");
+  const origin = options.origin ?? [0, 0, 0];
+  return [
+    { from: origin, to: [origin[0] + size, origin[1], origin[2]], color: AXIS_X },
+    { from: origin, to: [origin[0], origin[1] + size, origin[2]], color: AXIS_Y },
+    { from: origin, to: [origin[0], origin[1], origin[2] + size], color: AXIS_Z }
+  ];
+}
+
+export function buildGridHelper(options: GridHelperOptions = {}): readonly DebugRenderLine[] {
+  const size = positive(options.size ?? 10, "Grid helper size");
+  const divisions = integerAtLeast(options.divisions ?? 10, 1, "Grid helper divisions");
+  const y = finite(options.y ?? 0, "Grid helper y");
+  const half = size / 2;
+  const step = size / divisions;
+  const lines: DebugRenderLine[] = [];
+  for (let index = 0; index <= divisions; index += 1) {
+    const offset = -half + index * step;
+    const isCenter = Math.abs(offset) < 1e-8;
+    const color = isCenter ? options.centerColor ?? DEFAULT_CENTER : options.color ?? DEFAULT_GRID;
+    lines.push({ from: [-half, y, offset], to: [half, y, offset], color });
+    lines.push({ from: [offset, y, -half], to: [offset, y, half], color });
+  }
+  return lines;
+}
+
+export function buildBoundsHelper(options: BoundsHelperOptions): readonly DebugRenderLine[] {
+  validateVec3(options.min, "Bounds helper min");
+  validateVec3(options.max, "Bounds helper max");
+  const [minX, minY, minZ] = options.min;
+  const [maxX, maxY, maxZ] = options.max;
+  if (maxX < minX || maxY < minY || maxZ < minZ) {
+    throw new RangeError("Bounds helper max must be greater than or equal to min.");
+  }
+  const color = options.color ?? DEFAULT_HELPER;
+  const p: readonly DebugVec3[] = [
+    [minX, minY, minZ], [maxX, minY, minZ], [maxX, maxY, minZ], [minX, maxY, minZ],
+    [minX, minY, maxZ], [maxX, minY, maxZ], [maxX, maxY, maxZ], [minX, maxY, maxZ]
+  ];
+  return edges([
+    [0, 1], [1, 2], [2, 3], [3, 0],
+    [4, 5], [5, 6], [6, 7], [7, 4],
+    [0, 4], [1, 5], [2, 6], [3, 7]
+  ], p, color);
+}
+
+export function buildCameraFrustumHelper(options: CameraFrustumHelperOptions): readonly DebugRenderLine[] {
+  const nearHalfWidth = positive(options.nearHalfWidth, "Camera frustum nearHalfWidth");
+  const nearHalfHeight = positive(options.nearHalfHeight, "Camera frustum nearHalfHeight");
+  const farHalfWidth = positive(options.farHalfWidth, "Camera frustum farHalfWidth");
+  const farHalfHeight = positive(options.farHalfHeight, "Camera frustum farHalfHeight");
+  const nearZ = finite(options.nearZ ?? -0.1, "Camera frustum nearZ");
+  const farZ = finite(options.farZ ?? -1, "Camera frustum farZ");
+  if (Math.abs(nearZ - farZ) < 1e-8) {
+    throw new RangeError("Camera frustum nearZ and farZ must be distinct.");
+  }
+  const p: readonly DebugVec3[] = [
+    [-nearHalfWidth, -nearHalfHeight, nearZ],
+    [nearHalfWidth, -nearHalfHeight, nearZ],
+    [nearHalfWidth, nearHalfHeight, nearZ],
+    [-nearHalfWidth, nearHalfHeight, nearZ],
+    [-farHalfWidth, -farHalfHeight, farZ],
+    [farHalfWidth, -farHalfHeight, farZ],
+    [farHalfWidth, farHalfHeight, farZ],
+    [-farHalfWidth, farHalfHeight, farZ]
+  ];
+  return edges([
+    [0, 1], [1, 2], [2, 3], [3, 0],
+    [4, 5], [5, 6], [6, 7], [7, 4],
+    [0, 4], [1, 5], [2, 6], [3, 7]
+  ], p, options.color ?? DEFAULT_HELPER);
+}
+
+export function buildDirectionalLightHelper(options: DirectionalLightHelperOptions): readonly DebugRenderLine[] {
+  const origin = options.origin ?? [0, 0, 0];
+  const length = positive(options.length ?? 1, "Directional light helper length");
+  const direction = normalize(options.direction, "Directional light helper direction");
+  const to: DebugVec3 = [
+    origin[0] + direction[0] * length,
+    origin[1] + direction[1] * length,
+    origin[2] + direction[2] * length
+  ];
+  return [{ from: origin, to, color: options.color ?? DEFAULT_HELPER }];
+}
+
+export function buildSkeletonHelper(joints: readonly SkeletonHelperJoint[], color: DebugColor = DEFAULT_HELPER): readonly DebugRenderLine[] {
+  const byId = new Map<string, SkeletonHelperJoint>();
+  for (const joint of joints) {
+    if (!joint.id) throw new Error("Skeleton helper joints require stable ids.");
+    validateVec3(joint.position, `Skeleton helper joint ${joint.id}`);
+    byId.set(joint.id, joint);
+  }
+  const lines: DebugRenderLine[] = [];
+  for (const joint of joints) {
+    if (!joint.parentId) continue;
+    const parent = byId.get(joint.parentId);
+    if (!parent) continue;
+    lines.push({ from: parent.position, to: joint.position, color });
+  }
+  return lines;
+}
+
+function edges(indices: readonly (readonly [number, number])[], points: readonly DebugVec3[], color: DebugColor): readonly DebugRenderLine[] {
+  return indices.map(([from, to]) => ({ from: points[from]!, to: points[to]!, color }));
+}
+
+function positive(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${label} must be finite and positive.`);
+  return value;
+}
+
+function finite(value: number, label: string): number {
+  if (!Number.isFinite(value)) throw new RangeError(`${label} must be finite.`);
+  return value;
+}
+
+function integerAtLeast(value: number, minimum: number, label: string): number {
+  if (!Number.isInteger(value) || value < minimum) throw new RangeError(`${label} must be an integer >= ${minimum}.`);
+  return value;
+}
+
+function validateVec3(value: readonly number[], label: string): void {
+  if (value.length !== 3 || value.some((component) => !Number.isFinite(component))) {
+    throw new RangeError(`${label} must contain three finite values.`);
+  }
+}
+
+function normalize(value: DebugVec3, label: string): DebugVec3 {
+  validateVec3(value, label);
+  const length = Math.hypot(value[0], value[1], value[2]);
+  if (length <= 1e-8) throw new RangeError(`${label} must be non-zero.`);
+  return [value[0] / length, value[1] / length, value[2] / length];
+}

package/src/ShaderDiagnostics.ts

@@ -0,0 +1,64 @@
+import { type RenderShaderProgram, type ShaderSources } from "@aura3d/rendering";
+
+export interface ShaderDiagnosticReport {
+  readonly label: string;
+  readonly marker: string;
+  readonly markerPresentInVertex: boolean;
+  readonly markerPresentInFragment: boolean;
+  readonly attributes: readonly string[];
+  readonly uniforms: readonly string[];
+  readonly compileLog: string | null;
+}
+
+export class ShaderDiagnostics {
+  inspectSources(sources: ShaderSources, compileLog: string | null = null): ShaderDiagnosticReport {
+    return {
+      label: sources.label,
+      marker: sources.marker,
+      markerPresentInVertex: sources.vertex.includes(sources.marker),
+      markerPresentInFragment: sources.fragment.includes(sources.marker),
+      attributes: extractNames(/\b(?:in|attribute)\s+\w+\s+(\w+)\s*;/g, `${sources.vertex}\n${sources.fragment}`),
+      uniforms: extractNames(/\buniform\s+\w+\s+(\w+)(?:\s*\[[^\]]+\])?\s*;/g, `${sources.vertex}\n${sources.fragment}`),
+      compileLog
+    };
+  }
+
+  inspectProgram(program: RenderShaderProgram, compileLog: string | null = null): ShaderDiagnosticReport {
+    return {
+      label: program.label,
+      marker: program.marker,
+      markerPresentInVertex: true,
+      markerPresentInFragment: true,
+      attributes: [...program.reflection.attributes.keys()],
+      uniforms: [...program.reflection.uniforms],
+      compileLog
+    };
+  }
+
+  assertMarker(report: ShaderDiagnosticReport): void {
+    if (!report.markerPresentInVertex || !report.markerPresentInFragment) {
+      throw new ShaderDiagnosticError("Shader marker mismatch", report);
+    }
+  }
+}
+
+export class ShaderDiagnosticError extends Error {
+  constructor(
+    message: string,
+    public readonly report: ShaderDiagnosticReport
+  ) {
+    super(message);
+    this.name = "ShaderDiagnosticError";
+  }
+}
+
+function extractNames(pattern: RegExp, source: string): readonly string[] {
+  const names = new Set<string>();
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(source)) !== null) {
+    if (match[1]) {
+      names.add(match[1]);
+    }
+  }
+  return [...names];
+}

package/src/index.ts

@@ -0,0 +1,46 @@
+export { DrawCallTracker } from "./DrawCallTracker.js";
+export type { DrawCallRecord, DrawCallSnapshot } from "./DrawCallTracker.js";
+export { RenderStateInspector, RenderStateLeakError } from "./RenderStateInspector.js";
+export type { RenderStateDiff, RenderStateSnapshot, RenderStateValue } from "./RenderStateInspector.js";
+export { ShaderDiagnosticError, ShaderDiagnostics } from "./ShaderDiagnostics.js";
+export type { ShaderDiagnosticReport } from "./ShaderDiagnostics.js";
+export { MaterialDiagnosticError, MaterialDiagnostics } from "./MaterialDiagnostics.js";
+export type { MaterialDiagnosticReport } from "./MaterialDiagnostics.js";
+export { PhysicsDebugAdapter } from "./PhysicsDebugAdapter.js";
+export type { PhysicsDebugSnapshot, PhysicsStackEvidence } from "./PhysicsDebugAdapter.js";
+export { AnimationInspector } from "./AnimationInspector.js";
+export type { AnimationDebugSnapshot, AnimationVisualEvidence, SkeletonDebugSnapshot } from "./AnimationInspector.js";
+export { Profiler } from "./Profiler.js";
+export type { ProfilerMarker, ProfilerSnapshot } from "./Profiler.js";
+export { GPUProfiler } from "./GPUProfiler.js";
+export type { GPUProfilerSnapshot, GPUSample, GPUProfilerTimer } from "./GPUProfiler.js";
+export { ChromeTraceExporter } from "./ChromeTraceExporter.js";
+export type { ChromeTrace, ChromeTraceEvent, ChromeTraceExportOptions } from "./ChromeTraceExporter.js";
+export { ResourceLeakError, ResourceTracker } from "./ResourceTracker.js";
+export type { ResourceLeakReport, TrackedResource } from "./ResourceTracker.js";
+export { ECSInspector } from "./ECSInspector.js";
+export type { ECSInspectorSnapshot, ECSWorldLike } from "./ECSInspector.js";
+export { DebugOverlay } from "./DebugOverlay.js";
+export type { DebugOverlayRow, DebugOverlaySection, DebugOverlaySnapshot } from "./DebugOverlay.js";
+export { DebugLineCanvasRenderer } from "./DebugLineCanvasRenderer.js";
+export type { DebugLineCanvasRendererOptions, DebugLineCanvasRenderResult, DebugRenderLine } from "./DebugLineCanvasRenderer.js";
+export {
+  buildAxesHelper,
+  buildBoundsHelper,
+  buildCameraFrustumHelper,
+  buildDirectionalLightHelper,
+  buildGridHelper,
+  buildSkeletonHelper
+} from "./SceneHelpers.js";
+export type {
+  AxesHelperOptions,
+  BoundsHelperOptions,
+  CameraFrustumHelperOptions,
+  DebugColor,
+  DebugVec3,
+  DirectionalLightHelperOptions,
+  GridHelperOptions,
+  SkeletonHelperJoint
+} from "./SceneHelpers.js";
+export { ReportExporter } from "./ReportExporter.js";
+export type { DebugReport } from "./ReportExporter.js";

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "useUnknownInCatchVariables": true,
+    "exactOptionalPropertyTypes": false,
+    "isolatedModules": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "paths": {
+      "@aura3d/rendering": ["../rendering/src/index.ts"],
+      "@aura3d/scene": ["../scene/src/index.ts"],
+      "@aura3d/math": ["../math/src/index.ts"],
+      "@aura3d/core": ["../core/src/index.ts"]
+    }
+  },
+  "include": [
+    "src/DrawCallTracker.ts",
+    "src/RenderStateInspector.ts",
+    "src/ShaderDiagnostics.ts",
+    "src/MaterialDiagnostics.ts",
+    "src/index.ts"
+  ]
+}