incanto 0.1.0

package/dist/create-game-CZHROKcT.js

@@ -0,0 +1,527 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { _ as registerBehavior, n as loadScene, o as computeViewport, s as resolveViewport } from "./loader-CGs_G-r0.js";
+import { a as Engine } from "./particle-sim-DYuSUxvK.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { r as AudioPlayer } from "./register-BuUV1_KB.js";
+import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
+import { n as registerGameplayBehaviors } from "./gameplay-Ccruc3Wd.js";
+import { f as PhysicsBody2D, h as Node2D, n as UILayer, s as Camera2D, t as registerNodes2D } from "./register-DPEV9_9t.js";
+import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
+import { n as enablePhysics2D } from "./physics-2d-KuMWPTf6.js";
+import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
+//#region src/2d/assets.ts
+/**
+* String-keyed asset registry for the 2D layer (Phaser's loader model).
+*
+* Scene JSON declares assets under stable keys; node props reference them as
+* `"$key"`. The texture loader is injectable so tests run headless.
+*/
+var AssetStore2D = class {
+	entries = /* @__PURE__ */ new Map();
+	loader;
+	constructor(loader) {
+		this.loader = loader ?? ((url, callbacks) => new TextureLoader().load(url, () => callbacks?.onLoad?.(), void 0, (err) => callbacks?.onError?.(err)));
+	}
+	/** Load (or extend with) a scene's `assets` declarations. Hard-validates each entry. */
+	load(assets) {
+		for (const [key, decl] of Object.entries(assets)) {
+			const type = decl.type;
+			if (type !== "texture" && type !== "spritesheet") throw new IncantoError("BAD_FORMAT", `Asset '${key}': "type" must be 'texture' or 'spritesheet', got ${JSON.stringify(type)}.`);
+			if (typeof decl.url !== "string" || decl.url === "") throw new IncantoError("BAD_FORMAT", `Asset '${key}': "url" must be a non-empty string.`);
+			let frameWidth;
+			let frameHeight;
+			if (type === "spritesheet") {
+				if (typeof decl.frameWidth !== "number" || typeof decl.frameHeight !== "number") throw new IncantoError("BAD_FORMAT", `Asset '${key}': spritesheets need numeric "frameWidth" and "frameHeight".`);
+				frameWidth = decl.frameWidth;
+				frameHeight = decl.frameHeight;
+			}
+			const previous = this.entries.get(key);
+			const state = { status: "loading" };
+			const texture = this.loader(decl.url, {
+				onLoad: () => {
+					state.status = "ready";
+				},
+				onError: (err) => {
+					state.status = "error";
+					console.error(`[incanto] failed to load texture '${key}' (${decl.url}):`, err);
+				}
+			});
+			if (previous && previous.texture !== texture) previous.texture.dispose();
+			texture.colorSpace = SRGBColorSpace;
+			if (decl.filter === "nearest") {
+				texture.magFilter = NearestFilter;
+				texture.minFilter = NearestFilter;
+				texture.generateMipmaps = false;
+			} else texture.magFilter = LinearFilter;
+			texture.needsUpdate = true;
+			this.entries.set(key, {
+				texture,
+				type,
+				frameWidth,
+				frameHeight,
+				state
+			});
+		}
+	}
+	/** Load status of a declared asset KEY (no '$'), or undefined if unknown. */
+	status(key) {
+		return this.entries.get(key)?.state.status;
+	}
+	getTexture(ref) {
+		return this.resolve(ref).texture;
+	}
+	getSheet(ref) {
+		const entry = this.resolve(ref);
+		if (entry.type !== "spritesheet") throw new IncantoError("BAD_FORMAT", `Asset '${ref}' is a plain texture; a spritesheet (with frameWidth/frameHeight) is required here.`);
+		return {
+			texture: entry.texture,
+			frameWidth: entry.frameWidth,
+			frameHeight: entry.frameHeight
+		};
+	}
+	resolve(ref) {
+		if (!ref.startsWith("$")) throw new IncantoError("UNKNOWN_ASSET", `Asset reference '${ref}' must use the '$key' form (e.g. '$${ref}').`);
+		const entry = this.entries.get(ref.slice(1));
+		if (!entry) throw new IncantoError("UNKNOWN_ASSET", `Unknown asset '${ref}'. Declared assets: [${[...this.entries.keys()].join(", ")}].`);
+		return entry;
+	}
+};
+//#endregion
+//#region src/2d/picking.ts
+function screenFromWorld(view, wx, wy) {
+	return {
+		x: (wx - view.cx) * view.zoom + view.w / 2,
+		y: (wy - view.cy) * view.zoom + view.h / 2
+	};
+}
+function worldFromScreen(view, sx, sy) {
+	return {
+		x: (sx - view.w / 2) / view.zoom + view.cx,
+		y: (sy - view.h / 2) / view.zoom + view.cy
+	};
+}
+//#endregion
+//#region src/2d/sync.ts
+/**
+* Mirror an Incanto node tree onto two three scenes:
+* - `world`: camera-space drawables
+* - `ui`: everything under a `UILayer` (screen space, ignores the camera);
+*   each layer mounts through its own group, positioned by its `anchor`
+*   against `uiSize` (origin when no size is known — headless).
+*
+* Same dirty-push contract as the 3D sync; pure scene-graph math, headless-testable.
+*/
+function syncTree2D(root, world, ui, assets, uiSize) {
+	const visited = /* @__PURE__ */ new Set();
+	const cameras = [];
+	walk(root, world, ui, false, visited, cameras, assets, uiSize);
+	prune(world, visited);
+	prune(ui, visited);
+	return { activeCamera: cameras.find((c) => c.current) ?? cameras[0] ?? null };
+}
+function walk(node, parentObj, ui, inUi, visited, cameras, assets, uiSize) {
+	let nextParent = parentObj;
+	let nextInUi = inUi;
+	if (node instanceof UILayer) {
+		const group = node._ensureGroup();
+		if (group.parent !== ui) ui.add(group);
+		const origin = uiSize ? node._anchorOrigin(uiSize.width, uiSize.height) : {
+			x: 0,
+			y: 0
+		};
+		group.position.set(origin.x, -origin.y, 0);
+		visited.add(group);
+		nextInUi = true;
+		nextParent = group;
+	} else if (node instanceof Node2D) {
+		const obj = node._ensureObject2D();
+		if (obj.parent !== parentObj) parentObj.add(obj);
+		node._syncObject2D(assets);
+		visited.add(obj);
+		if (node instanceof Camera2D && !inUi) cameras.push(node);
+		nextParent = obj;
+	}
+	for (const child of node.children) walk(child, nextParent, ui, nextInUi, visited, cameras, assets, uiSize);
+}
+function prune(obj, visited) {
+	for (const child of [...obj.children]) if (child.userData.incantoNode && !visited.has(child)) obj.remove(child);
+	else prune(child, visited);
+}
+//#endregion
+//#region src/2d/renderer.ts
+/**
+* 2D presentation layer: world pass through the active Camera2D
+* (center/zoom/limits), then a screen-space UI pass for UILayer subtrees.
+* 1 unit = 1 px, (0,0) top-left, +y down.
+*/
+var Renderer2D = class {
+	/**
+	* When set, the world pass frames THIS view instead of the scene's active
+	* Camera2D — tooling (the scene editor) pans/zooms freely without touching
+	* scene data. `null` restores normal camera behavior.
+	*/
+	viewOverride = null;
+	webgl;
+	worldScene = new Scene();
+	uiScene = new Scene();
+	worldCam = new OrthographicCamera(-1, 1, 1, -1, -1e3, 1e3);
+	uiCam = new OrthographicCamera(-1, 1, 1, -1, -1e3, 1e3);
+	engine;
+	assets;
+	loadedAssetScenes = /* @__PURE__ */ new WeakSet();
+	disconnect;
+	canvas;
+	constructor(opts) {
+		this.canvas = opts.canvas;
+		this.engine = opts.engine;
+		this.assets = opts.assets ?? new AssetStore2D();
+		const rendering = resolveRendering(opts.engine.scene?.environment, {
+			antialias: true,
+			pixelRatio: 1
+		}, globalThis.devicePixelRatio ?? 1, opts);
+		this.webgl = new WebGLRenderer({
+			canvas: opts.canvas,
+			antialias: rendering.antialias
+		});
+		this.webgl.setPixelRatio(rendering.pixelRatio);
+		this.webgl.info.autoReset = false;
+		this.debugLines = new LineSegments(new BufferGeometry(), new LineBasicMaterial({ color: "#00ff6e" }));
+		this.debugLines.frustumCulled = false;
+		this.debugLines.renderOrder = 9999;
+		this.debugLines.visible = false;
+		this.worldScene.add(this.debugLines);
+		this.disconnect = this.engine.updated.connect(() => this.render());
+	}
+	debugLines;
+	syncDebugLines() {
+		let vertices = null;
+		for (const source of debugSources("2d")) {
+			vertices = source.debugLines();
+			if (vertices) break;
+		}
+		this.debugLines.visible = vertices !== null;
+		if (!vertices) return;
+		const xyz = new Float32Array(vertices.length / 2 * 3);
+		for (let i = 0, j = 0; i < vertices.length; i += 2, j += 3) {
+			xyz[j] = vertices[i];
+			xyz[j + 1] = vertices[i + 1];
+			xyz[j + 2] = 0;
+		}
+		this.debugLines.geometry.setAttribute("position", new BufferAttribute(xyz, 3));
+	}
+	render() {
+		const scene = this.engine.scene;
+		if (!scene) return;
+		this.webgl.info.reset();
+		this.syncDebugLines();
+		if (scene.assets && !this.loadedAssetScenes.has(scene)) {
+			this.assets.load(scene.assets);
+			this.loadedAssetScenes.add(scene);
+		}
+		const background = scene.environment?.background;
+		this.worldScene.background = typeof background === "string" ? new Color(background) : null;
+		const w = this.canvas.clientWidth || this.canvas.width;
+		const h = this.canvas.clientHeight || this.canvas.height;
+		const size = this.webgl.getSize(sizeScratch);
+		if (size.x !== w || size.y !== h) this.webgl.setSize(w, h, false);
+		const vp = this.viewOverride ? null : resolveViewport(scene.viewport);
+		const view = vp ? computeViewport(w, h, vp) : null;
+		const uiW = view ? view.viewW : w;
+		const uiH = view ? view.viewH : h;
+		const { activeCamera } = syncTree2D(scene.root, this.worldScene, this.uiScene, this.assets, {
+			width: uiW,
+			height: uiH
+		});
+		let center = vp ? {
+			x: vp.design[0] / 2,
+			y: vp.design[1] / 2
+		} : {
+			x: w / 2,
+			y: h / 2
+		};
+		let zoom = 1;
+		if (this.viewOverride) {
+			center = {
+				x: this.viewOverride.cx,
+				y: this.viewOverride.cy
+			};
+			zoom = this.viewOverride.zoom;
+		} else if (activeCamera) {
+			center = activeCamera.clampedCenter(uiW, uiH);
+			zoom = activeCamera.effectiveZoom;
+		}
+		const scale = view?.scale ?? 1;
+		this.lastView = {
+			cx: center.x,
+			cy: center.y,
+			zoom: zoom * scale,
+			w,
+			h
+		};
+		this.lastViewport = view;
+		if (view && (view.offsetX > .5 || view.offsetY > .5)) {
+			this.webgl.setScissorTest(false);
+			this.webgl.setViewport(0, 0, w, h);
+			this.webgl.clear();
+			this.webgl.setViewport(view.offsetX, view.offsetY, view.contentW, view.contentH);
+			this.webgl.setScissor(view.offsetX, view.offsetY, view.contentW, view.contentH);
+			this.webgl.setScissorTest(true);
+		} else {
+			this.webgl.setScissorTest(false);
+			this.webgl.setViewport(0, 0, w, h);
+		}
+		frame(this.worldCam, center.x, center.y, uiW / zoom, uiH / zoom);
+		frame(this.uiCam, uiW / 2, uiH / 2, uiW, uiH);
+		this.webgl.autoClear = true;
+		this.webgl.render(this.worldScene, this.worldCam);
+		this.webgl.autoClear = false;
+		this.webgl.render(this.uiScene, this.uiCam);
+		this.webgl.autoClear = true;
+	}
+	lastViewport = null;
+	lastView = {
+		cx: 0,
+		cy: 0,
+		zoom: 1,
+		w: 1,
+		h: 1
+	};
+	/** The world view used by the LAST render (center/zoom/canvas size). */
+	view() {
+		return { ...this.lastView };
+	}
+	/**
+	* GPU counters for the LAST rendered frame (world + UI passes combined),
+	* straight from three's per-frame-maintained `renderer.info`.
+	*/
+	stats() {
+		const info = this.webgl.info;
+		return {
+			triangles: info.render.triangles,
+			drawCalls: info.render.calls,
+			geometries: info.memory.geometries,
+			textures: info.memory.textures
+		};
+	}
+	worldFromScreen(sx, sy) {
+		return worldFromScreen(this.lastView, sx, sy);
+	}
+	screenFromWorld(wx, wy) {
+		return screenFromWorld(this.lastView, wx, wy);
+	}
+	/**
+	* The topmost world-pass node under a canvas pixel (UI pass excluded).
+	* Hits resolve through `userData.incantoNode` and prefer higher renderOrder.
+	*/
+	pick(sx, sy) {
+		const { w, h } = this.lastView;
+		const ox = this.lastViewport?.offsetX ?? 0;
+		const oy = this.lastViewport?.offsetY ?? 0;
+		const cw = this.lastViewport?.contentW ?? w;
+		const ch = this.lastViewport?.contentH ?? h;
+		pickNdc.set((sx - ox) / cw * 2 - 1, -((sy - oy) / ch * 2 - 1));
+		raycaster.setFromCamera(pickNdc, this.worldCam);
+		const hits = raycaster.intersectObjects(this.worldScene.children, true);
+		let best = null;
+		for (const hit of hits) {
+			let obj = hit.object;
+			while (obj && !obj.userData.incantoNode) obj = obj.parent;
+			const node = obj?.userData.incantoNode;
+			if (!node) continue;
+			const order = hit.object.renderOrder ?? 0;
+			if (!best || order >= best.order) best = {
+				node,
+				order
+			};
+		}
+		return best?.node ?? null;
+	}
+	/**
+	* Canvas-pixel AABB of a node's rendered world-pass objects, or null when it
+	* has no renderable extent (plain Nodes, empty containers).
+	*/
+	boundsOf(node) {
+		const obj = node._object2D;
+		if (!obj) return null;
+		boundsScratch.makeEmpty();
+		boundsScratch.expandByObject(obj);
+		if (boundsScratch.isEmpty()) return null;
+		boundsScratch.getSize(sizeScratch3);
+		if (sizeScratch3.x === 0 && sizeScratch3.y === 0) return null;
+		const a = this.screenFromWorld(boundsScratch.min.x, -boundsScratch.max.y);
+		const b = this.screenFromWorld(boundsScratch.max.x, -boundsScratch.min.y);
+		return {
+			x: a.x,
+			y: a.y,
+			w: b.x - a.x,
+			h: b.y - a.y
+		};
+	}
+	dispose() {
+		this.disconnect();
+		for (const scene of [this.worldScene, this.uiScene]) scene.traverse((obj) => {
+			const mesh = obj;
+			if (!mesh.isMesh) return;
+			const mats = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+			for (const mat of mats) {
+				mat?.map?.dispose();
+				mat?.dispose();
+			}
+		});
+		this.webgl.dispose();
+	}
+};
+/** Aim an ortho camera at a y-down world center with a view of vw×vh world px. */
+function frame(cam, cx, cy, vw, vh) {
+	cam.position.set(cx, -cy, 10);
+	cam.left = -vw / 2;
+	cam.right = vw / 2;
+	cam.top = vh / 2;
+	cam.bottom = -vh / 2;
+	cam.updateProjectionMatrix();
+}
+const sizeScratch = new Vector2();
+const sizeScratch3 = new Vector3();
+const pickNdc = new Vector2();
+const raycaster = new Raycaster();
+const boundsScratch = new Box3();
+//#endregion
+//#region src/2d/create-game.ts
+var create_game_exports = /* @__PURE__ */ __exportAll({ createGame2D: () => createGame2D });
+/**
+* The one-call boot every game was hand-rolling: register → load (engine
+* attached, so onReady can use this.rng/this.log) → physics (auto-detected) →
+* input → renderer → start. The returned `dispose()` is the one-call
+* teardown for SPA unmounts. Audio unlocks on the first user gesture.
+*/
+async function createGame2D(opts) {
+	registerNodes2D();
+	if (opts.gameplay ?? true) registerGameplayBehaviors();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	const engine = new Engine({
+		seed: opts.seed,
+		fixedHz: opts.fixedHz,
+		...opts._scheduler ? { scheduler: opts._scheduler } : {}
+	});
+	const scene = loadScene(cloneSceneJson(opts.scene), {
+		resolveScene: opts.resolveScene,
+		engine
+	});
+	engine.setScene(scene);
+	let physics = null;
+	if (opts.physics === true || (opts.physics ?? "auto") === "auto" && hasBody(scene.root)) physics = await enablePhysics2D(engine);
+	const cleanups = [];
+	const keyboard = opts.keyboard ?? (typeof window !== "undefined" ? window : false);
+	if (keyboard) engine.input.attachKeyboard(keyboard);
+	cleanups.push(wireAudioUnlock(engine, scene.root, opts.canvas));
+	const touchMode = opts.touch ?? "auto";
+	if (touchMode !== false) {
+		const host = opts.touchContainer ?? opts.canvas.parentElement ?? null;
+		if (host) {
+			const touchOpts = {
+				force: touchMode === true,
+				...opts._touchDoc ? { doc: opts._touchDoc } : {}
+			};
+			let touchControls = attachTouchControls(engine, host, touchOpts);
+			const offSceneChanged = engine.sceneChanged.connect(() => {
+				touchControls?.dispose();
+				touchControls = attachTouchControls(engine, host, touchOpts);
+			});
+			cleanups.push(() => {
+				offSceneChanged();
+				touchControls?.dispose();
+			});
+		}
+	}
+	const renderer = opts._rendererFactory ? opts._rendererFactory(engine, opts.canvas) : new Renderer2D({
+		canvas: opts.canvas,
+		engine,
+		...opts.pixelRatio !== void 0 ? { pixelRatio: opts.pixelRatio } : {},
+		...opts.antialias !== void 0 ? { antialias: opts.antialias } : {}
+	});
+	if (opts.debug ?? false) {
+		const host = opts.touchContainer ?? opts.canvas.parentElement ?? (typeof document !== "undefined" ? document.body : null);
+		if (host) {
+			const { attachDebugOverlay } = await import("./debug.js");
+			const overlay = attachDebugOverlay(engine, {
+				container: host,
+				statsSource: () => renderer.stats?.() ?? {},
+				...opts._debugDoc ? { doc: opts._debugDoc } : {}
+			});
+			if (overlay) cleanups.push(() => overlay.dispose());
+		}
+	}
+	engine.start();
+	return {
+		engine,
+		scene,
+		renderer,
+		physics,
+		stats() {
+			return {
+				triangles: 0,
+				drawCalls: 0,
+				geometries: 0,
+				textures: 0,
+				...engine.stats(),
+				...renderer.stats?.()
+			};
+		},
+		dispose() {
+			renderer.dispose();
+			physics?.dispose();
+			for (const cleanup of cleanups) cleanup();
+			engine.dispose();
+		}
+	};
+}
+function cloneSceneJson(json) {
+	try {
+		return structuredClone(json);
+	} catch {
+		throw new IncantoError("BAD_FORMAT", "createGame \"scene\" must be plain scene JSON (the imported *.scene.json object) — got something unclonable (a loaded Scene, class instances, or functions).");
+	}
+}
+function hasBody(root) {
+	if (root instanceof PhysicsBody2D) return true;
+	for (const child of root.children) if (hasBody(child)) return true;
+	return false;
+}
+/**
+* Browsers gate audio behind a user gesture — retry pending players on the
+* first pointer or key gesture, then stop listening once nothing is pending.
+*/
+function wireAudioUnlock(engine, root, canvas) {
+	const sources = [];
+	const canvasTarget = canvas;
+	if (canvasTarget.addEventListener) sources.push({
+		target: canvasTarget,
+		type: "pointerdown"
+	});
+	if (typeof window !== "undefined") sources.push({
+		target: window,
+		type: "keydown"
+	});
+	if (sources.length === 0) return () => {};
+	function detachAll() {
+		for (const s of sources) s.target.removeEventListener?.(s.type, unlock);
+	}
+	function unlock() {
+		engine.sfx.unlock();
+		engine.music.unlock();
+		let pending = false;
+		const walk = (node) => {
+			if (node instanceof AudioPlayer) {
+				node.retryPending();
+				if (node.pendingGesture) pending = true;
+			}
+			for (const child of node.children) walk(child);
+		};
+		walk(root);
+		if (!pending) detachAll();
+	}
+	for (const s of sources) s.target.addEventListener?.(s.type, unlock, { passive: true });
+	return detachAll;
+}
+//#endregion
+export { AssetStore2D as a, syncTree2D as i, create_game_exports as n, Renderer2D as r, createGame2D as t };

package/dist/debug-draw-CZmOYjL2.js

@@ -0,0 +1,13 @@
+//#region src/core/debug-draw.ts
+const sources = /* @__PURE__ */ new Set();
+/** @internal physics runtimes self-register on enable. */
+function registerDebugSource(source) {
+	sources.add(source);
+	return () => sources.delete(source);
+}
+/** @internal renderers pull their dimension's sources. */
+function debugSources(dimension) {
+	return [...sources].filter((s) => s.dimension === dimension);
+}
+//#endregion
+export { registerDebugSource as n, debugSources as t };

package/dist/debug.d.ts

@@ -0,0 +1,66 @@
+import { C as RendererStats, k as LogLevel, v as Engine } from "./behavior-BAQq7HGM.js";
+
+//#region src/debug/panel.d.ts
+/** Minimal document surface the overlay needs (injectable for tests). */
+interface DocumentLike {
+  createElement(tag: string): HTMLElement;
+}
+//#endregion
+//#region src/debug/index.d.ts
+type DebugPanelId = "explorer" | "inspector" | "logs" | "stats";
+interface DebugOverlayOptions {
+  /** Overlay host (default: document.body). Give it position: relative. */
+  container?: HTMLElement;
+  /**
+  * Renderer counters for the Stats chip — the overlay only holds the engine,
+  * so createGame wires `() => renderer.stats()` here. Omitted (headless/stub
+  * renderers): the chip shows engine stats only.
+  */
+  statsSource?: () => Partial<RendererStats>;
+  /** @internal Test seam — replaces `document`. */
+  doc?: DocumentLike;
+}
+/** Attach the overlay; null when no DOM is available (headless). */
+declare function attachDebugOverlay(engine: Engine, opts?: DebugOverlayOptions): DebugOverlay | null;
+declare class DebugOverlay {
+  private readonly engine;
+  private readonly container;
+  private readonly doc;
+  private readonly statsSource?;
+  private readonly panels;
+  private readonly cleanups;
+  private readonly menuButton;
+  private dropdown;
+  private selected;
+  private statsChip;
+  private readonly logRows;
+  private readonly levelEnabled;
+  private consoleCapture;
+  private consolePatched;
+  private frame;
+  private editing;
+  constructor(engine: Engine, container: HTMLElement, doc: DocumentLike, statsSource?: (() => Partial<RendererStats>) | undefined);
+  isOpen(id: DebugPanelId): boolean;
+  open(id: DebugPanelId): void;
+  close(id: DebugPanelId): void;
+  toggle(id: DebugPanelId): void;
+  setLevelEnabled(level: LogLevel, on: boolean): void;
+  /**
+  * Patch console.* into the Logs panel (restored on disable/dispose).
+  * Standard monkey-patch hazard: a tool that patches console AFTER capture
+  * enables will be clobbered by our restore — enable capture last.
+  */
+  setConsoleCapture(on: boolean): void;
+  dispose(): void;
+  private toggleDropdown;
+  private openStatsChip;
+  private renderStats;
+  private renderExplorer;
+  private renderInspector;
+  private renderPropRow;
+  private trackEditing;
+  private pushLog;
+  private renderLogs;
+}
+//#endregion
+export { DebugOverlay, DebugOverlayOptions, DebugPanelId, attachDebugOverlay };