@downdraft/engine 0.0.0 → 0.1.0

package/modules/editor/src/commands/transform.ts

@@ -0,0 +1,91 @@
+// ============================================================================
+// Transform commands — `transform.set` is the workhorse for gizmo drags and
+// inspector vec3 edits. Writes into the entity's `transform` component
+// (position/rotation/scale), creating it with identity defaults when absent.
+// The component name is configurable via `ctx.transformComponent`.
+// ============================================================================
+
+import { sanitizeObject } from "@downdraft/engine";
+
+import type { EditorContext } from "../editor-context";
+import type { EditorCommand } from "./registry";
+
+const IDENTITY = { position: [0, 0, 0], rotation: [0, 0, 0, 1], scale: [1, 1, 1] };
+
+function readTransform(ctx: EditorContext, entityKey: string): Record<string, unknown> {
+  const entity = ctx.parseEntity(entityKey);
+  if (!entity) return { ...IDENTITY };
+  const cid = ctx.engine.getComponentIdByName(ctx.transformComponent);
+  const data = ctx.engine.ecsWorld.getComponent<Record<string, unknown>>(entity, cid);
+  return data ? (sanitizeObject({ ...data }) as Record<string, unknown>) : { ...IDENTITY };
+}
+
+export function createTransformCommands(): EditorCommand[] {
+  return [
+    {
+      id: "transform.set",
+      title: "Set Transform",
+      mutating: true,
+      params: {
+        type: "object",
+        properties: {
+          entity: { type: "string" },
+          position: { type: "array", items: { type: "number" }, description: "[x,y,z]" },
+          rotation: { type: "array", items: { type: "number" }, description: "quaternion [x,y,z,w]" },
+          scale: { type: "array", items: { type: "number" }, description: "[x,y,z]" },
+        },
+        required: ["entity"],
+      },
+      apply(ctx, params) {
+        const key = params.entity as string;
+        const entity = ctx.parseEntity(key);
+        if (!entity || !ctx.isAliveKey(key)) throw new Error(`Entity ${key} not found or dead`);
+
+        const old = readTransform(ctx, key);
+        const next = { ...old } as Record<string, unknown>;
+        const applied: string[] = [];
+        (["position", "rotation", "scale"] as const).forEach((field) => {
+          const v = params[field] as number[] | undefined;
+          if (v) { next[field] = [...v]; applied.push(field); }
+        });
+        if (applied.length === 0) throw new Error("transform.set: nothing to set");
+
+        const cid = ctx.engine.getComponentIdByName(ctx.transformComponent);
+        const sanitized = sanitizeObject(next);
+        if (ctx.engine.ecsWorld.hasComponent(entity, cid)) {
+          ctx.engine.ecsWorld.setComponent(entity, cid, sanitized);
+        } else {
+          ctx.engine.ecsWorld.addComponent(entity, cid, sanitized);
+        }
+        ctx.engine.ecsWorld.flushCommands();
+        ctx.document.markDirty({ kind: "data", entity: key });
+        ctx.adapter?.syncEntity?.(key);
+
+        // Inverse restores only the fields we changed.
+        const inverseChanges: Record<string, unknown> = {};
+        applied.forEach((f) => { inverseChanges[f] = old[f]; });
+        return {
+          value: { entity: key, applied },
+          inverse: [{ command: "component.set", params: { entity: key, component: ctx.transformComponent, changes: inverseChanges } }],
+          description: `Transform ${key} (${applied.join(", ")})`,
+        };
+      },
+    },
+
+    {
+      id: "transform.get",
+      title: "Get Transform",
+      mutating: false,
+      params: {
+        type: "object",
+        properties: { entity: { type: "string" } },
+        required: ["entity"],
+      },
+      apply(ctx, params) {
+        const key = params.entity as string;
+        if (!ctx.isAliveKey(key)) throw new Error(`Entity ${key} not found or dead`);
+        return { value: { entity: key, transform: readTransform(ctx, key) } };
+      },
+    },
+  ];
+}

package/modules/editor/src/ddscene.ts

@@ -0,0 +1,267 @@
+// ============================================================================
+// .ddscene — the editor's scene document format + SceneLoader.
+//
+// JSON, versioned, component-name-keyed (stable across code changes —
+// numeric component ids are NOT persisted). Entity file ids are stable
+// strings ("e_3") so parent references survive respawn.
+//
+//   serializeDocument(doc)              → DdSceneFile
+//   deserializeIntoDocument(doc, file)  → { warnings, idMap }
+//   instantiateScene(file, deps)        → spawn-only engine API for games
+//   diffScenes(a, b)                    → structural diff for agents/CI
+//
+// Format is intentionally close to `SerializedScene` (core/scene/scene.ts)
+// but persists component *names* and adds names/hierarchy/environment —
+// `SerializedScene` is a runtime checkpoint, `.ddscene` is an authored doc.
+// ============================================================================
+
+import {
+    getColumnValue,
+    getComponentId,
+    getComponentName,
+    isRegisteredComponentName,
+    sanitizeObject,
+    type Entity,
+    type Hierarchy,
+    type Scene,
+    type World,
+} from "@downdraft/engine";
+
+import type { EditorDocument } from "./document";
+
+export const DDSCENE_FORMAT = "ddscene";
+export const DDSCENE_VERSION = 1;
+
+export interface DdSceneEntity {
+  /** Stable file id — unique within the document. */
+  id: string;
+  /** Editor display name. */
+  name?: string;
+  /** File id of the parent entity. */
+  parent?: string;
+  /** Prefab reference (path or registry name). */
+  prefab?: string;
+  /** Per-prefab component overrides (recorded over the prefab base). */
+  overrides?: Record<string, Record<string, unknown>>;
+  /** Component name → data. Absent when the entity is a pure prefab ref. */
+  components?: Record<string, Record<string, unknown>>;
+}
+
+export interface DdSceneFile {
+  format: typeof DDSCENE_FORMAT;
+  version: number;
+  name: string;
+  entities: DdSceneEntity[];
+  environment?: Record<string, unknown>;
+  camera?: {
+    position: [number, number, number];
+    target: [number, number, number];
+    fov?: number;
+  };
+  meta: Record<string, unknown>;
+}
+
+export interface DeserializeResult {
+  warnings: string[];
+  /** file id → live entity key ("index.generation"). */
+  idMap: Map<string, string>;
+}
+
+// ── Serialize ──
+
+export function serializeDocument(doc: EditorDocument, scene: Scene, hierarchy: Hierarchy): DdSceneFile {
+  const entities: DdSceneEntity[] = [];
+  const fileIds = new Map<string, string>(); // entity key → file id
+
+  for (const entity of doc.entities()) {
+    fileIds.set(doc.key(entity), `e_${entity.index}`);
+  }
+
+  for (const entity of doc.entities()) {
+    const key = doc.key(entity);
+    const arch = doc.world.getArchetypeForEntity(entity);
+    const components: Record<string, Record<string, unknown>> = {};
+    if (arch) {
+      const row = arch.entities.findIndex((e) => e.index === entity.index && e.generation === entity.generation);
+      if (row >= 0) {
+        for (const [cid, col] of arch.columns.entries()) {
+          const data = getColumnValue(col, row);
+          if (data !== undefined && data !== null) {
+            components[getComponentName(cid)] = sanitizeObject(data) as Record<string, unknown>;
+          }
+        }
+      }
+    }
+
+    const parent = hierarchy.getParent(entity);
+    const entry: DdSceneEntity = {
+      id: fileIds.get(key)!,
+      components,
+    };
+    const displayName = doc.entityName(key);
+    if (displayName) entry.name = displayName;
+    if (parent) {
+      const parentFileId = fileIds.get(doc.key(parent));
+      if (parentFileId) entry.parent = parentFileId;
+    }
+    entities.push(entry);
+  }
+
+  return {
+    format: DDSCENE_FORMAT,
+    version: DDSCENE_VERSION,
+    name: doc.name,
+    entities,
+    meta: {
+      engineVersion: "0.1.0",
+      savedAt: new Date().toISOString(),
+    },
+  };
+}
+
+// ── Deserialize ──
+
+export function deserializeIntoDocument(
+  doc: EditorDocument,
+  scene: Scene,
+  world: World,
+  hierarchy: Hierarchy,
+  file: DdSceneFile,
+): DeserializeResult {
+  const warnings: string[] = [];
+  const idMap = new Map<string, string>();
+
+  if (file.format !== DDSCENE_FORMAT) {
+    throw new Error(`Not a .ddscene document (format="${file.format}")`);
+  }
+  if (file.version > DDSCENE_VERSION) {
+    throw new Error(
+      `.ddscene version ${file.version} is newer than this engine supports (${DDSCENE_VERSION})`,
+    );
+  }
+
+  // Clear the current document contents.
+  for (const entity of doc.entities()) {
+    world.despawn(entity);
+    scene.removeEntity(entity);
+  }
+  world.flushCommands();
+  doc.resetMeta(file.name);
+
+  // Pass 1: spawn entities + components.
+  const spawned = new Map<string, Entity>(); // fileId → Entity
+  file.entities.forEach((entry) => {
+    const components = new Map<number, unknown>();
+    for (const [compName, data] of Object.entries(entry.components ?? {})) {
+      if (!isRegisteredComponentName(compName)) {
+        warnings.push(`entity "${entry.id}": unknown component "${compName}" — skipped`);
+        continue;
+      }
+      components.set(getComponentId(compName), sanitizeObject({ ...data }));
+    }
+    const entity = world.spawn(components);
+    scene.trackEntity(entity);
+    spawned.set(entry.id, entity);
+    const key = `${entity.index}.${entity.generation}`;
+    idMap.set(entry.id, key);
+    if (entry.name) doc.setEntityName(key, entry.name);
+  });
+  world.flushCommands();
+
+  // Pass 2: restore hierarchy (prefab refs resolve in Phase 3 — entries with
+  // `prefab` still spawn their own entity shell for now).
+  file.entities.forEach((entry) => {
+    if (!entry.parent) return;
+    const child = spawned.get(entry.id);
+    const parent = spawned.get(entry.parent);
+    if (child && parent) {
+      hierarchy.setParent(child, parent);
+    } else {
+      warnings.push(`entity "${entry.id}": parent "${entry.parent}" not found — orphaned`);
+    }
+  });
+
+  doc.markClean();
+  return { warnings, idMap };
+}
+
+/**
+ * `SceneLoader` — the runtime consumption half. Games call this to spawn a
+ * `.ddscene` into their own World/Hierarchy. Returns the fileId→Entity map
+ * so games can resolve authored references.
+ */
+export function instantiateScene(
+  file: DdSceneFile,
+  deps: { world: World; scene?: Scene; hierarchy?: Hierarchy },
+): DeserializeResult & { entities: Map<string, Entity> } {
+  const warnings: string[] = [];
+  const idMap = new Map<string, string>();
+  const spawned = new Map<string, Entity>();
+
+  if (file.format !== DDSCENE_FORMAT) {
+    throw new Error(`Not a .ddscene document (format="${file.format}")`);
+  }
+
+  file.entities.forEach((entry) => {
+    const components = new Map<number, unknown>();
+    for (const [compName, data] of Object.entries(entry.components ?? {})) {
+      if (!isRegisteredComponentName(compName)) {
+        warnings.push(`entity "${entry.id}": unknown component "${compName}" — skipped`);
+        continue;
+      }
+      components.set(getComponentId(compName), sanitizeObject({ ...data }));
+    }
+    const entity = deps.world.spawn(components);
+    deps.scene?.trackEntity(entity);
+    spawned.set(entry.id, entity);
+    idMap.set(entry.id, `${entity.index}.${entity.generation}`);
+  });
+  deps.world.flushCommands();
+
+  file.entities.forEach((entry) => {
+    if (!entry.parent || !deps.hierarchy) return;
+    const child = spawned.get(entry.id);
+    const parent = spawned.get(entry.parent);
+    if (child && parent) deps.hierarchy.setParent(child, parent);
+  });
+
+  return { warnings, idMap, entities: spawned };
+}
+
+// ── Diff ──
+
+export interface SceneDiff {
+  added: string[];
+  removed: string[];
+  changed: string[];
+}
+
+/** Structural diff between two serialized scenes (entity id + JSON-equal
+ *  component data). Used by `editor_diff` and by tests verifying round-trips. */
+export function diffScenes(a: DdSceneFile, b: DdSceneFile): SceneDiff {
+  const aMap = new Map(a.entities.map((e) => [e.id, e]));
+  const bMap = new Map(b.entities.map((e) => [e.id, e]));
+  const diff: SceneDiff = { added: [], removed: [], changed: [] };
+
+  bMap.forEach((ent, id) => {
+    const prev = aMap.get(id);
+    if (!prev) { diff.added.push(id); return; }
+    if (JSON.stringify(prev.components) !== JSON.stringify(ent.components)
+      || prev.parent !== ent.parent
+      || prev.name !== ent.name) {
+      diff.changed.push(id);
+    }
+  });
+  aMap.forEach((_, id) => {
+    if (!bMap.has(id)) diff.removed.push(id);
+  });
+  return diff;
+}
+
+export function parseDdScene(text: string): DdSceneFile {
+  const data = JSON.parse(text) as DdSceneFile;
+  if (data.format !== DDSCENE_FORMAT) {
+    throw new Error(`Not a .ddscene document (format="${(data as { format?: string }).format}")`);
+  }
+  return data;
+}

package/modules/editor/src/document.ts

@@ -0,0 +1,123 @@
+// ============================================================================
+// EditorDocument — the design-world document the editor edits.
+//
+// Wraps the EngineContext's Scene/World/Hierarchy plus editor-owned metadata
+// (display names, file path, dirty state). Commands mutate the world through
+// this document; the `.ddscene` serializer (ddscene.ts) round-trips it to
+// disk.
+//
+// Display names are document metadata, not a component — games are free to
+// have their own "name" component; the editor's name is authoring chrome.
+// ============================================================================
+
+import { isAlive, type Entity, type Scene, type World } from "@downdraft/engine";
+
+export type DocumentChangeKind =
+  | "structure"      // entity spawned/removed/reparented
+  | "data"           // component data changed
+  | "meta"           // names/flags changed
+  | "file";          // opened/saved (path + dirty reset)
+
+export interface DocumentChange {
+  kind: DocumentChangeKind;
+  entity?: string;
+}
+
+export class EditorDocument {
+  name: string;
+  filePath: string | null = null;
+
+  private scene: Scene;
+  private names = new Map<string, string>();
+  private dirty = false;
+  private version = 0;
+  private listeners = new Set<(change: DocumentChange) => void>();
+
+  constructor(scene: Scene, name?: string) {
+    this.scene = scene;
+    this.name = name ?? scene.name;
+  }
+
+  get world(): World {
+    return this.scene.world;
+  }
+
+  get entityCount(): number {
+    return this.scene.getEntityCount();
+  }
+
+  key(entity: Entity): string {
+    return `${entity.index}.${entity.generation}`;
+  }
+
+  parse(key: string): Entity | null {
+    const parts = key.split(".");
+    if (parts.length !== 2) return null;
+    const index = parseInt(parts[0]!, 10);
+    const generation = parseInt(parts[1]!, 10);
+    if (Number.isNaN(index) || Number.isNaN(generation)) return null;
+    return { index, generation };
+  }
+
+  isAliveKey(key: string): boolean {
+    const e = this.parse(key);
+    return e !== null && isAlive(this.world.entities, e);
+  }
+
+  /** All live entities tracked by the document's scene. */
+  entities(): Entity[] {
+    return this.scene.getEntities();
+  }
+
+  entityKeys(): string[] {
+    return this.entities().map((e) => this.key(e));
+  }
+
+  entityName(key: string): string | undefined {
+    return this.names.get(key);
+  }
+
+  setEntityName(key: string, name: string | undefined): void {
+    if (name === undefined || name === "") this.names.delete(key);
+    else this.names.set(key, name);
+  }
+
+  /** Display label: authored name if present, else `Entity <key>`. */
+  label(key: string): string {
+    return this.names.get(key) ?? `Entity ${key}`;
+  }
+
+  /** Reset all editor metadata (called when a new doc is loaded in place). */
+  resetMeta(name: string): void {
+    this.names.clear();
+    this.name = name;
+    this.filePath = null;
+    this.dirty = false;
+    this.version++;
+  }
+
+  isDirty(): boolean {
+    return this.dirty;
+  }
+
+  getVersion(): number {
+    return this.version;
+  }
+
+  markDirty(change: DocumentChange): void {
+    this.dirty = true;
+    this.version++;
+    this.listeners.forEach((fn) => fn(change));
+  }
+
+  markClean(): void {
+    this.dirty = false;
+    this.version++;
+    this.listeners.forEach((fn) => fn({ kind: "file" }));
+  }
+
+  onChange(fn: (change: DocumentChange) => void): () => void {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+}

package/modules/editor/src/editor-context.ts

@@ -0,0 +1,172 @@
+// ============================================================================
+// EditorContext — the editor's backend object.
+//
+// Composes an `EngineContext` (the standalone editing world from
+// `@downdraft/engine/mcp`: World + Scene + GameWorld + Hierarchy +
+// AssetManager + MaterialLibrary + CheckpointManager + SaveSystem +
+// UndoRedoManager) with editor session state: the `EditorDocument`,
+// `SelectionModel`, `EditorCommandRegistry`, and filesystem access.
+//
+// Design-document mode (Phase 0–5): the EngineContext is standalone — the
+// editor owns a private World/Scene on the main thread and the game's
+// renderer maps entities to visuals via an `EditorSceneAdapter`.
+// Live-sim mode (Phase 6) swaps in `EngineContext.fromGame()` backed by the
+// game's world — the command layer above doesn't change.
+// ============================================================================
+
+import type { Entity } from "@downdraft/engine";
+import { EngineContext } from "@downdraft/engine/mcp";
+
+import { EditorCommandRegistry } from "./commands/registry";
+import { EditorDocument } from "./document";
+import { SelectionModel } from "./selection";
+
+// ── Filesystem abstraction ──
+// The editor runs in the JS runtime process (Bun/Node/Deno), so `node:fs`
+// covers all hosts — but it is lazy-imported so the module stays loadable in
+// non-node test contexts. `createNodeFs()` resolves at call time.
+
+export interface EditorFs {
+  readText(path: string): Promise<string>;
+  writeText(path: string, text: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+}
+
+export function createNodeFs(): EditorFs {
+  return {
+    async readText(path: string): Promise<string> {
+      const fs = await import("node:fs/promises");
+      return fs.readFile(path, "utf8");
+    },
+    async writeText(path: string, text: string): Promise<void> {
+      const fs = await import("node:fs/promises");
+      await fs.writeFile(path, text, "utf8");
+    },
+    async exists(path: string): Promise<boolean> {
+      const fs = await import("node:fs/promises");
+      try {
+        await fs.access(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+}
+
+// ── Scene adapter (game-provided visual bridge) ──
+// The design world is pure ECS data; the adapter maps entities to whatever
+// the game uses to draw them (ModelRenderer, custom passes). Phase 0 is
+// headless — no adapter is required. Phase 1 ships the generic adapter.
+
+export interface EditorRay {
+  origin: [number, number, number];
+  dir: [number, number, number];
+}
+
+export interface EditorSceneAdapter {
+  /** Push an entity's visual state to the renderer (spawn/update). */
+  syncEntity?(entityKey: string): void;
+  /** Remove an entity's visual. */
+  removeEntity?(entityKey: string): void;
+  /**
+   * Pick: screen-space pointer position → entity key, or null. The adapter
+   * owns the camera, so it computes the world ray itself.
+   */
+  pickAt?(x: number, y: number, w: number, h: number): string | null;
+  /** World-space bounds for framing/marquee/outline. */
+  bounds?(entityKey: string): { min: [number, number, number]; max: [number, number, number] } | null;
+}
+
+export interface EditorContextOptions {
+  /** Provide a pre-built EngineContext (e.g. `EngineContext.fromGame()` for
+   *  live-world editing). When omitted a standalone design world is created. */
+  engine?: EngineContext;
+  sceneName?: string;
+  fs?: EditorFs | null;
+  adapter?: EditorSceneAdapter;
+}
+
+export class EditorContext {
+  readonly engine: EngineContext;
+  readonly document: EditorDocument;
+  readonly selection: SelectionModel;
+  readonly commands: EditorCommandRegistry;
+  readonly fs: EditorFs | null;
+  adapter: EditorSceneAdapter | null;
+  /**
+   * Entity key produced by the most recent `entity.restore` — lets
+   * `hierarchy.setParentToRestore` in the same undo batch re-parent
+   * children to the restored (new) key. Internal; not for public use.
+   */
+  lastRestoredKey: string | null = null;
+  /**
+   * Entity keys are physical ("index.generation") — despawn frees the slot
+   * and respawn yields a different key. `entity.restore` registers an
+   * alias oldKey→newKey here so journaled inverses and params carrying a
+   * stale key keep resolving (redo after an undo-remove relies on this).
+   */
+  private keyAliases = new Map<string, string>();
+  /** Component name the transform commands read/write. Games with a
+   *  differently-named transform component can override via module config. */
+  transformComponent = "transform";
+
+  constructor(opts: EditorContextOptions = {}) {
+    this.engine = opts.engine ?? new EngineContext({ sceneName: opts.sceneName ?? "editor-scene" });
+    this.document = new EditorDocument(this.engine.scene, opts.sceneName ?? this.engine.scene.name);
+    this.selection = new SelectionModel();
+    this.commands = new EditorCommandRegistry(this);
+    this.fs = opts.fs === undefined ? createNodeFs() : opts.fs;
+    this.adapter = opts.adapter ?? null;
+
+    // Document dirty tracking: any applied mutating command dirties the doc
+    // unless it opts out via `marksDirty: false` — file-state commands
+    // (scene.save/open/new) call markClean themselves, and auto-dirtying
+    // after dispatch would stomp the clean flag.
+    this.commands.onDispatched((entry) => {
+      const cmd = this.commands.get(entry.command);
+      if (cmd?.mutating && cmd.marksDirty !== false) {
+        this.document.markDirty({ kind: "data", entity: entry.params["entity"] as string | undefined });
+      }
+    });
+  }
+
+  // ── Entity helpers (delegate to engine + document) ──
+
+  key(entity: Entity): string {
+    return this.document.key(entity);
+  }
+
+  /** Follow the restore-alias chain for a possibly stale entity key. */
+  resolveKey(key: string): string {
+    let k = key;
+    const seen = new Set<string>();
+    while (this.keyAliases.has(k) && !seen.has(k)) {
+      seen.add(k);
+      k = this.keyAliases.get(k)!;
+    }
+    return k;
+  }
+
+  /** Record that oldKey now refers to newKey (entity restored under a new id). */
+  registerKeyAlias(oldKey: string, newKey: string): void {
+    if (oldKey !== newKey) this.keyAliases.set(oldKey, newKey);
+  }
+
+  clearKeyAliases(): void {
+    this.keyAliases.clear();
+  }
+
+  parseEntity(key: string): Entity | null {
+    return this.document.parse(this.resolveKey(key));
+  }
+
+  isAliveKey(key: string): boolean {
+    return this.document.isAliveKey(this.resolveKey(key));
+  }
+
+  dispose(): void {
+    // No timers/subscriptions held yet — placeholder for adapter teardown,
+    // autosave timers, and the UI shell.
+  }
+}

package/modules/editor/src/index.ts

@@ -0,0 +1,41 @@
+// @downdraft/engine/modules/editor — public API
+export { createEditorModule, EditorModuleTok } from "./module";
+export type { EditorModuleConfig } from "./module";
+
+export { createNodeFs, EditorContext } from "./editor-context";
+export type { EditorContextOptions, EditorFs, EditorRay, EditorSceneAdapter } from "./editor-context";
+
+export { EditorDocument } from "./document";
+export type { DocumentChange, DocumentChangeKind } from "./document";
+
+export { SelectionModel } from "./selection";
+
+export { EditorCommandError, EditorCommandRegistry } from "./commands/registry";
+export type {
+    CommandInvocation,
+    CommandOutcome,
+    EditorCommand,
+    EditorCommandSource,
+    EditorParamSchema,
+    JournalEntry
+} from "./commands/registry";
+
+export { registerDefaultCommands } from "./commands/index";
+
+export { DEFAULT_LAYOUT, EditorShell } from "./shell";
+export type { EditorShellLayout, GizmoModeName } from "./shell";
+
+export { EditorViewport } from "./viewport";
+
+export {
+    DDSCENE_FORMAT,
+    DDSCENE_VERSION,
+    deserializeIntoDocument,
+    diffScenes,
+    instantiateScene,
+    parseDdScene,
+    serializeDocument
+} from "./ddscene";
+export type { DdSceneEntity, DdSceneFile, DeserializeResult, SceneDiff } from "./ddscene";
+
+export { createEditorMcpTools, editorMcpTools, getEditorContext } from "./mcp";