incanto 0.28.0 → 0.30.0

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { C as RendererStats, E as LogLevel, v as Engine } from "./behavior-CPibUfnH.js";
+import { C as RendererStats, E as LogLevel, v as Engine } from "./behavior-BAc0erXF.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */
@@ -8,10 +8,30 @@ interface DocumentLike {
 //#endregion
 //#region src/debug/index.d.ts
 type DebugPanelId = "explorer" | "inspector" | "logs" | "stats";
+/** Menu entries that are switches rather than panels. */
+type DebugSwitchId = "colliders";
+/** `all` is every collider in the world; `selected` follows the Explorer. */
+type ColliderMode = "off" | "all" | "selected";
+type DebugMenuId = DebugPanelId | DebugSwitchId;
+/** An extra ☰ menu entry the host app supplies (e.g. "edit this scene"). */
+interface DebugAction {
+  /** Menu label. Keep it a verb — the menu is a list of things you can do. */
+  label: string;
+  /** Runs on click. The menu closes first, so a slow action can await freely. */
+  run(): void | Promise<void>;
+}
 interface DebugOverlayOptions {
   /** Overlay host (default: document.body). Give it position: relative. */
   container?: HTMLElement;
   /**
+  * Extra menu entries, listed under the panels with a separator.
+  *
+  * This is how a page hangs its own tooling off the overlay without the
+  * overlay having to know what tooling exists — `createGame3D`'s live editor
+  * switch arrives through here.
+  */
+  actions?: DebugAction[];
+  /**
   * 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.
@@ -27,6 +47,7 @@ declare class DebugOverlay {
   private readonly container;
   private readonly doc;
   private readonly statsSource?;
+  private readonly actions;
   private readonly panels;
   private readonly cleanups;
   private readonly menuButton;
@@ -41,11 +62,27 @@ declare class DebugOverlay {
   private consolePatched;
   private frame;
   private editing;
-  constructor(engine: Engine, container: HTMLElement, doc: DocumentLike, statsSource?: (() => Partial<RendererStats>) | undefined);
-  isOpen(id: DebugPanelId): boolean;
+  /** Which bulky values are unfolded, per node ('transforms', 'collider.vertices'). */
+  private readonly detailOpen;
+  /** Pointer inside the inspector — it stops refreshing under your hand. */
+  private hovering;
+  constructor(engine: Engine, container: HTMLElement, doc: DocumentLike, statsSource?: (() => Partial<RendererStats>) | undefined, actions?: DebugAction[]);
+  isOpen(id: DebugMenuId): boolean;
+  /** How much of the physics world the wireframes show. */
+  colliderMode: ColliderMode;
+  /**
+  * 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: ColliderMode): void;
+  private applyColliderScope;
   open(id: DebugPanelId): void;
   close(id: DebugPanelId): void;
-  toggle(id: DebugPanelId): void;
+  toggle(id: DebugMenuId): void;
   setLevelEnabled(level: LogLevel, on: boolean): void;
   /**
   * Patch console.* into the Logs panel (restored on disable/dispose).
@@ -54,15 +91,23 @@ declare class DebugOverlay {
   */
   setConsoleCapture(on: boolean): void;
   dispose(): void;
+  /** `✓ Colliders · selected` — check for on, suffix for the collider mode. */
+  private menuLabel;
   private toggleDropdown;
   private openStatsChip;
   private renderStats;
   private renderExplorer;
   private renderInspector;
-  private renderPropRow;
+  /**
+  * 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.
+  */
+  private renderValueRow;
   private trackEditing;
   private pushLog;
   private renderLogs;
 }
 //#endregion
-export { DebugOverlay, DebugOverlayOptions, DebugPanelId, attachDebugOverlay };
+export { ColliderMode, DebugAction, DebugMenuId, DebugOverlay, DebugOverlayOptions, DebugPanelId, DebugSwitchId, attachDebugOverlay };

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-BM3DsvtT.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.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;