incanto 0.28.0 → 0.29.0

package/dist/debug.js

@@ -1,5 +1,6 @@
 import { t as jsonClone } from "./json-BLk7H2Qa.js";
 import { s as mergeStaticProps } from "./registry-BVJ2HbCn.js";
+import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
 //#region src/debug/panel.ts
 /** Keep a panel rect on screen and above the minimum usable size. */
 function clampPanelRect(x, y, w, h, viewW, viewH, minW = 180, minH = 120) {
@@ -152,13 +153,52 @@ var FloatingPanel = class {
 };
 //#endregion
 //#region src/debug/index.ts
+/**
+* incanto/debug — the runtime debug overlay: play the game WITH X-ray vision.
+*
+* A ☰ debug menu (top-left) toggles three floating, draggable, resizable
+* panels over the running game:
+* - Explorer — the live scene tree; click a node to inspect it
+* - Inspector — the selected node's current state; simple values editable
+* - Logs — engine.log tail + optional browser-console capture, level filters
+* plus a Stats chip — a fixed always-on-top perf readout pinned top-right
+* (fps · frame ms / nodes · tris · draw calls) — and a Colliders switch that
+* draws every physics shape as wireframe over the live game.
+*
+* Enable via `createGame({ debug: true })`, gated to dev (e.g.
+* `debug: import.meta.env.VITE_INCANTO_DEBUG === '1'`). There is NO URL/query
+* toggle — a deployed build must not be switchable on by end users.
+*/
+/** Longest serialized value the inspector shows inline, un-folded. */
+const DETAIL_INLINE_MAX = 96;
+/** Expanded detail is capped — a 100k-float vertices array must not be the DOM. */
+const DETAIL_MAX_ROWS = 200;
+const DETAIL_MAX_CHARS = 8192;
+/** One line saying what the folded value is and how much of it there is. */
+function summarizeValue(value) {
+	if (Array.isArray(value)) return `Array(${value.length})`;
+	return `Object(${Object.keys(value).length} keys)`;
+}
+/** The unfolded body: one row per element where that reads better than a blob. */
+function detailText(value, json) {
+	if (Array.isArray(value) && value.some((v) => typeof v === "object" && v !== null)) {
+		const rows = value.slice(0, DETAIL_MAX_ROWS).map((v) => JSON.stringify(v));
+		const extra = value.length - DETAIL_MAX_ROWS;
+		return rows.join("\n") + (extra > 0 ? `\n… ${extra} more` : "");
+	}
+	return json.length > DETAIL_MAX_CHARS ? `${json.slice(0, DETAIL_MAX_CHARS)} … (${json.length - DETAIL_MAX_CHARS} more chars)` : json;
+}
+/** A JSON object (not an array, not null) — the shape that becomes a block. */
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /** Attach the overlay; null when no DOM is available (headless). */
 function attachDebugOverlay(engine, opts = {}) {
 	const doc = opts.doc ?? (typeof document !== "undefined" ? document : null);
 	if (!doc) return null;
 	const container = opts.container ?? (typeof document !== "undefined" ? document.body : null);
 	if (!container || typeof container.appendChild !== "function") return null;
-	return new DebugOverlay(engine, container, doc, opts.statsSource);
+	return new DebugOverlay(engine, container, doc, opts.statsSource, opts.actions);
 }
 const MAX_LOG_ROWS = 300;
 const CONSOLE_LEVELS = [
@@ -173,6 +213,7 @@ var DebugOverlay = class {
 	container;
 	doc;
 	statsSource;
+	actions;
 	panels = /* @__PURE__ */ new Map();
 	cleanups = [];
 	menuButton;
@@ -192,11 +233,16 @@ var DebugOverlay = class {
 	consolePatched = [];
 	frame = 0;
 	editing = 0;
-	constructor(engine, container, doc, statsSource) {
+	/** Which bulky values are unfolded, per node ('transforms', 'collider.vertices'). */
+	detailOpen = /* @__PURE__ */ new WeakMap();
+	/** Pointer inside the inspector — it stops refreshing under your hand. */
+	hovering = false;
+	constructor(engine, container, doc, statsSource, actions = []) {
 		this.engine = engine;
 		this.container = container;
 		this.doc = doc;
 		this.statsSource = statsSource;
+		this.actions = actions;
 		this.menuButton = doc.createElement("div");
 		this.menuButton.textContent = "☰ debug";
 		applyStyle(this.menuButton, {
@@ -226,6 +272,7 @@ var DebugOverlay = class {
 		}));
 		this.cleanups.push(engine.sceneChanged.connect(() => {
 			this.selected = null;
+			this.applyColliderScope();
 			this.renderExplorer();
 			this.renderInspector();
 		}));
@@ -234,12 +281,34 @@ var DebugOverlay = class {
 			if (this.frame % 30 !== 0) return;
 			this.renderExplorer();
 			this.renderStats();
-			if (this.editing === 0) this.renderInspector();
+			if (this.editing === 0 && !this.hovering) this.renderInspector();
 		}));
 	}
 	isOpen(id) {
+		if (id === "colliders") return this.colliderMode !== "off";
 		return id === "stats" ? this.statsChip !== null : this.panels.has(id);
 	}
+	/** How much of the physics world the wireframes show. */
+	colliderMode = "off";
+	/**
+	* Physics wireframes, from the menu instead of from the console. What you see
+	* is the shape data the solver holds — the fastest way to catch a collider
+	* that disagrees with the art it belongs to.
+	*
+	* `'selected'` narrows it to the Explorer's selection, because `'all'` on a
+	* real map is a terrain grid burying the one shape you came to look at.
+	*/
+	setColliders(mode) {
+		this.colliderMode = mode;
+		this.applyColliderScope();
+	}
+	applyColliderScope() {
+		const mode = this.colliderMode;
+		for (const source of debugSources("2d").concat(debugSources("3d"))) {
+			source.debugDraw = mode !== "off";
+			source.debugScope = mode === "selected" ? this.selected : null;
+		}
+	}
 	open(id) {
 		if (id === "stats") {
 			this.openStatsChip();
@@ -271,12 +340,21 @@ var DebugOverlay = class {
 			}
 		}[id]);
 		panel.onClose = () => this.close(id);
+		if (id === "inspector") {
+			panel.body.addEventListener("pointerenter", () => {
+				this.hovering = true;
+			});
+			panel.body.addEventListener("pointerleave", () => {
+				this.hovering = false;
+			});
+		}
 		this.panels.set(id, panel);
 		if (id === "explorer") this.renderExplorer();
 		if (id === "inspector") this.renderInspector();
 		if (id === "logs") this.renderLogs();
 	}
 	close(id) {
+		if (id === "inspector") this.hovering = false;
 		if (id === "stats") {
 			this.statsChip?.remove();
 			this.statsChip = null;
@@ -288,6 +366,14 @@ var DebugOverlay = class {
 		this.panels.delete(id);
 	}
 	toggle(id) {
+		if (id === "colliders") {
+			this.setColliders({
+				off: "all",
+				all: "selected",
+				selected: "off"
+			}[this.colliderMode]);
+			return;
+		}
 		if (this.isOpen(id)) this.close(id);
 		else this.open(id);
 	}
@@ -329,6 +415,7 @@ var DebugOverlay = class {
 	}
 	dispose() {
 		this.engine.debugSelection = null;
+		this.setColliders("off");
 		this.setConsoleCapture(false);
 		for (const cleanup of this.cleanups) cleanup();
 		for (const id of [...this.panels.keys()]) this.close(id);
@@ -337,6 +424,11 @@ var DebugOverlay = class {
 		this.dropdown = null;
 		this.menuButton.remove();
 	}
+	/** `✓ Colliders · selected` — check for on, suffix for the collider mode. */
+	menuLabel(id, label) {
+		const suffix = id === "colliders" && this.colliderMode !== "off" ? ` · ${this.colliderMode}` : "";
+		return `${this.isOpen(id) ? "✓ " : ""}${label}${suffix}`;
+	}
 	toggleDropdown() {
 		if (this.dropdown) {
 			this.dropdown.remove();
@@ -361,10 +453,11 @@ var DebugOverlay = class {
 			["explorer", "Explorer"],
 			["inspector", "Inspector"],
 			["logs", "Logs"],
-			["stats", "Stats"]
+			["stats", "Stats"],
+			["colliders", "Colliders"]
 		]) {
 			const item = this.doc.createElement("div");
-			item.textContent = `${this.isOpen(id) ? "✓ " : ""}${label}`;
+			item.textContent = this.menuLabel(id, label);
 			applyStyle(item, {
 				padding: "6px 14px",
 				cursor: "pointer",
@@ -372,11 +465,32 @@ var DebugOverlay = class {
 			});
 			item.addEventListener("click", () => {
 				this.toggle(id);
+				if (id === "colliders") {
+					item.textContent = this.menuLabel(id, label);
+					return;
+				}
 				this.dropdown?.remove();
 				this.dropdown = null;
 			});
 			menu.appendChild(item);
 		}
+		for (const action of this.actions) {
+			const item = this.doc.createElement("div");
+			item.textContent = action.label;
+			applyStyle(item, {
+				padding: "6px 14px",
+				cursor: "pointer",
+				userSelect: "none",
+				borderTop: "1px solid rgba(255,255,255,0.14)",
+				color: "rgba(158,232,220,0.95)"
+			});
+			item.addEventListener("click", () => {
+				this.dropdown?.remove();
+				this.dropdown = null;
+				action.run();
+			});
+			menu.appendChild(item);
+		}
 		this.container.appendChild(menu);
 		this.dropdown = menu;
 	}
@@ -418,9 +532,13 @@ var DebugOverlay = class {
 	renderExplorer() {
 		const panel = this.panels.get("explorer");
 		if (!panel) return;
+		const scroll = panel.body.scrollTop;
 		clear(panel.body);
 		const root = this.engine.scene?.root;
-		if (!root) return;
+		if (!root) {
+			panel.body.scrollTop = scroll;
+			return;
+		}
 		const renderNode = (node, container) => {
 			const ctor = node.constructor;
 			const hasKids = node.children.length > 0;
@@ -473,6 +591,7 @@ var DebugOverlay = class {
 			row.addEventListener("click", () => {
 				this.selected = node;
 				this.engine.debugSelection = node;
+				this.applyColliderScope();
 				this.open("inspector");
 				this.renderExplorer();
 				this.renderInspector();
@@ -490,15 +609,18 @@ var DebugOverlay = class {
 			}
 		};
 		renderNode(root, panel.body);
+		panel.body.scrollTop = scroll;
 	}
 	renderInspector() {
 		const panel = this.panels.get("inspector");
 		if (!panel) return;
+		const scroll = panel.body.scrollTop;
 		clear(panel.body);
 		let node = this.selected;
 		if (node && node.tree === null) {
 			this.selected = null;
 			this.engine.debugSelection = null;
+			this.applyColliderScope();
 			node = null;
 		}
 		if (!node) {
@@ -527,11 +649,37 @@ var DebugOverlay = class {
 			panel.body.appendChild(groups);
 		}
 		const schema = mergeStaticProps(ctor);
-		for (const key of Object.keys(schema)) this.renderPropRow(panel.body, node, key, schema[key]?.options);
-	}
-	renderPropRow(body, node, key, schemaOptions) {
 		const record = node;
-		const value = record[key];
+		for (const key of Object.keys(schema)) {
+			const def = schema[key];
+			this.renderValueRow(panel.body, node, key, {
+				read: () => record[key],
+				write: (next) => {
+					record[key] = next;
+				},
+				options: def?.options,
+				variants: def?.variants
+			});
+		}
+		panel.body.scrollTop = scroll;
+	}
+	/**
+	* One editable row. `read`/`write` are closures rather than a (node, key)
+	* pair so the SAME renderer serves a node prop and a key INSIDE an object
+	* prop — `collider.radius` gets a real number field instead of being a
+	* character in an ellipsised JSON dump.
+	*/
+	renderValueRow(body, node, key, access) {
+		const value = access.read();
+		const schemaOptions = access.options;
+		const record = {
+			get [key]() {
+				return access.read();
+			},
+			set [key](next) {
+				access.write(next);
+			}
+		};
 		const row = this.doc.createElement("div");
 		applyStyle(row, {
 			display: "flex",
@@ -551,6 +699,7 @@ var DebugOverlay = class {
 			input.type = "number";
 			input.value = String(current);
 			applyStyle(input, inputStyle("70px"));
+			this.trackEditing(input);
 			input.addEventListener("change", () => {
 				const next = Number(input.value);
 				if (Number.isFinite(next)) commit(next);
@@ -596,20 +745,94 @@ var DebugOverlay = class {
 				record[key] = input.value;
 			});
 			row.appendChild(input);
-		} else if (Array.isArray(value) && value.every((v) => typeof v === "number")) for (let i = 0; i < value.length; i++) row.appendChild(numberInput(value[i], (next) => {
+		} else if (Array.isArray(value) && value.length <= 8 && value.every((v) => typeof v === "number")) for (let i = 0; i < value.length; i++) row.appendChild(numberInput(value[i], (next) => {
 			const arr = [...record[key]];
 			arr[i] = next;
 			record[key] = arr;
 		}));
-		else {
-			const readout = this.doc.createElement("div");
-			readout.textContent = JSON.stringify(jsonClone(value));
-			applyStyle(readout, {
-				opacity: "0.65",
-				overflow: "hidden",
-				textOverflow: "ellipsis"
+		else if (isPlainObject(value)) {
+			const nest = this.doc.createElement("div");
+			applyStyle(nest, {
+				marginLeft: "10px",
+				paddingLeft: "8px",
+				borderLeft: "1px solid rgba(255,255,255,0.14)"
 			});
-			row.appendChild(readout);
+			const tag = access.variants?.tag;
+			const keys = Object.keys(value);
+			if (tag && !keys.includes(tag)) keys.unshift(tag);
+			const basePath = access.path ?? key;
+			for (const k of keys) {
+				const isTag = k === tag;
+				this.renderValueRow(nest, node, k, {
+					path: `${basePath}.${k}`,
+					read: () => access.read()[k] ?? (isTag ? "" : null),
+					write: (next) => {
+						if (isTag && access.variants) {
+							const preset = access.variants.byTag[String(next)];
+							if (preset !== void 0) {
+								access.write(jsonClone(preset));
+								return;
+							}
+						}
+						access.write({
+							...access.read(),
+							[k]: next
+						});
+					},
+					options: isTag && access.variants ? Object.keys(access.variants.byTag) : void 0
+				});
+			}
+			body.appendChild(row);
+			body.appendChild(nest);
+			return;
+		} else {
+			const json = JSON.stringify(jsonClone(value));
+			if (json.length <= DETAIL_INLINE_MAX) {
+				const readout = this.doc.createElement("div");
+				readout.textContent = json;
+				applyStyle(readout, {
+					opacity: "0.65",
+					whiteSpace: "pre-wrap",
+					wordBreak: "break-all"
+				});
+				row.appendChild(readout);
+			} else {
+				const path = access.path ?? key;
+				const open = this.detailOpen.get(node)?.has(path) ?? false;
+				const toggle = this.doc.createElement("div");
+				toggle.textContent = `${open ? "▾" : "▸"} ${summarizeValue(value)}`;
+				applyStyle(toggle, {
+					opacity: "0.75",
+					cursor: "pointer",
+					userSelect: "none"
+				});
+				toggle.addEventListener("click", () => {
+					let set = this.detailOpen.get(node);
+					if (!set) {
+						set = /* @__PURE__ */ new Set();
+						this.detailOpen.set(node, set);
+					}
+					if (open) set.delete(path);
+					else set.add(path);
+					this.renderInspector();
+				});
+				row.appendChild(toggle);
+				body.appendChild(row);
+				if (open) {
+					const detail = this.doc.createElement("div");
+					detail.textContent = detailText(value, json);
+					applyStyle(detail, {
+						opacity: "0.6",
+						whiteSpace: "pre-wrap",
+						wordBreak: "break-all",
+						marginLeft: "10px",
+						paddingLeft: "8px",
+						borderLeft: "1px solid rgba(255,255,255,0.14)"
+					});
+					body.appendChild(detail);
+				}
+				return;
+			}
 		}
 		body.appendChild(row);
 	}

package/dist/editor-switch-B0wB_DSr.d.ts

@@ -0,0 +1,59 @@
+import { s as JsonObject } from "./schema-CcoWb32N.js";
+
+//#region src/core/editor-switch.d.ts
+/** Where a camera is and what it looks at, in world space. */
+interface CameraPose {
+  position: [number, number, number];
+  target: [number, number, number];
+}
+/** What the editor module needs to know to take over the page. */
+interface EditorOpenOptions {
+  /** The authored scene to edit. */
+  scene: JsonObject;
+  /** Start the edit view here (continuity out of the running game). */
+  camera?: CameraPose;
+  /** Called when the editor hands the page back — boot the game from `working`. */
+  play(working: JsonObject, camera?: CameraPose): void | Promise<void>;
+  /** Called when the user leaves the editor without playing. */
+  exit?(): void | Promise<void>;
+  /** Persist edits (from `editor.save`). Omitted: no save button. */
+  save?(working: JsonObject): void | Promise<void>;
+  /** Asset-library search (from `editor.library`). Omitted: no 📚 buttons. */
+  library?: LibrarySearch;
+}
+/**
+* How a page opens its editor.
+*
+* Default: `import('incanto/editor')`, so `editor: true` is all a game needs.
+* Apps that alias the engine to source (the examples, the playground) map that
+* specifier themselves, or pass `open` and skip the resolution entirely.
+*/
+interface EditorSwitchOptions {
+  open?(opts: EditorOpenOptions): void | Promise<void>;
+  /** Persist edits. Omitted: the editor's save button is hidden. */
+  save?(working: JsonObject): void | Promise<void>;
+  /**
+  * Search the agent8 asset library from inside the game's editor.
+  *
+  * `true` means "my dev server serves `/api/library`" — add
+  * `incantoLibrary()` from `incanto/vite` and this is the whole opt-in. A
+  * function is your own transport. Omitted: the 📚 buttons are not rendered,
+  * because a page with no catalog should show no button rather than one that
+  * fails when pressed.
+  */
+  library?: true | LibrarySearch;
+}
+/** Search the asset catalog: the shape the editor's browser consumes. */
+type LibrarySearch = (query: {
+  tags: string[];
+  keyword?: string;
+  page?: number;
+  limit?: number;
+}) => Promise<{
+  items: unknown[];
+  page: number;
+  hasNext: boolean;
+  total?: number;
+}>;
+//#endregion
+export { EditorSwitchOptions as t };

package/dist/editor-switch-CAKlJMIY.js

@@ -0,0 +1,161 @@
+//#region src/core/editor-switch.ts
+/**
+* Cover the page while it changes what it is.
+*
+* A mode switch tears down a whole game and builds a whole IDE in its place;
+* between those two the window shows a dead canvas, a flash of white body, and
+* then a fully-formed editor. Every one of those frames is honest and none of
+* them is pleasant. A veil makes the crossing read as one movement: fade to the
+* editor's own background, do the work behind it, fade back.
+*
+* Deliberately CSS-only and dependency-free — it has to work in a game page
+* whose styles we know nothing about, so it sits at the top of the stacking
+* order, eats pointer events (nobody clicks a UI that is being replaced), and
+* removes itself completely. In a headless boot there is no document and this
+* is a pair of no-ops.
+*/
+const VEIL_MS = 160;
+function raiseVeil(label = "", background = "#0b0d14") {
+	if (typeof document === "undefined") return { lift: () => {} };
+	const el = document.createElement("div");
+	el.dataset.incantoSwitch = "";
+	el.style.cssText = `position:fixed;inset:0;z-index:2147483646;background:${background};display:flex;align-items:center;justify-content:center;opacity:0;transition:opacity ${VEIL_MS}ms ease;pointer-events:auto;`;
+	if (label) {
+		const text = document.createElement("div");
+		text.textContent = label;
+		text.style.cssText = "font:13px/1 ui-monospace,SFMono-Regular,Menlo,monospace;color:#5d6680;letter-spacing:0.04em;";
+		el.appendChild(text);
+	}
+	document.body.appendChild(el);
+	requestAnimationFrame(() => {
+		el.style.opacity = "1";
+	});
+	let lifted = false;
+	return { lift() {
+		if (lifted) return;
+		lifted = true;
+		requestAnimationFrame(() => {
+			el.style.opacity = "0";
+			setTimeout(() => el.remove(), 200);
+		});
+	} };
+}
+/** Hold the veil up for at least one paint so the fade is visible at all. */
+async function settle(ms = VEIL_MS) {
+	if (typeof requestAnimationFrame !== "function") return;
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* The `/api/library` route `incanto/vite`'s `incantoLibrary()` (and the
+* `incanto-editor` server) serve. Used when a game passes `library: true`.
+*/
+function devServerLibrary(token) {
+	return async (query) => {
+		const params = new URLSearchParams({
+			tags: query.tags.join(","),
+			page: String(query.page ?? 1),
+			limit: String(query.limit ?? 24)
+		});
+		if (query.keyword?.trim()) params.set("keyword", query.keyword.trim());
+		const res = await fetch(`/api/library?${params}`, { headers: token ? { "x-incanto-v8-token": token } : {} });
+		if (res.status === 401) {
+			const body = await res.json().catch(() => ({}));
+			const error = new Error(body.error ?? "the asset library needs a Verse8 access token");
+			error.needsToken = true;
+			throw error;
+		}
+		if (!res.ok) throw new Error(`asset library: HTTP ${res.status}`);
+		return await res.json();
+	};
+}
+/**
+* The default opener: pull `incanto/editor` in on demand and mount it.
+*
+* It is a dynamic import so the editor — an IDE's worth of UI — never enters a
+* production bundle. A build that cannot resolve it fails HERE, with the two
+* ways to fix it, rather than silently offering a menu item that does nothing.
+*/
+async function openBundledEditor(opts) {
+	let mod;
+	try {
+		mod = await import("incanto/editor");
+	} catch (error) {
+		throw new Error(`createGame3D editor: could not load 'incanto/editor'. If this app aliases incanto to the engine SOURCE (the examples and playground do), add an alias for 'incanto/editor' → packages/editor/src/main.ts — or pass editor: { open } and load it yourself. (${error instanceof Error ? error.message : String(error)})`);
+	}
+	let handle = null;
+	handle = await mod.mountEditor({
+		...opts.camera ? { camera: opts.camera } : {},
+		api: {
+			meta: async () => ({
+				version: "live",
+				mode: "single",
+				root: "",
+				input: null,
+				output: null
+			}),
+			loadScene: async () => opts.scene,
+			...opts.save ? { saveScene: async (json) => void opts.save?.(json) } : {},
+			...opts.library ? { library: opts.library } : {}
+		},
+		onPlay: (choice, working) => {
+			if (choice !== "debug") return void 0;
+			const camera = handle?.camera();
+			return crossFade(async () => {
+				handle?.dispose();
+				handle = null;
+				await opts.play(working, camera);
+			}, "starting the game…");
+		},
+		...opts.exit ? { onExit: () => crossFade(async () => {
+			handle?.dispose();
+			handle = null;
+			await opts.exit?.();
+		}, "back to the game…") } : {}
+	});
+}
+/**
+* Run a mode change behind the veil: cover, swap, reveal.
+*
+* The reveal waits for the new page to have PAINTED (two frames — one for the
+* layout the swap just produced, one for it to reach the screen), otherwise the
+* fade-out races the boot and shows the very flash it exists to hide.
+*/
+async function crossFade(swap, label = "") {
+	const veil = raiseVeil(label);
+	await settle();
+	try {
+		await swap();
+	} finally {
+		await settle(0);
+		veil.lift();
+	}
+}
+/**
+* The camera the player is actually looking through, as a pose.
+*
+* Reads the renderer's LAST rendered camera rather than the scene's Camera3D:
+* a third-person rig, a cutscene camera and a debug free-fly all end up in the
+* same place, and it is the view on screen — the thing continuity is about.
+*/
+function poseFromRenderer(renderer, fallbackDistance = 8) {
+	const basis = renderer.cameraBasis;
+	const posOf = renderer.lastCameraPosition;
+	if (typeof basis !== "function" || typeof posOf !== "function") return void 0;
+	const eye = posOf.call(renderer);
+	if (!eye) return void 0;
+	const { forward } = basis.call(renderer);
+	return {
+		position: [
+			eye.x,
+			eye.y,
+			eye.z
+		],
+		target: [
+			eye.x + forward.x * fallbackDistance,
+			eye.y + forward.y * fallbackDistance,
+			eye.z + forward.z * fallbackDistance
+		]
+	};
+}
+//#endregion
+export { poseFromRenderer as i, devServerLibrary as n, openBundledEditor as r, crossFade as t };

package/dist/editor.d.ts

@@ -0,0 +1,49 @@
+// Generated by packages/editor/scripts/emit-types.mjs — do not edit.
+type Json = Record<string, unknown>;
+
+export interface EditorMeta {
+  version: string;
+  mode: 'single' | 'project';
+  root: string;
+  input: string | null;
+  output: string | null;
+}
+
+export interface SceneEntry {
+  rel: string;
+  abs: string;
+}
+
+/** Where a mounted editor reads and writes scenes. */
+export interface EditorApi {
+  meta(): Promise<EditorMeta>;
+  loadScene(file?: string): Promise<Json>;
+  saveScene?(json: Json, file?: string): Promise<void>;
+  scenes?(): Promise<SceneEntry[]>;
+  createScene?(path: string): Promise<SceneEntry>;
+}
+
+export type PlayChoice = 'preview' | 'debug';
+
+export interface MountEditorOptions {
+  host?: HTMLElement;
+  api?: EditorApi;
+  camera?: { position: readonly number[]; target: readonly number[] };
+  onPlay?(choice: PlayChoice, working: Json): void | Promise<void>;
+  onExit?(): void | Promise<void>;
+}
+
+export interface EditorHandle {
+  dispose(): void;
+  working(): Json;
+  camera(): { position: [number, number, number]; target: [number, number, number] };
+}
+
+/**
+ * Mount the scene editor over the page. It OWNS the window while it is up —
+ * dispose() puts the page back exactly as it was.
+ */
+export declare function mountEditor(opts?: MountEditorOptions): Promise<EditorHandle>;
+
+/** The `incanto-editor` server's /api routes, as an EditorApi. */
+export declare const httpEditorApi: EditorApi;