@donut-games/cli 0.1.0

package/dist/donut-mcp.js

@@ -0,0 +1,2654 @@
+#!/usr/bin/env node
+
+// ../mcp/dist/index.js
+import path10 from "path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// ../mcp/dist/tools/component-system/components.js
+import path2 from "path";
+import fileSystemExtra from "fs-extra";
+import typescript from "typescript";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// ../mcp/dist/tools/component-system/naming.js
+function toPascalCase(rawName) {
+  const trimmed = rawName.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Name must not be empty");
+  }
+  const parts = trimmed.replace(/[_\-\s]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(" ").filter((part) => part.length > 0);
+  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toKebabCase(rawName) {
+  const pascal = toPascalCase(rawName);
+  return pascal.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function stripSuffix(pascalName, suffix) {
+  return pascalName.endsWith(suffix) ? pascalName.slice(0, pascalName.length - suffix.length) : pascalName;
+}
+
+// ../mcp/dist/tools/component-system/path-guard.js
+import path from "path";
+function resolveWithinProject(projectDirectory, relativePath) {
+  const absoluteProjectDirectory = path.resolve(projectDirectory);
+  const absoluteResolved = path.resolve(absoluteProjectDirectory, relativePath);
+  const projectDirectoryWithSeparator = absoluteProjectDirectory.endsWith(path.sep) ? absoluteProjectDirectory : absoluteProjectDirectory + path.sep;
+  if (absoluteResolved !== absoluteProjectDirectory && !absoluteResolved.startsWith(projectDirectoryWithSeparator)) {
+    throw new Error(`Path "${relativePath}" escapes project directory "${absoluteProjectDirectory}"`);
+  }
+  return absoluteResolved;
+}
+
+// ../mcp/dist/tools/component-system/components.js
+var stateFieldTypeSchema = z.enum(["number", "string", "boolean", "Vector2", "Vector3"]);
+var stateFieldSchema = z.object({
+  name: z.string().min(1),
+  type: stateFieldTypeSchema,
+  defaultValue: z.union([z.string(), z.number(), z.boolean()]).optional()
+});
+var lifecycleHookSchema = z.enum(["onAdd", "onRemove"]);
+var createComponentInputSchema = z.object({
+  name: z.string().min(1),
+  stateFields: z.array(stateFieldSchema).default([]),
+  lifecycleHooks: z.array(lifecycleHookSchema).optional()
+});
+var readComponentInputSchema = z.object({ name: z.string().min(1) });
+var updateComponentInputSchema = z.object({
+  name: z.string().min(1),
+  changes: z.object({
+    addFields: z.array(stateFieldSchema).optional(),
+    removeFields: z.array(z.string()).optional(),
+    renameFields: z.array(z.object({ from: z.string(), to: z.string() })).optional(),
+    addHook: lifecycleHookSchema.optional(),
+    removeHook: lifecycleHookSchema.optional()
+  }).default({})
+});
+var deleteComponentInputSchema = z.object({ name: z.string().min(1) });
+var listComponentsInputSchema = z.object({}).default({});
+function renderDefaultLiteral(field) {
+  if (field.defaultValue !== void 0) {
+    if (field.type === "string") {
+      return JSON.stringify(String(field.defaultValue));
+    }
+    return String(field.defaultValue);
+  }
+  switch (field.type) {
+    case "number":
+      return "0";
+    case "string":
+      return "''";
+    case "boolean":
+      return "false";
+    case "Vector2":
+      return "new Vector2(0, 0)";
+    case "Vector3":
+      return "new Vector3(0, 0, 0)";
+  }
+}
+function renderComponentSource(className, stateFields, lifecycleHooks) {
+  const needsVector2 = stateFields.some((field) => field.type === "Vector2");
+  const needsVector3 = stateFields.some((field) => field.type === "Vector3");
+  const mathImports = [];
+  if (needsVector2) {
+    mathImports.push("Vector2");
+  }
+  if (needsVector3) {
+    mathImports.push("Vector3");
+  }
+  const lines = [];
+  lines.push(`import { Component, type Entity } from '@donut/core';`);
+  if (mathImports.length > 0) {
+    lines.push(`import { ${mathImports.join(", ")} } from '@donut/math';`);
+  }
+  lines.push("");
+  lines.push("/**");
+  lines.push(` * ${className} \u2014 generated by the Donut MCP \`create_component\` tool.`);
+  lines.push(" *");
+  lines.push(" * Holds authored state for entities that participate in the related system.");
+  lines.push(" */");
+  lines.push(`export class ${className} extends Component {`);
+  for (const field of stateFields) {
+    lines.push(`  /** Authored state field. */`);
+    lines.push(`  ${field.name}: ${field.type} = ${renderDefaultLiteral(field)};`);
+  }
+  if (lifecycleHooks.includes("onAdd")) {
+    lines.push("");
+    lines.push("  /** Lifecycle hook fired when this component is attached to an entity. */");
+    lines.push("  onAdd(owner: Entity): void {");
+    lines.push("    void owner;");
+    lines.push("  }");
+  }
+  if (lifecycleHooks.includes("onRemove")) {
+    lines.push("");
+    lines.push("  /** Lifecycle hook fired when this component is detached from an entity. */");
+    lines.push("  onRemove(previousOwner: Entity): void {");
+    lines.push("    void previousOwner;");
+    lines.push("  }");
+  }
+  lines.push("");
+  lines.push("  /** Deep-copy this component for entity duplication. */");
+  lines.push(`  clone(): ${className} {`);
+  lines.push(`    const copy = new ${className}();`);
+  for (const field of stateFields) {
+    if (field.type === "Vector2" || field.type === "Vector3") {
+      lines.push(`    copy.${field.name} = this.${field.name}.clone();`);
+    } else {
+      lines.push(`    copy.${field.name} = this.${field.name};`);
+    }
+  }
+  lines.push("    return copy;");
+  lines.push("  }");
+  lines.push("");
+  lines.push("  /** Convert this component to a plain-object snapshot. */");
+  lines.push("  serialize(): Record<string, unknown> {");
+  lines.push("    return {");
+  for (const field of stateFields) {
+    if (field.type === "Vector2" || field.type === "Vector3") {
+      lines.push(`      ${field.name}: this.${field.name}.serialize(),`);
+    } else {
+      lines.push(`      ${field.name}: this.${field.name},`);
+    }
+  }
+  lines.push("    };");
+  lines.push("  }");
+  lines.push("");
+  lines.push("  /** Restore this component's state from a plain-object snapshot. */");
+  lines.push("  deserialize(data: Record<string, unknown>): void {");
+  for (const field of stateFields) {
+    lines.push(`    if (data['${field.name}'] !== undefined) {`);
+    if (field.type === "Vector2") {
+      lines.push(`      this.${field.name} = Vector2.deserialize(data['${field.name}'] as Record<string, unknown>);`);
+    } else if (field.type === "Vector3") {
+      lines.push(`      this.${field.name} = Vector3.deserialize(data['${field.name}'] as Record<string, unknown>);`);
+    } else {
+      lines.push(`      this.${field.name} = data['${field.name}'] as ${field.type};`);
+    }
+    lines.push("    }");
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function parseComponentSource(sourceText, filePath) {
+  const sourceFile = typescript.createSourceFile(filePath, sourceText, typescript.ScriptTarget.ES2022, true);
+  let className;
+  const stateFields = [];
+  const dependencies = [];
+  typescript.forEachChild(sourceFile, (node) => {
+    if (!typescript.isClassDeclaration(node) || node.name === void 0) {
+      return;
+    }
+    className = node.name.text;
+    for (const member of node.members) {
+      if (typescript.isPropertyDeclaration(member) && typescript.isIdentifier(member.name)) {
+        const propertyName = member.name.text;
+        if (propertyName === "dependencies" && member.initializer !== void 0) {
+          if (typescript.isArrayLiteralExpression(member.initializer)) {
+            for (const element of member.initializer.elements) {
+              if (typescript.isIdentifier(element)) {
+                dependencies.push(element.text);
+              }
+            }
+          }
+          continue;
+        }
+        if (propertyName === "owner") {
+          continue;
+        }
+        const typeText = member.type !== void 0 ? member.type.getText(sourceFile) : "unknown";
+        const defaultText = member.initializer !== void 0 ? member.initializer.getText(sourceFile) : void 0;
+        stateFields.push({
+          name: propertyName,
+          type: typeText,
+          ...defaultText !== void 0 ? { defaultText } : {}
+        });
+      }
+    }
+  });
+  if (className === void 0) {
+    throw new Error(`No class declaration found in ${filePath}`);
+  }
+  return { className, stateFields, dependencies };
+}
+function resolveComponentPaths(projectDirectory, rawName) {
+  const pascal = toPascalCase(rawName);
+  const baseName = stripSuffix(pascal, "Component");
+  const className = `${baseName}Component`;
+  const kebabName = toKebabCase(baseName);
+  const relativePath = path2.posix.join("src", "components", `${kebabName}-component.ts`);
+  const absoluteFilePath = resolveWithinProject(projectDirectory, relativePath);
+  return { absoluteFilePath, className, kebabName };
+}
+function formatToolResult(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+async function collectTypeScriptFiles(directory) {
+  if (!await fileSystemExtra.pathExists(directory)) {
+    return [];
+  }
+  const collected = [];
+  const walk = async (current) => {
+    const entries = await fileSystemExtra.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryAbsolute = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryAbsolute);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts")) {
+        collected.push(entryAbsolute);
+      }
+    }
+  };
+  await walk(directory);
+  return collected;
+}
+function registerComponentTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const createComponentTool = {
+    name: "create_component",
+    description: "Scaffold a new Donut component file under src/components/. State fields generate typed properties with sane defaults plus clone/serialize/deserialize. Fails if the file already exists.",
+    inputSchema: zodToJsonSchema(createComponentInputSchema),
+    handler: async (input) => {
+      const parsed = createComponentInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveComponentPaths(projectDirectory, parsed.name);
+      if (await fileSystemExtra.pathExists(absoluteFilePath)) {
+        throw new Error(`Component file already exists: ${absoluteFilePath}`);
+      }
+      const lifecycleHooks = parsed.lifecycleHooks ?? [];
+      const source = renderComponentSource(className, parsed.stateFields, lifecycleHooks);
+      await fileSystemExtra.ensureDir(path2.dirname(absoluteFilePath));
+      await fileSystemExtra.writeFile(absoluteFilePath, source, "utf8");
+      return formatToolResult({ className, filePath: absoluteFilePath });
+    }
+  };
+  const readComponentTool = {
+    name: "read_component",
+    description: "Return the source text of an existing component file.",
+    inputSchema: zodToJsonSchema(readComponentInputSchema),
+    handler: async (input) => {
+      const parsed = readComponentInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveComponentPaths(projectDirectory, parsed.name);
+      if (!await fileSystemExtra.pathExists(absoluteFilePath)) {
+        throw new Error(`Component file not found: ${absoluteFilePath}`);
+      }
+      const source = await fileSystemExtra.readFile(absoluteFilePath, "utf8");
+      return formatToolResult({ className, filePath: absoluteFilePath, source });
+    }
+  };
+  const updateComponentTool = {
+    name: "update_component",
+    description: "Apply structural changes to an existing component: add/remove/rename state fields and add/remove onAdd/onRemove lifecycle hooks. File is re-rendered from the merged field list to keep clone/serialize/deserialize in sync.",
+    inputSchema: zodToJsonSchema(updateComponentInputSchema),
+    handler: async (input) => {
+      const parsed = updateComponentInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveComponentPaths(projectDirectory, parsed.name);
+      if (!await fileSystemExtra.pathExists(absoluteFilePath)) {
+        throw new Error(`Component file not found: ${absoluteFilePath}`);
+      }
+      const existingSource = await fileSystemExtra.readFile(absoluteFilePath, "utf8");
+      const existing = parseComponentSource(existingSource, absoluteFilePath);
+      const supportedTypes = ["number", "string", "boolean", "Vector2", "Vector3"];
+      const isSupportedType = (value) => supportedTypes.includes(value);
+      const currentFields = existing.stateFields.filter((field) => isSupportedType(field.type)).map((field) => ({
+        name: field.name,
+        type: field.type
+      }));
+      const changes = parsed.changes;
+      const removeFields = new Set(changes.removeFields ?? []);
+      const renameMap = new Map((changes.renameFields ?? []).map((rename) => [rename.from, rename.to]));
+      const rebuiltFields = [];
+      for (const field of currentFields) {
+        if (removeFields.has(field.name)) {
+          continue;
+        }
+        const renamedTo = renameMap.get(field.name);
+        rebuiltFields.push({
+          name: renamedTo ?? field.name,
+          type: field.type
+        });
+      }
+      for (const added of changes.addFields ?? []) {
+        rebuiltFields.push(added);
+      }
+      const hadOnAdd = /\bonAdd\s*\(/.test(existingSource);
+      const hadOnRemove = /\bonRemove\s*\(/.test(existingSource);
+      const lifecycleHooksSet = /* @__PURE__ */ new Set();
+      if (hadOnAdd) {
+        lifecycleHooksSet.add("onAdd");
+      }
+      if (hadOnRemove) {
+        lifecycleHooksSet.add("onRemove");
+      }
+      if (changes.addHook !== void 0) {
+        lifecycleHooksSet.add(changes.addHook);
+      }
+      if (changes.removeHook !== void 0) {
+        lifecycleHooksSet.delete(changes.removeHook);
+      }
+      const nextSource = renderComponentSource(className, rebuiltFields, Array.from(lifecycleHooksSet));
+      await fileSystemExtra.writeFile(absoluteFilePath, nextSource, "utf8");
+      return formatToolResult({
+        className,
+        filePath: absoluteFilePath,
+        stateFields: rebuiltFields,
+        lifecycleHooks: Array.from(lifecycleHooksSet)
+      });
+    }
+  };
+  const deleteComponentTool = {
+    name: "delete_component",
+    description: "Delete a component file and report warnings for any references to the class name found under src/systems/ or src/scenes/.",
+    inputSchema: zodToJsonSchema(deleteComponentInputSchema),
+    handler: async (input) => {
+      const parsed = deleteComponentInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveComponentPaths(projectDirectory, parsed.name);
+      if (!await fileSystemExtra.pathExists(absoluteFilePath)) {
+        throw new Error(`Component file not found: ${absoluteFilePath}`);
+      }
+      const warnings = [];
+      const scanRoots = [
+        resolveWithinProject(projectDirectory, "src/systems"),
+        resolveWithinProject(projectDirectory, "src/scenes")
+      ];
+      for (const root of scanRoots) {
+        const files = await collectTypeScriptFiles(root);
+        for (const filePath of files) {
+          const content = await fileSystemExtra.readFile(filePath, "utf8");
+          const lines = content.split("\n");
+          lines.forEach((lineText, lineIndex) => {
+            const pattern = new RegExp(`\\b${className}\\b`);
+            if (pattern.test(lineText)) {
+              warnings.push({
+                filePath,
+                line: lineIndex + 1,
+                text: lineText.trim()
+              });
+            }
+          });
+        }
+      }
+      await fileSystemExtra.remove(absoluteFilePath);
+      return formatToolResult({ deleted: absoluteFilePath, className, warnings });
+    }
+  };
+  const listComponentsTool = {
+    name: "list_components",
+    description: "List all component files under src/components/ with their class names, state fields, and declared dependencies.",
+    inputSchema: zodToJsonSchema(listComponentsInputSchema),
+    handler: async (input) => {
+      listComponentsInputSchema.parse(input ?? {});
+      const componentsDirectory = resolveWithinProject(projectDirectory, "src/components");
+      const files = await collectTypeScriptFiles(componentsDirectory);
+      const components = [];
+      for (const filePath of files) {
+        const content = await fileSystemExtra.readFile(filePath, "utf8");
+        try {
+          const parsedFile = parseComponentSource(content, filePath);
+          components.push({
+            name: parsedFile.className,
+            filePath,
+            stateFields: parsedFile.stateFields.map((field) => ({
+              name: field.name,
+              type: field.type
+            })),
+            dependencies: parsedFile.dependencies
+          });
+        } catch {
+        }
+      }
+      return formatToolResult({ components });
+    }
+  };
+  context.registerTool(createComponentTool);
+  context.registerTool(readComponentTool);
+  context.registerTool(updateComponentTool);
+  context.registerTool(deleteComponentTool);
+  context.registerTool(listComponentsTool);
+}
+
+// ../mcp/dist/tools/component-system/systems.js
+import path3 from "path";
+import fileSystemExtra2 from "fs-extra";
+import typescript2 from "typescript";
+import { z as z2 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+var priorityEnum = z2.enum(["Highest", "Higher", "Average", "Lower", "Lowest"]);
+var systemTypeEnum = z2.enum(["Update", "Draw"]);
+var createSystemInputSchema = z2.object({
+  name: z2.string().min(1),
+  queryComponents: z2.array(z2.string().min(1)).default([]),
+  priority: priorityEnum.optional(),
+  systemType: systemTypeEnum.optional()
+});
+var readSystemInputSchema = z2.object({ name: z2.string().min(1) });
+var updateSystemInputSchema = z2.object({
+  name: z2.string().min(1),
+  changes: z2.object({
+    setQueryComponents: z2.array(z2.string().min(1)).optional(),
+    setPriority: priorityEnum.optional(),
+    setSystemType: systemTypeEnum.optional()
+  }).default({})
+});
+var deleteSystemInputSchema = z2.object({ name: z2.string().min(1) });
+var listSystemsInputSchema = z2.object({}).default({});
+function renderSystemSource(className, queryComponents, priority, systemType) {
+  const queryComponentList = queryComponents.join(", ");
+  const coreImports = [
+    "System",
+    "SystemPriority",
+    "SystemType",
+    "Query",
+    "type World"
+  ];
+  for (const componentName of queryComponents) {
+    if (!coreImports.includes(componentName)) {
+      coreImports.push(componentName);
+    }
+  }
+  const lines = [];
+  lines.push(`import {`);
+  for (const importName of coreImports) {
+    lines.push(`  ${importName},`);
+  }
+  lines.push(`} from '@donut/core';`);
+  lines.push("");
+  lines.push("/**");
+  lines.push(` * ${className} \u2014 generated by the Donut MCP \`create_system\` tool.`);
+  lines.push(" *");
+  lines.push(" * Processes entities matching its declared component query each frame.");
+  lines.push(" */");
+  lines.push(`export class ${className} extends System {`);
+  lines.push(`  /** Indicates whether this system runs in the update or draw phase. */`);
+  lines.push(`  readonly systemType = SystemType.${systemType};`);
+  lines.push("");
+  lines.push(`  /** Execution priority relative to sibling systems. */`);
+  lines.push(`  static priority = SystemPriority.${priority};`);
+  lines.push("");
+  lines.push(`  /** Reactive query matching entities this system operates on. */`);
+  lines.push(`  private readonly entityQuery: Query<${queryComponents.length > 0 ? `typeof ${queryComponents.join(", typeof ")}` : "never"}>;`);
+  lines.push("");
+  lines.push("  /** Build the query once the world is available. */");
+  lines.push("  constructor(world: World) {");
+  lines.push("    super();");
+  lines.push(`    this.entityQuery = world.query([${queryComponentList}]) as Query<${queryComponents.length > 0 ? `typeof ${queryComponents.join(", typeof ")}` : "never"}>;`);
+  lines.push("  }");
+  lines.push("");
+  lines.push("  /**");
+  lines.push("   * Frame update. Iterates matching entities and applies system logic.");
+  lines.push("   * @param elapsedMilliseconds time since previous frame, in milliseconds");
+  lines.push("   */");
+  lines.push("  update(elapsedMilliseconds: number): void {");
+  lines.push("    void elapsedMilliseconds;");
+  lines.push("    for (const entity of this.entityQuery.entities) {");
+  lines.push("      void entity;");
+  lines.push("    }");
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function parseSystemSource(sourceText, filePath) {
+  const sourceFile = typescript2.createSourceFile(filePath, sourceText, typescript2.ScriptTarget.ES2022, true);
+  let className;
+  let priority = "Average";
+  let systemType = "Update";
+  const queryComponents = [];
+  typescript2.forEachChild(sourceFile, (node) => {
+    if (!typescript2.isClassDeclaration(node) || node.name === void 0) {
+      return;
+    }
+    className = node.name.text;
+    for (const member of node.members) {
+      if (typescript2.isPropertyDeclaration(member) && typescript2.isIdentifier(member.name)) {
+        const propertyName = member.name.text;
+        if (propertyName === "systemType" && member.initializer !== void 0) {
+          const text = member.initializer.getText(sourceFile);
+          const match = /SystemType\.(\w+)/.exec(text);
+          if (match) {
+            systemType = match[1];
+          }
+        }
+        if (propertyName === "priority" && member.initializer !== void 0) {
+          const text = member.initializer.getText(sourceFile);
+          const match = /SystemPriority\.(\w+)/.exec(text);
+          if (match) {
+            priority = match[1];
+          }
+        }
+      }
+      if (typescript2.isConstructorDeclaration(member) && member.body !== void 0) {
+        const bodyText = member.body.getText(sourceFile);
+        const queryMatch = /world\.query\(\s*\[([^\]]*)\]/m.exec(bodyText);
+        if (queryMatch) {
+          const inside = queryMatch[1].trim();
+          if (inside.length > 0) {
+            for (const part of inside.split(",")) {
+              const trimmed = part.trim();
+              if (trimmed.length > 0) {
+                queryComponents.push(trimmed);
+              }
+            }
+          }
+        }
+      }
+    }
+  });
+  if (className === void 0) {
+    throw new Error(`No class declaration found in ${filePath}`);
+  }
+  return { className, queryComponents, priority, systemType };
+}
+function resolveSystemPaths(projectDirectory, rawName) {
+  const pascal = toPascalCase(rawName);
+  const baseName = stripSuffix(pascal, "System");
+  const className = `${baseName}System`;
+  const kebabName = toKebabCase(baseName);
+  const relativePath = path3.posix.join("src", "systems", `${kebabName}-system.ts`);
+  const absoluteFilePath = resolveWithinProject(projectDirectory, relativePath);
+  return { absoluteFilePath, className, kebabName };
+}
+function formatToolResult2(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+async function collectTypeScriptFiles2(directory) {
+  if (!await fileSystemExtra2.pathExists(directory)) {
+    return [];
+  }
+  const collected = [];
+  const walk = async (current) => {
+    const entries = await fileSystemExtra2.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryAbsolute = path3.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryAbsolute);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts")) {
+        collected.push(entryAbsolute);
+      }
+    }
+  };
+  await walk(directory);
+  return collected;
+}
+function registerSystemTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const createSystemTool = {
+    name: "create_system",
+    description: "Scaffold a new Donut system file under src/systems/. Declares a reactive query over the named components and an empty update loop. Imports only from @donut/core to preserve the portability guarantee for game logic.",
+    inputSchema: zodToJsonSchema2(createSystemInputSchema),
+    handler: async (input) => {
+      const parsed = createSystemInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveSystemPaths(projectDirectory, parsed.name);
+      if (await fileSystemExtra2.pathExists(absoluteFilePath)) {
+        throw new Error(`System file already exists: ${absoluteFilePath}`);
+      }
+      const priority = parsed.priority ?? "Average";
+      const systemType = parsed.systemType ?? "Update";
+      const source = renderSystemSource(className, parsed.queryComponents, priority, systemType);
+      await fileSystemExtra2.ensureDir(path3.dirname(absoluteFilePath));
+      await fileSystemExtra2.writeFile(absoluteFilePath, source, "utf8");
+      return formatToolResult2({ className, filePath: absoluteFilePath });
+    }
+  };
+  const readSystemTool = {
+    name: "read_system",
+    description: "Return the source text of an existing system file.",
+    inputSchema: zodToJsonSchema2(readSystemInputSchema),
+    handler: async (input) => {
+      const parsed = readSystemInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveSystemPaths(projectDirectory, parsed.name);
+      if (!await fileSystemExtra2.pathExists(absoluteFilePath)) {
+        throw new Error(`System file not found: ${absoluteFilePath}`);
+      }
+      const source = await fileSystemExtra2.readFile(absoluteFilePath, "utf8");
+      return formatToolResult2({ className, filePath: absoluteFilePath, source });
+    }
+  };
+  const updateSystemTool = {
+    name: "update_system",
+    description: "Apply structural changes to an existing system: replace the query component list, priority, or system-type. File is re-rendered from the merged configuration.",
+    inputSchema: zodToJsonSchema2(updateSystemInputSchema),
+    handler: async (input) => {
+      const parsed = updateSystemInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveSystemPaths(projectDirectory, parsed.name);
+      if (!await fileSystemExtra2.pathExists(absoluteFilePath)) {
+        throw new Error(`System file not found: ${absoluteFilePath}`);
+      }
+      const existingSource = await fileSystemExtra2.readFile(absoluteFilePath, "utf8");
+      const existing = parseSystemSource(existingSource, absoluteFilePath);
+      const nextQueryComponents = parsed.changes.setQueryComponents ?? existing.queryComponents;
+      const nextPriority = parsed.changes.setPriority ?? existing.priority;
+      const nextSystemType = parsed.changes.setSystemType ?? existing.systemType;
+      const nextSource = renderSystemSource(className, nextQueryComponents, nextPriority, nextSystemType);
+      await fileSystemExtra2.writeFile(absoluteFilePath, nextSource, "utf8");
+      return formatToolResult2({
+        className,
+        filePath: absoluteFilePath,
+        queryComponents: nextQueryComponents,
+        priority: nextPriority,
+        systemType: nextSystemType
+      });
+    }
+  };
+  const deleteSystemTool = {
+    name: "delete_system",
+    description: "Delete a system file and report warnings for any references to the class name found under src/scenes/.",
+    inputSchema: zodToJsonSchema2(deleteSystemInputSchema),
+    handler: async (input) => {
+      const parsed = deleteSystemInputSchema.parse(input);
+      const { absoluteFilePath, className } = resolveSystemPaths(projectDirectory, parsed.name);
+      if (!await fileSystemExtra2.pathExists(absoluteFilePath)) {
+        throw new Error(`System file not found: ${absoluteFilePath}`);
+      }
+      const warnings = [];
+      const scenesDirectory = resolveWithinProject(projectDirectory, "src/scenes");
+      const files = await collectTypeScriptFiles2(scenesDirectory);
+      for (const filePath of files) {
+        const content = await fileSystemExtra2.readFile(filePath, "utf8");
+        const lines = content.split("\n");
+        lines.forEach((lineText, lineIndex) => {
+          const pattern = new RegExp(`\\b${className}\\b`);
+          if (pattern.test(lineText)) {
+            warnings.push({ filePath, line: lineIndex + 1, text: lineText.trim() });
+          }
+        });
+      }
+      await fileSystemExtra2.remove(absoluteFilePath);
+      return formatToolResult2({ deleted: absoluteFilePath, className, warnings });
+    }
+  };
+  const listSystemsTool = {
+    name: "list_systems",
+    description: "List all system files under src/systems/ with their class names, query components, priority, and system-type.",
+    inputSchema: zodToJsonSchema2(listSystemsInputSchema),
+    handler: async (input) => {
+      listSystemsInputSchema.parse(input ?? {});
+      const systemsDirectory = resolveWithinProject(projectDirectory, "src/systems");
+      const files = await collectTypeScriptFiles2(systemsDirectory);
+      const systems = [];
+      for (const filePath of files) {
+        const content = await fileSystemExtra2.readFile(filePath, "utf8");
+        try {
+          const parsedFile = parseSystemSource(content, filePath);
+          systems.push({
+            name: parsedFile.className,
+            filePath,
+            queryComponents: parsedFile.queryComponents,
+            priority: parsedFile.priority,
+            systemType: parsedFile.systemType
+          });
+        } catch {
+        }
+      }
+      return formatToolResult2({ systems });
+    }
+  };
+  context.registerTool(createSystemTool);
+  context.registerTool(readSystemTool);
+  context.registerTool(updateSystemTool);
+  context.registerTool(deleteSystemTool);
+  context.registerTool(listSystemsTool);
+}
+
+// ../mcp/dist/tools/component-system/index.js
+function registerComponentSystemTools(_server, context) {
+  registerComponentTools(context);
+  registerSystemTools(context);
+}
+
+// ../mcp/dist/tools/entity-scene/assets.js
+import path4 from "path";
+import fileSystemExtra3 from "fs-extra";
+import { z as z3 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+var assetTypeSchema = z3.enum(["texture", "audio", "font", "other"]);
+var addAssetInputSchema = z3.object({
+  type: assetTypeSchema,
+  sourcePath: z3.string().min(1),
+  name: z3.string().min(1).optional()
+});
+var getAssetInputSchema = z3.object({ name: z3.string().min(1) });
+var replaceAssetInputSchema = z3.object({
+  name: z3.string().min(1),
+  newSourcePath: z3.string().min(1)
+});
+var deleteAssetInputSchema = z3.object({ name: z3.string().min(1) });
+var listAssetsInputSchema = z3.object({ type: assetTypeSchema.optional() }).default({});
+var ASSET_TYPE_DIRECTORIES = Object.freeze({
+  texture: "textures",
+  audio: "audio",
+  font: "fonts",
+  other: "other"
+});
+function formatToolResult3(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function isHttpUrl(sourcePath) {
+  return /^https?:\/\//i.test(sourcePath);
+}
+async function copyOrDownload(sourcePath, destinationAbsolute) {
+  await fileSystemExtra3.ensureDir(path4.dirname(destinationAbsolute));
+  if (isHttpUrl(sourcePath)) {
+    const response = await fetch(sourcePath);
+    if (!response.ok) {
+      throw new Error(`Failed to download asset from ${sourcePath}: ${response.status}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await fileSystemExtra3.writeFile(destinationAbsolute, buffer);
+    return;
+  }
+  if (!await fileSystemExtra3.pathExists(sourcePath)) {
+    throw new Error(`Asset source file not found: ${sourcePath}`);
+  }
+  await fileSystemExtra3.copy(sourcePath, destinationAbsolute, { overwrite: true });
+}
+async function scanAssets(projectDirectory) {
+  const assetsRoot = resolveWithinProject(projectDirectory, "assets");
+  if (!await fileSystemExtra3.pathExists(assetsRoot)) {
+    return [];
+  }
+  const located = [];
+  for (const [typeKey, typeDirectory] of Object.entries(ASSET_TYPE_DIRECTORIES)) {
+    const absoluteTypeDirectory = path4.join(assetsRoot, typeDirectory);
+    if (!await fileSystemExtra3.pathExists(absoluteTypeDirectory)) {
+      continue;
+    }
+    const entries = await fileSystemExtra3.readdir(absoluteTypeDirectory);
+    for (const entryName of entries) {
+      const absolutePath = path4.join(absoluteTypeDirectory, entryName);
+      const stats = await fileSystemExtra3.stat(absolutePath);
+      if (!stats.isFile()) {
+        continue;
+      }
+      located.push({
+        name: entryName,
+        type: typeKey,
+        absolutePath,
+        relativePath: path4.posix.join("assets", typeDirectory, entryName)
+      });
+    }
+  }
+  return located;
+}
+async function findAssetByName(projectDirectory, assetName) {
+  const assets = await scanAssets(projectDirectory);
+  const match = assets.find((candidate) => candidate.name === assetName);
+  if (match === void 0) {
+    throw new Error(`Asset not found: ${assetName}`);
+  }
+  return match;
+}
+async function findReferencesInSource(projectDirectory, searchText) {
+  const sourceRoot = resolveWithinProject(projectDirectory, "src");
+  const references = [];
+  if (!await fileSystemExtra3.pathExists(sourceRoot)) {
+    return references;
+  }
+  const walk = async (current) => {
+    const entries = await fileSystemExtra3.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryAbsolute = path4.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryAbsolute);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".ts")) {
+        continue;
+      }
+      const content = await fileSystemExtra3.readFile(entryAbsolute, "utf8");
+      const lines = content.split("\n");
+      lines.forEach((lineText, lineIndex) => {
+        if (lineText.includes(searchText)) {
+          references.push({
+            filePath: entryAbsolute,
+            line: lineIndex + 1,
+            text: lineText.trim()
+          });
+        }
+      });
+    }
+  };
+  await walk(sourceRoot);
+  return references;
+}
+function registerAssetTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const addAssetTool = {
+    name: "add_asset",
+    description: "Copy (or download, if sourcePath is http(s)) a file into assets/<type>/. If `name` is provided it is used as the destination filename; otherwise the source basename is used.",
+    inputSchema: zodToJsonSchema3(addAssetInputSchema),
+    handler: async (input) => {
+      const parsedInput = addAssetInputSchema.parse(input);
+      const destinationFilename = parsedInput.name ?? path4.basename(parsedInput.sourcePath.split("?")[0]);
+      const relativePath = path4.posix.join("assets", ASSET_TYPE_DIRECTORIES[parsedInput.type], destinationFilename);
+      const destinationAbsolute = resolveWithinProject(projectDirectory, relativePath);
+      await copyOrDownload(parsedInput.sourcePath, destinationAbsolute);
+      const stats = await fileSystemExtra3.stat(destinationAbsolute);
+      return formatToolResult3({
+        name: destinationFilename,
+        type: parsedInput.type,
+        path: relativePath,
+        absolutePath: destinationAbsolute,
+        sizeBytes: stats.size
+      });
+    }
+  };
+  const getAssetTool = {
+    name: "get_asset",
+    description: "Return metadata (name, type, relative path, size in bytes) for an asset by filename. Dimensions are omitted because they would require a native image decoder.",
+    inputSchema: zodToJsonSchema3(getAssetInputSchema),
+    handler: async (input) => {
+      const parsedInput = getAssetInputSchema.parse(input);
+      const located = await findAssetByName(projectDirectory, parsedInput.name);
+      const stats = await fileSystemExtra3.stat(located.absolutePath);
+      return formatToolResult3({
+        name: located.name,
+        type: located.type,
+        path: located.relativePath,
+        absolutePath: located.absolutePath,
+        sizeBytes: stats.size
+      });
+    }
+  };
+  const replaceAssetTool = {
+    name: "replace_asset",
+    description: "Overwrite an existing asset file with a new source (local path or http(s) URL). The destination filename and type folder are preserved.",
+    inputSchema: zodToJsonSchema3(replaceAssetInputSchema),
+    handler: async (input) => {
+      const parsedInput = replaceAssetInputSchema.parse(input);
+      const located = await findAssetByName(projectDirectory, parsedInput.name);
+      await copyOrDownload(parsedInput.newSourcePath, located.absolutePath);
+      const stats = await fileSystemExtra3.stat(located.absolutePath);
+      return formatToolResult3({
+        name: located.name,
+        type: located.type,
+        path: located.relativePath,
+        sizeBytes: stats.size
+      });
+    }
+  };
+  const deleteAssetTool = {
+    name: "delete_asset",
+    description: "Delete an asset file. Before deletion, scans src/ for string references to the asset filename and returns them as warnings.",
+    inputSchema: zodToJsonSchema3(deleteAssetInputSchema),
+    handler: async (input) => {
+      const parsedInput = deleteAssetInputSchema.parse(input);
+      const located = await findAssetByName(projectDirectory, parsedInput.name);
+      const warnings = await findReferencesInSource(projectDirectory, located.name);
+      await fileSystemExtra3.remove(located.absolutePath);
+      return formatToolResult3({
+        deleted: located.absolutePath,
+        name: located.name,
+        warnings
+      });
+    }
+  };
+  const listAssetsTool = {
+    name: "list_assets",
+    description: "List all assets, optionally filtered by type.",
+    inputSchema: zodToJsonSchema3(listAssetsInputSchema),
+    handler: async (input) => {
+      const parsedInput = listAssetsInputSchema.parse(input ?? {});
+      const assets = await scanAssets(projectDirectory);
+      const filtered = parsedInput.type === void 0 ? assets : assets.filter((asset) => asset.type === parsedInput.type);
+      return formatToolResult3({
+        assets: filtered.map((asset) => ({
+          name: asset.name,
+          type: asset.type,
+          path: asset.relativePath
+        }))
+      });
+    }
+  };
+  context.registerTool(addAssetTool);
+  context.registerTool(getAssetTool);
+  context.registerTool(replaceAssetTool);
+  context.registerTool(deleteAssetTool);
+  context.registerTool(listAssetsTool);
+}
+
+// ../mcp/dist/tools/entity-scene/entities.js
+import { z as z4 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
+
+// ../mcp/dist/tools/entity-scene/scene-file.js
+import path5 from "path";
+import fileSystemExtra4 from "fs-extra";
+var ENGINE_COMPONENT_PACKAGE = Object.freeze({
+  TransformComponent: "@donut/core",
+  SpriteComponent: "@donut/pixi",
+  AnimatedSpriteComponent: "@donut/pixi",
+  TilemapComponent: "@donut/pixi",
+  Camera2dComponent: "@donut/pixi",
+  CtrllrInputComponent: "@donut/ctrllr"
+});
+var MARKER_ENTITIES_OPEN = "@donut-entities";
+var MARKER_SYSTEMS_OPEN = "@donut-systems";
+function resolveScenePaths(projectDirectory, rawName) {
+  const pascal = toPascalCase(rawName);
+  const sceneBaseName = stripSuffix(pascal, "Scene");
+  const sceneClassName = `${sceneBaseName}Scene`;
+  const sceneKebabName = `${toKebabCase(sceneBaseName)}-scene`;
+  const relativePath = path5.posix.join("src", "scenes", `${sceneKebabName}.ts`);
+  const absoluteFilePath = resolveWithinProject(projectDirectory, relativePath);
+  return { absoluteFilePath, sceneBaseName, sceneClassName, sceneKebabName, relativePath };
+}
+function extractMarkerJson(source, markerTag) {
+  const markerIndex = source.indexOf(markerTag);
+  if (markerIndex === -1) {
+    return void 0;
+  }
+  const closingIndex = source.indexOf("*/", markerIndex);
+  if (closingIndex === -1) {
+    throw new Error(`Marker ${markerTag} has no closing */`);
+  }
+  const rawBlock = source.slice(markerIndex + markerTag.length, closingIndex);
+  const stripped = rawBlock.split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n").trim();
+  return stripped;
+}
+function parseSceneSource(source, sceneBaseName, sceneKebabName) {
+  const sceneClassName = `${sceneBaseName}Scene`;
+  const entitiesJson = extractMarkerJson(source, MARKER_ENTITIES_OPEN);
+  const systemsJson = extractMarkerJson(source, MARKER_SYSTEMS_OPEN);
+  const entities = entitiesJson !== void 0 && entitiesJson.length > 0 ? JSON.parse(entitiesJson) : [];
+  const systems = systemsJson !== void 0 && systemsJson.length > 0 ? JSON.parse(systemsJson) : [];
+  return { sceneBaseName, sceneClassName, sceneKebabName, entities, systems };
+}
+function renderConfigLiteral(value) {
+  if (Array.isArray(value) && value.every((element) => typeof element === "number")) {
+    if (value.length === 2) {
+      return `new Vector2(${value[0]}, ${value[1]})`;
+    }
+    if (value.length === 3) {
+      return `new Vector3(${value[0]}, ${value[1]}, ${value[2]})`;
+    }
+    if (value.length === 4) {
+      return `new Quaternion(${value[0]}, ${value[1]}, ${value[2]}, ${value[3]})`;
+    }
+  }
+  return JSON.stringify(value);
+}
+async function resolveComponentImportSource(projectDirectory, componentType) {
+  const baseName = stripSuffix(componentType, "Component");
+  const kebabName = toKebabCase(baseName);
+  const localRelative = path5.posix.join("src", "components", `${kebabName}-component.ts`);
+  const localAbsolute = resolveWithinProject(projectDirectory, localRelative);
+  if (await fileSystemExtra4.pathExists(localAbsolute)) {
+    return `../components/${kebabName}-component.js`;
+  }
+  const enginePackage = ENGINE_COMPONENT_PACKAGE[componentType];
+  if (enginePackage !== void 0) {
+    return enginePackage;
+  }
+  return void 0;
+}
+async function resolveSystemImportSource(projectDirectory, systemType) {
+  const baseName = stripSuffix(systemType, "System");
+  const kebabName = toKebabCase(baseName);
+  const localRelative = path5.posix.join("src", "systems", `${kebabName}-system.ts`);
+  const localAbsolute = resolveWithinProject(projectDirectory, localRelative);
+  if (await fileSystemExtra4.pathExists(localAbsolute)) {
+    return `../systems/${kebabName}-system.js`;
+  }
+  return void 0;
+}
+async function renderSceneSource(projectDirectory, parsedScene) {
+  const componentImports = /* @__PURE__ */ new Map();
+  componentImports.set("@donut/core", /* @__PURE__ */ new Set(["Entity", "type World"]));
+  const todoComments = [];
+  const usedMathTypes = /* @__PURE__ */ new Set();
+  for (const entity of parsedScene.entities) {
+    for (const componentDescriptor of entity.components) {
+      const importSource = await resolveComponentImportSource(projectDirectory, componentDescriptor.type);
+      if (importSource === void 0) {
+        todoComments.push(`// TODO: resolve import for unknown component "${componentDescriptor.type}"`);
+        continue;
+      }
+      const existing = componentImports.get(importSource) ?? /* @__PURE__ */ new Set();
+      existing.add(componentDescriptor.type);
+      componentImports.set(importSource, existing);
+      if (componentDescriptor.config !== void 0) {
+        for (const configValue of Object.values(componentDescriptor.config)) {
+          if (Array.isArray(configValue) && configValue.every((element) => typeof element === "number")) {
+            if (configValue.length === 2) {
+              usedMathTypes.add("Vector2");
+            } else if (configValue.length === 3) {
+              usedMathTypes.add("Vector3");
+            } else if (configValue.length === 4) {
+              usedMathTypes.add("Quaternion");
+            }
+          }
+        }
+      }
+    }
+  }
+  const systemImports = /* @__PURE__ */ new Map();
+  for (const systemType of parsedScene.systems) {
+    const importSource = await resolveSystemImportSource(projectDirectory, systemType);
+    if (importSource === void 0) {
+      todoComments.push(`// TODO: resolve import for unknown system "${systemType}"`);
+      continue;
+    }
+    const existing = systemImports.get(importSource) ?? /* @__PURE__ */ new Set();
+    existing.add(systemType);
+    systemImports.set(importSource, existing);
+  }
+  const lines = [];
+  const externalModules = [];
+  const relativeModules = [];
+  for (const moduleSpecifier of componentImports.keys()) {
+    if (moduleSpecifier.startsWith(".")) {
+      relativeModules.push(moduleSpecifier);
+    } else {
+      externalModules.push(moduleSpecifier);
+    }
+  }
+  for (const moduleSpecifier of systemImports.keys()) {
+    if (moduleSpecifier.startsWith(".")) {
+      relativeModules.push(moduleSpecifier);
+    } else {
+      externalModules.push(moduleSpecifier);
+    }
+  }
+  externalModules.sort();
+  relativeModules.sort();
+  for (const moduleSpecifier of externalModules) {
+    const names = /* @__PURE__ */ new Set([
+      ...componentImports.get(moduleSpecifier) ?? /* @__PURE__ */ new Set(),
+      ...systemImports.get(moduleSpecifier) ?? /* @__PURE__ */ new Set()
+    ]);
+    lines.push(`import { ${Array.from(names).sort().join(", ")} } from '${moduleSpecifier}';`);
+  }
+  if (usedMathTypes.size > 0) {
+    lines.push(`import { ${Array.from(usedMathTypes).sort().join(", ")} } from '@donut/math';`);
+  }
+  for (const moduleSpecifier of relativeModules) {
+    const names = /* @__PURE__ */ new Set([
+      ...componentImports.get(moduleSpecifier) ?? /* @__PURE__ */ new Set(),
+      ...systemImports.get(moduleSpecifier) ?? /* @__PURE__ */ new Set()
+    ]);
+    lines.push(`import { ${Array.from(names).sort().join(", ")} } from '${moduleSpecifier}';`);
+  }
+  lines.push("");
+  const entitiesJsonPayload = JSON.stringify(parsedScene.entities, null, 2);
+  const systemsJsonPayload = JSON.stringify(parsedScene.systems, null, 2);
+  lines.push("/**");
+  lines.push(` * ${MARKER_ENTITIES_OPEN}`);
+  for (const jsonLine of entitiesJsonPayload.split("\n")) {
+    lines.push(` * ${jsonLine}`);
+  }
+  lines.push(" */");
+  lines.push("/**");
+  lines.push(` * ${MARKER_SYSTEMS_OPEN}`);
+  for (const jsonLine of systemsJsonPayload.split("\n")) {
+    lines.push(` * ${jsonLine}`);
+  }
+  lines.push(" */");
+  lines.push("");
+  for (const todoComment of todoComments) {
+    lines.push(todoComment);
+  }
+  if (todoComments.length > 0) {
+    lines.push("");
+  }
+  lines.push("/**");
+  lines.push(` * Construct the ${parsedScene.sceneClassName} entities and register its systems on`);
+  lines.push(" * the provided world. Generated by the Donut MCP scene tools \u2014 do not edit the");
+  lines.push(" * body directly; edit the declarative marker blocks above instead.");
+  lines.push(" */");
+  lines.push(`export function create${parsedScene.sceneClassName}(world: World): Entity[] {`);
+  lines.push("  const createdEntities: Entity[] = [];");
+  for (let entityIndex = 0; entityIndex < parsedScene.entities.length; entityIndex += 1) {
+    const entity = parsedScene.entities[entityIndex];
+    const entityVariable = `entity${entityIndex}`;
+    lines.push("");
+    lines.push(`  const ${entityVariable} = new Entity({ name: ${JSON.stringify(entity.name)} });`);
+    for (const tagName of entity.tags ?? []) {
+      lines.push(`  ${entityVariable}.addTag(${JSON.stringify(tagName)});`);
+    }
+    for (let componentIndex = 0; componentIndex < entity.components.length; componentIndex += 1) {
+      const componentDescriptor = entity.components[componentIndex];
+      const componentVariable = `${entityVariable}Component${componentIndex}`;
+      lines.push(`  const ${componentVariable} = new ${componentDescriptor.type}();`);
+      for (const [fieldName, fieldValue] of Object.entries(componentDescriptor.config ?? {})) {
+        lines.push(`  ${componentVariable}.${fieldName} = ${renderConfigLiteral(fieldValue)};`);
+      }
+      lines.push(`  ${entityVariable}.addComponent(${componentVariable});`);
+    }
+    lines.push(`  world.add(${entityVariable});`);
+    lines.push(`  createdEntities.push(${entityVariable});`);
+  }
+  if (parsedScene.systems.length > 0) {
+    lines.push("");
+    for (const systemType of parsedScene.systems) {
+      lines.push(`  world.addSystem(new ${systemType}(world));`);
+    }
+  }
+  lines.push("");
+  lines.push("  return createdEntities;");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+async function readSceneFile(projectDirectory, rawName) {
+  const { absoluteFilePath, sceneBaseName, sceneKebabName } = resolveScenePaths(projectDirectory, rawName);
+  if (!await fileSystemExtra4.pathExists(absoluteFilePath)) {
+    throw new Error(`Scene file not found: ${absoluteFilePath}`);
+  }
+  const source = await fileSystemExtra4.readFile(absoluteFilePath, "utf8");
+  const parsed = parseSceneSource(source, sceneBaseName, sceneKebabName);
+  return { parsed, absoluteFilePath, source };
+}
+async function writeSceneFile(projectDirectory, parsedScene) {
+  const { absoluteFilePath } = resolveScenePaths(projectDirectory, parsedScene.sceneBaseName);
+  const source = await renderSceneSource(projectDirectory, parsedScene);
+  await fileSystemExtra4.ensureDir(path5.dirname(absoluteFilePath));
+  await fileSystemExtra4.writeFile(absoluteFilePath, source, "utf8");
+  return absoluteFilePath;
+}
+async function listSceneFiles(projectDirectory) {
+  const scenesDirectory = resolveWithinProject(projectDirectory, "src/scenes");
+  if (!await fileSystemExtra4.pathExists(scenesDirectory)) {
+    return [];
+  }
+  const entries = await fileSystemExtra4.readdir(scenesDirectory);
+  const scenes = [];
+  for (const entryName of entries) {
+    if (!entryName.endsWith("-scene.ts") || entryName.endsWith(".test.ts")) {
+      continue;
+    }
+    const sceneKebabName = entryName.slice(0, entryName.length - ".ts".length);
+    const sceneBaseName = toPascalCase(sceneKebabName.slice(0, sceneKebabName.length - "-scene".length));
+    try {
+      const source = await fileSystemExtra4.readFile(path5.join(scenesDirectory, entryName), "utf8");
+      scenes.push(parseSceneSource(source, sceneBaseName, sceneKebabName));
+    } catch {
+    }
+  }
+  return scenes;
+}
+
+// ../mcp/dist/tools/entity-scene/entities.js
+var createEntityInputSchema = z4.object({
+  sceneName: z4.string().min(1),
+  entityName: z4.string().min(1),
+  components: z4.array(z4.string().min(1)).default([]),
+  tags: z4.array(z4.string().min(1)).optional(),
+  componentConfigs: z4.record(z4.record(z4.unknown())).optional()
+});
+var getEntityInputSchema = z4.object({
+  sceneName: z4.string().min(1),
+  entityName: z4.string().min(1)
+});
+var updateEntityInputSchema = z4.object({
+  sceneName: z4.string().min(1),
+  entityName: z4.string().min(1),
+  addComponents: z4.array(z4.string().min(1)).optional(),
+  removeComponents: z4.array(z4.string().min(1)).optional(),
+  setConfig: z4.record(z4.record(z4.unknown())).optional(),
+  addTags: z4.array(z4.string().min(1)).optional(),
+  removeTags: z4.array(z4.string().min(1)).optional()
+});
+var deleteEntityInputSchema = z4.object({
+  sceneName: z4.string().min(1),
+  entityName: z4.string().min(1)
+});
+var listEntitiesInputSchema = z4.object({ sceneName: z4.string().min(1).optional() }).default({});
+var cloneEntityInputSchema = z4.object({
+  sceneName: z4.string().min(1),
+  sourceEntityName: z4.string().min(1),
+  newEntityName: z4.string().min(1),
+  overrides: z4.object({
+    tags: z4.array(z4.string().min(1)).optional(),
+    componentConfigs: z4.record(z4.record(z4.unknown())).optional()
+  }).optional()
+});
+function formatToolResult4(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function deepCloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function registerEntityTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const createEntityTool = {
+    name: "create_entity",
+    description: "Append a new entity to the @donut-entities marker block of a scene file. The scene body is regenerated. Fails if the entity name is already used in that scene or the scene file does not exist.",
+    inputSchema: zodToJsonSchema4(createEntityInputSchema),
+    handler: async (input) => {
+      const parsedInput = createEntityInputSchema.parse(input);
+      const { parsed: parsedScene } = await readSceneFile(projectDirectory, parsedInput.sceneName);
+      if (parsedScene.entities.some((entity) => entity.name === parsedInput.entityName)) {
+        throw new Error(`Entity "${parsedInput.entityName}" already exists in scene "${parsedInput.sceneName}"`);
+      }
+      const components = parsedInput.components.map((componentType) => {
+        const descriptor = { type: componentType };
+        const config = parsedInput.componentConfigs?.[componentType];
+        if (config !== void 0) {
+          descriptor.config = config;
+        }
+        return descriptor;
+      });
+      const newEntity = { name: parsedInput.entityName, components };
+      if (parsedInput.tags !== void 0 && parsedInput.tags.length > 0) {
+        newEntity.tags = parsedInput.tags;
+      }
+      parsedScene.entities.push(newEntity);
+      const absoluteFilePath = await writeSceneFile(projectDirectory, parsedScene);
+      return formatToolResult4({
+        sceneName: parsedScene.sceneBaseName,
+        entity: newEntity,
+        filePath: absoluteFilePath
+      });
+    }
+  };
+  const getEntityTool = {
+    name: "get_entity",
+    description: "Return the declarative record for a single entity in a scene.",
+    inputSchema: zodToJsonSchema4(getEntityInputSchema),
+    handler: async (input) => {
+      const parsedInput = getEntityInputSchema.parse(input);
+      const { parsed: parsedScene } = await readSceneFile(projectDirectory, parsedInput.sceneName);
+      const entity = parsedScene.entities.find((candidate) => candidate.name === parsedInput.entityName);
+      if (entity === void 0) {
+        throw new Error(`Entity "${parsedInput.entityName}" not found in scene "${parsedInput.sceneName}"`);
+      }
+      return formatToolResult4({ sceneName: parsedScene.sceneBaseName, entity });
+    }
+  };
+  const updateEntityTool = {
+    name: "update_entity",
+    description: "Add/remove components, replace component config, and add/remove tags on an existing entity. The scene body is regenerated on every call.",
+    inputSchema: zodToJsonSchema4(updateEntityInputSchema),
+    handler: async (input) => {
+      const parsedInput = updateEntityInputSchema.parse(input);
+      const { parsed: parsedScene } = await readSceneFile(projectDirectory, parsedInput.sceneName);
+      const entity = parsedScene.entities.find((candidate) => candidate.name === parsedInput.entityName);
+      if (entity === void 0) {
+        throw new Error(`Entity "${parsedInput.entityName}" not found in scene "${parsedInput.sceneName}"`);
+      }
+      if (parsedInput.removeComponents !== void 0) {
+        const toRemove = new Set(parsedInput.removeComponents);
+        entity.components = entity.components.filter((component) => !toRemove.has(component.type));
+      }
+      if (parsedInput.addComponents !== void 0) {
+        for (const componentType of parsedInput.addComponents) {
+          if (!entity.components.some((component) => component.type === componentType)) {
+            entity.components.push({ type: componentType });
+          }
+        }
+      }
+      if (parsedInput.setConfig !== void 0) {
+        for (const [componentType, config] of Object.entries(parsedInput.setConfig)) {
+          let component = entity.components.find((candidate) => candidate.type === componentType);
+          if (component === void 0) {
+            component = { type: componentType };
+            entity.components.push(component);
+          }
+          component.config = { ...component.config ?? {}, ...config };
+        }
+      }
+      if (parsedInput.addTags !== void 0) {
+        const nextTags = new Set(entity.tags ?? []);
+        for (const tag of parsedInput.addTags) {
+          nextTags.add(tag);
+        }
+        entity.tags = Array.from(nextTags);
+      }
+      if (parsedInput.removeTags !== void 0) {
+        const removalSet = new Set(parsedInput.removeTags);
+        entity.tags = (entity.tags ?? []).filter((tag) => !removalSet.has(tag));
+        if (entity.tags.length === 0) {
+          delete entity.tags;
+        }
+      }
+      const absoluteFilePath = await writeSceneFile(projectDirectory, parsedScene);
+      return formatToolResult4({
+        sceneName: parsedScene.sceneBaseName,
+        entity,
+        filePath: absoluteFilePath
+      });
+    }
+  };
+  const deleteEntityTool = {
+    name: "delete_entity",
+    description: "Remove an entity from a scene and regenerate the scene body.",
+    inputSchema: zodToJsonSchema4(deleteEntityInputSchema),
+    handler: async (input) => {
+      const parsedInput = deleteEntityInputSchema.parse(input);
+      const { parsed: parsedScene } = await readSceneFile(projectDirectory, parsedInput.sceneName);
+      const entityIndex = parsedScene.entities.findIndex((candidate) => candidate.name === parsedInput.entityName);
+      if (entityIndex === -1) {
+        throw new Error(`Entity "${parsedInput.entityName}" not found in scene "${parsedInput.sceneName}"`);
+      }
+      parsedScene.entities.splice(entityIndex, 1);
+      const absoluteFilePath = await writeSceneFile(projectDirectory, parsedScene);
+      return formatToolResult4({
+        sceneName: parsedScene.sceneBaseName,
+        deletedEntityName: parsedInput.entityName,
+        filePath: absoluteFilePath
+      });
+    }
+  };
+  const listEntitiesTool = {
+    name: "list_entities",
+    description: "List all entities in a single scene, or across every scene under src/scenes/ when sceneName is omitted.",
+    inputSchema: zodToJsonSchema4(listEntitiesInputSchema),
+    handler: async (input) => {
+      const parsedInput = listEntitiesInputSchema.parse(input ?? {});
+      if (parsedInput.sceneName !== void 0) {
+        const { parsed: parsedScene } = await readSceneFile(projectDirectory, parsedInput.sceneName);
+        return formatToolResult4({
+          entities: parsedScene.entities.map((entity) => ({
+            sceneName: parsedScene.sceneBaseName,
+            ...entity
+          }))
+        });
+      }
+      const scenes = await listSceneFiles(projectDirectory);
+      const entities = scenes.flatMap((scene) => scene.entities.map((entity) => ({
+        sceneName: scene.sceneBaseName,
+        ...entity
+      })));
+      return formatToolResult4({ entities });
+    }
+  };
+  const cloneEntityTool = {
+    name: "clone_entity",
+    description: "Deep-clone an entity within the same scene under a new name. Overrides can replace tags and merge component configs on the clone.",
+    inputSchema: zodToJsonSchema4(cloneEntityInputSchema),
+    handler: async (input) => {
+      const parsedInput = cloneEntityInputSchema.parse(input);
+      const { parsed: parsedScene } = await readSceneFile(projectDirectory, parsedInput.sceneName);
+      const sourceEntity = parsedScene.entities.find((candidate) => candidate.name === parsedInput.sourceEntityName);
+      if (sourceEntity === void 0) {
+        throw new Error(`Source entity "${parsedInput.sourceEntityName}" not found in scene "${parsedInput.sceneName}"`);
+      }
+      if (parsedScene.entities.some((candidate) => candidate.name === parsedInput.newEntityName)) {
+        throw new Error(`Entity "${parsedInput.newEntityName}" already exists in scene "${parsedInput.sceneName}"`);
+      }
+      const clone = deepCloneJson(sourceEntity);
+      clone.name = parsedInput.newEntityName;
+      if (parsedInput.overrides?.tags !== void 0) {
+        clone.tags = parsedInput.overrides.tags;
+      }
+      if (parsedInput.overrides?.componentConfigs !== void 0) {
+        for (const [componentType, config] of Object.entries(parsedInput.overrides.componentConfigs)) {
+          let component = clone.components.find((candidate) => candidate.type === componentType);
+          if (component === void 0) {
+            component = { type: componentType };
+            clone.components.push(component);
+          }
+          component.config = { ...component.config ?? {}, ...config };
+        }
+      }
+      parsedScene.entities.push(clone);
+      const absoluteFilePath = await writeSceneFile(projectDirectory, parsedScene);
+      return formatToolResult4({
+        sceneName: parsedScene.sceneBaseName,
+        entity: clone,
+        filePath: absoluteFilePath
+      });
+    }
+  };
+  context.registerTool(createEntityTool);
+  context.registerTool(getEntityTool);
+  context.registerTool(updateEntityTool);
+  context.registerTool(deleteEntityTool);
+  context.registerTool(listEntitiesTool);
+  context.registerTool(cloneEntityTool);
+}
+
+// ../mcp/dist/tools/entity-scene/project.js
+import fileSystemExtra5 from "fs-extra";
+import { z as z5 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema5 } from "zod-to-json-schema";
+var readProjectConfigInputSchema = z5.object({}).default({});
+var updateProjectConfigInputSchema = z5.object({
+  changes: z5.record(z5.unknown())
+});
+function formatToolResult5(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function registerProjectTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const readProjectConfigTool = {
+    name: "read_project_config",
+    description: "Return the parsed contents of donut.json.",
+    inputSchema: zodToJsonSchema5(readProjectConfigInputSchema),
+    handler: async (input) => {
+      readProjectConfigInputSchema.parse(input ?? {});
+      const manifestPath = resolveWithinProject(projectDirectory, "donut.json");
+      if (!await fileSystemExtra5.pathExists(manifestPath)) {
+        throw new Error(`donut.json not found at ${manifestPath}`);
+      }
+      const raw = await fileSystemExtra5.readFile(manifestPath, "utf8");
+      const config = JSON.parse(raw);
+      return formatToolResult5({ filePath: manifestPath, config });
+    }
+  };
+  const updateProjectConfigTool = {
+    name: "update_project_config",
+    description: "Shallow-merge `changes` into donut.json and write back the result. Top-level keys in `changes` overwrite existing values.",
+    inputSchema: zodToJsonSchema5(updateProjectConfigInputSchema),
+    handler: async (input) => {
+      const parsedInput = updateProjectConfigInputSchema.parse(input);
+      const manifestPath = resolveWithinProject(projectDirectory, "donut.json");
+      if (!await fileSystemExtra5.pathExists(manifestPath)) {
+        throw new Error(`donut.json not found at ${manifestPath}`);
+      }
+      const raw = await fileSystemExtra5.readFile(manifestPath, "utf8");
+      const existing = JSON.parse(raw);
+      const merged = { ...existing, ...parsedInput.changes };
+      await fileSystemExtra5.writeFile(manifestPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+      return formatToolResult5({ filePath: manifestPath, config: merged });
+    }
+  };
+  context.registerTool(readProjectConfigTool);
+  context.registerTool(updateProjectConfigTool);
+}
+
+// ../mcp/dist/tools/entity-scene/scenes.js
+import fileSystemExtra6 from "fs-extra";
+import { z as z6 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema6 } from "zod-to-json-schema";
+var createSceneInputSchema = z6.object({
+  name: z6.string().min(1),
+  systems: z6.array(z6.string().min(1)).optional()
+});
+var readSceneInputSchema = z6.object({ name: z6.string().min(1) });
+var updateSceneInputSchema = z6.object({
+  name: z6.string().min(1),
+  setSystems: z6.array(z6.string().min(1)).optional()
+});
+var deleteSceneInputSchema = z6.object({ name: z6.string().min(1) });
+var listScenesInputSchema = z6.object({}).default({});
+var setActiveSceneInputSchema = z6.object({ name: z6.string().min(1) });
+function formatToolResult6(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function registerSceneTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const createSceneTool = {
+    name: "create_scene",
+    description: "Create a new scene file under src/scenes/ with empty @donut-entities and @donut-systems marker blocks. Fails if the file already exists.",
+    inputSchema: zodToJsonSchema6(createSceneInputSchema),
+    handler: async (input) => {
+      const parsedInput = createSceneInputSchema.parse(input);
+      const { absoluteFilePath, sceneBaseName, sceneClassName, sceneKebabName } = resolveScenePaths(projectDirectory, parsedInput.name);
+      if (await fileSystemExtra6.pathExists(absoluteFilePath)) {
+        throw new Error(`Scene file already exists: ${absoluteFilePath}`);
+      }
+      const parsedScene = {
+        sceneBaseName,
+        sceneClassName,
+        sceneKebabName,
+        entities: [],
+        systems: parsedInput.systems ?? []
+      };
+      const written = await writeSceneFile(projectDirectory, parsedScene);
+      return formatToolResult6({
+        sceneName: sceneBaseName,
+        className: sceneClassName,
+        filePath: written
+      });
+    }
+  };
+  const readSceneTool = {
+    name: "read_scene",
+    description: "Return the current source text of a scene file plus its parsed data.",
+    inputSchema: zodToJsonSchema6(readSceneInputSchema),
+    handler: async (input) => {
+      const parsedInput = readSceneInputSchema.parse(input);
+      const { parsed, absoluteFilePath, source } = await readSceneFile(projectDirectory, parsedInput.name);
+      return formatToolResult6({
+        sceneName: parsed.sceneBaseName,
+        className: parsed.sceneClassName,
+        filePath: absoluteFilePath,
+        source,
+        entities: parsed.entities,
+        systems: parsed.systems
+      });
+    }
+  };
+  const updateSceneTool = {
+    name: "update_scene",
+    description: "Replace the list of systems registered by this scene. Marker block and generated body are both regenerated.",
+    inputSchema: zodToJsonSchema6(updateSceneInputSchema),
+    handler: async (input) => {
+      const parsedInput = updateSceneInputSchema.parse(input);
+      const { parsed } = await readSceneFile(projectDirectory, parsedInput.name);
+      if (parsedInput.setSystems !== void 0) {
+        parsed.systems = parsedInput.setSystems;
+      }
+      const written = await writeSceneFile(projectDirectory, parsed);
+      return formatToolResult6({
+        sceneName: parsed.sceneBaseName,
+        systems: parsed.systems,
+        filePath: written
+      });
+    }
+  };
+  const deleteSceneTool = {
+    name: "delete_scene",
+    description: "Delete a scene file from src/scenes/.",
+    inputSchema: zodToJsonSchema6(deleteSceneInputSchema),
+    handler: async (input) => {
+      const parsedInput = deleteSceneInputSchema.parse(input);
+      const { absoluteFilePath, sceneBaseName } = resolveScenePaths(projectDirectory, parsedInput.name);
+      if (!await fileSystemExtra6.pathExists(absoluteFilePath)) {
+        throw new Error(`Scene file not found: ${absoluteFilePath}`);
+      }
+      await fileSystemExtra6.remove(absoluteFilePath);
+      return formatToolResult6({ sceneName: sceneBaseName, deleted: absoluteFilePath });
+    }
+  };
+  const listScenesTool = {
+    name: "list_scenes",
+    description: "List all scene files found under src/scenes/.",
+    inputSchema: zodToJsonSchema6(listScenesInputSchema),
+    handler: async (input) => {
+      listScenesInputSchema.parse(input ?? {});
+      const scenes = await listSceneFiles(projectDirectory);
+      return formatToolResult6({
+        scenes: scenes.map((scene) => ({
+          name: scene.sceneBaseName,
+          className: scene.sceneClassName,
+          entityCount: scene.entities.length,
+          systems: scene.systems
+        }))
+      });
+    }
+  };
+  const setActiveSceneTool = {
+    name: "set_active_scene",
+    description: "Set the activeScene field in donut.json to the given scene name. Creates the field if missing.",
+    inputSchema: zodToJsonSchema6(setActiveSceneInputSchema),
+    handler: async (input) => {
+      const parsedInput = setActiveSceneInputSchema.parse(input);
+      const { sceneBaseName } = resolveScenePaths(projectDirectory, parsedInput.name);
+      const manifestPath = resolveWithinProject(projectDirectory, "donut.json");
+      if (!await fileSystemExtra6.pathExists(manifestPath)) {
+        throw new Error(`donut.json not found at ${manifestPath}`);
+      }
+      const raw = await fileSystemExtra6.readFile(manifestPath, "utf8");
+      const manifest = JSON.parse(raw);
+      manifest["activeScene"] = sceneBaseName;
+      await fileSystemExtra6.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+      return formatToolResult6({ activeScene: sceneBaseName, filePath: manifestPath });
+    }
+  };
+  context.registerTool(createSceneTool);
+  context.registerTool(readSceneTool);
+  context.registerTool(updateSceneTool);
+  context.registerTool(deleteSceneTool);
+  context.registerTool(listScenesTool);
+  context.registerTool(setActiveSceneTool);
+}
+
+// ../mcp/dist/tools/entity-scene/index.js
+function registerEntitySceneTools(_server, context) {
+  registerEntityTools(context);
+  registerSceneTools(context);
+  registerAssetTools(context);
+  registerProjectTools(context);
+}
+
+// ../mcp/dist/tools/quality/type-check.js
+import path6 from "path";
+import { spawn } from "child_process";
+import { createRequire } from "module";
+import fileSystemExtra7 from "fs-extra";
+import { z as z7 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema7 } from "zod-to-json-schema";
+var compilerOutputOverride;
+function resolveTypeScriptCompiler(projectDirectory) {
+  const projectLocal = path6.join(projectDirectory, "node_modules", "typescript", "bin", "tsc");
+  if (fileSystemExtra7.existsSync(projectLocal)) {
+    return projectLocal;
+  }
+  try {
+    const requireFromHere = createRequire(import.meta.url);
+    const typeScriptPackageJsonPath = requireFromHere.resolve("typescript/package.json");
+    const typeScriptPackageDirectory = path6.dirname(typeScriptPackageJsonPath);
+    const fallback = path6.join(typeScriptPackageDirectory, "bin", "tsc");
+    if (fileSystemExtra7.existsSync(fallback)) {
+      return fallback;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function runProcess(command, argumentList, workingDirectory) {
+  return new Promise((resolve) => {
+    const child = spawn(command, argumentList, {
+      cwd: workingDirectory,
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("close", () => {
+      resolve({ stdout, stderr });
+    });
+    child.on("error", () => {
+      resolve({ stdout, stderr });
+    });
+  });
+}
+async function runTypeScriptCompiler(projectDirectory) {
+  if (compilerOutputOverride !== void 0) {
+    return { output: compilerOutputOverride };
+  }
+  const tsconfigPath = path6.join(projectDirectory, "tsconfig.json");
+  if (!await fileSystemExtra7.pathExists(tsconfigPath)) {
+    return { output: "", skippedReason: "tsconfig.json not found" };
+  }
+  const compilerPath = resolveTypeScriptCompiler(projectDirectory);
+  if (compilerPath === void 0) {
+    return { output: "", skippedReason: "unable to locate the TypeScript compiler" };
+  }
+  const { stdout, stderr } = await runProcess(process.execPath, [compilerPath, "--noEmit", "-p", tsconfigPath], projectDirectory);
+  return { output: `${stdout}
+${stderr}` };
+}
+function parseTypeScriptDiagnostics(output, projectDirectory) {
+  const diagnosticLineRegex = /^([^\s(][^(]*?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/gm;
+  const diagnostics = [];
+  let match;
+  while ((match = diagnosticLineRegex.exec(output)) !== null) {
+    const [, rawFilePath, lineText, columnText, typeScriptCode, messageText] = match;
+    const absoluteFilePath = path6.isAbsolute(rawFilePath) ? rawFilePath : path6.join(projectDirectory, rawFilePath);
+    diagnostics.push({
+      filePath: absoluteFilePath,
+      line: Number.parseInt(lineText, 10),
+      column: Number.parseInt(columnText, 10),
+      message: `${typeScriptCode}: ${messageText.trim()}`,
+      code: typeScriptCode
+    });
+  }
+  return diagnostics;
+}
+var checkTypesFileInputSchema = z7.object({ filePath: z7.string().min(1) });
+var emptyInputSchema = z7.object({}).default({});
+function formatToolResult7(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function registerTypeCheckTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const checkTypesTool = {
+    name: "check_types",
+    description: "Run `tsc --noEmit` against the project and return structured diagnostics for every type error discovered.",
+    inputSchema: zodToJsonSchema7(emptyInputSchema),
+    handler: async (input) => {
+      emptyInputSchema.parse(input ?? {});
+      const { output, skippedReason } = await runTypeScriptCompiler(projectDirectory);
+      const errors = parseTypeScriptDiagnostics(output, projectDirectory);
+      return formatToolResult7({
+        errors,
+        errorCount: errors.length,
+        ...skippedReason !== void 0 ? { skippedReason } : {}
+      });
+    }
+  };
+  const checkTypesFileTool = {
+    name: "check_types_file",
+    description: "Run a project-wide type-check and filter diagnostics down to a single file (preserves tsconfig.json settings for accurate results).",
+    inputSchema: zodToJsonSchema7(checkTypesFileInputSchema),
+    handler: async (input) => {
+      const parsed = checkTypesFileInputSchema.parse(input);
+      const absoluteTargetPath = path6.isAbsolute(parsed.filePath) ? parsed.filePath : path6.resolve(projectDirectory, parsed.filePath);
+      const { output, skippedReason } = await runTypeScriptCompiler(projectDirectory);
+      const allDiagnostics = parseTypeScriptDiagnostics(output, projectDirectory);
+      const errors = allDiagnostics.filter((diagnostic) => path6.resolve(diagnostic.filePath) === path6.resolve(absoluteTargetPath));
+      return formatToolResult7({
+        filePath: absoluteTargetPath,
+        errors,
+        errorCount: errors.length,
+        ...skippedReason !== void 0 ? { skippedReason } : {}
+      });
+    }
+  };
+  context.registerTool(checkTypesTool);
+  context.registerTool(checkTypesFileTool);
+}
+
+// ../mcp/dist/tools/quality/lint.js
+import path7 from "path";
+import fileSystemExtra8 from "fs-extra";
+import { z as z8 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema8 } from "zod-to-json-schema";
+var lintInputSchema = z8.object({ filePath: z8.string().min(1).optional() }).default({});
+var CONFIG_FILE_NAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  ".eslintrc",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.json",
+  ".eslintrc.yaml",
+  ".eslintrc.yml"
+];
+async function hasEslintConfig(projectDirectory) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    if (await fileSystemExtra8.pathExists(path7.join(projectDirectory, fileName))) {
+      return true;
+    }
+  }
+  const packageJsonPath = path7.join(projectDirectory, "package.json");
+  if (await fileSystemExtra8.pathExists(packageJsonPath)) {
+    try {
+      const packageJson = await fileSystemExtra8.readJson(packageJsonPath);
+      if (packageJson && typeof packageJson === "object" && "eslintConfig" in packageJson) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function tryLoadEslint() {
+  try {
+    const moduleName = "eslint";
+    const mod = await import(moduleName);
+    return mod;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeResults(rawResults) {
+  const errors = [];
+  const warnings = [];
+  const results = [];
+  for (const entry of rawResults) {
+    results.push({
+      filePath: entry.filePath,
+      errorCount: entry.errorCount,
+      warningCount: entry.warningCount
+    });
+    for (const message of entry.messages) {
+      const normalized = {
+        filePath: entry.filePath,
+        line: message.line ?? 1,
+        column: message.column ?? 1,
+        ruleId: message.ruleId,
+        message: message.message,
+        severity: message.severity === 2 ? "error" : "warning"
+      };
+      if (normalized.severity === "error") {
+        errors.push(normalized);
+      } else {
+        warnings.push(normalized);
+      }
+    }
+  }
+  return { errors, warnings, results };
+}
+function formatToolResult8(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function resolveLintTargets(projectDirectory, filePath) {
+  if (filePath === void 0) {
+    return [path7.join(projectDirectory, "src")];
+  }
+  const absolute = path7.isAbsolute(filePath) ? filePath : path7.resolve(projectDirectory, filePath);
+  return [absolute];
+}
+function registerLintTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const lintTool = {
+    name: "lint",
+    description: "Run ESLint programmatically against the project (or a single file). Returns structured errors and warnings. If the project has no ESLint configuration or ESLint is not installed, the tool returns a skip warning.",
+    inputSchema: zodToJsonSchema8(lintInputSchema),
+    handler: async (input) => {
+      const parsed = lintInputSchema.parse(input ?? {});
+      if (!await hasEslintConfig(projectDirectory)) {
+        return formatToolResult8({
+          skipped: true,
+          reason: "No ESLint configuration found at the project root",
+          errors: [],
+          warnings: [],
+          results: []
+        });
+      }
+      const eslintModule = await tryLoadEslint();
+      if (eslintModule === void 0) {
+        return formatToolResult8({
+          skipped: true,
+          reason: "ESLint package is not installed",
+          errors: [],
+          warnings: [],
+          results: []
+        });
+      }
+      const eslintInstance = new eslintModule.ESLint({ cwd: projectDirectory });
+      const rawResults = await eslintInstance.lintFiles(resolveLintTargets(projectDirectory, parsed.filePath));
+      const normalized = normalizeResults(rawResults);
+      return formatToolResult8(normalized);
+    }
+  };
+  const lintFixTool = {
+    name: "lint_fix",
+    description: "Run ESLint with auto-fix enabled. Writes fixes to disk and returns the number of auto-fixed messages plus any remaining errors and warnings.",
+    inputSchema: zodToJsonSchema8(lintInputSchema),
+    handler: async (input) => {
+      const parsed = lintInputSchema.parse(input ?? {});
+      if (!await hasEslintConfig(projectDirectory)) {
+        return formatToolResult8({
+          skipped: true,
+          reason: "No ESLint configuration found at the project root",
+          fixed: 0,
+          remainingErrors: [],
+          remainingWarnings: []
+        });
+      }
+      const eslintModule = await tryLoadEslint();
+      if (eslintModule === void 0) {
+        return formatToolResult8({
+          skipped: true,
+          reason: "ESLint package is not installed",
+          fixed: 0,
+          remainingErrors: [],
+          remainingWarnings: []
+        });
+      }
+      const eslintInstance = new eslintModule.ESLint({
+        cwd: projectDirectory,
+        fix: true
+      });
+      const rawResults = await eslintInstance.lintFiles(resolveLintTargets(projectDirectory, parsed.filePath));
+      let fixed = 0;
+      for (const result of rawResults) {
+        if (typeof result.output === "string") {
+          await fileSystemExtra8.writeFile(result.filePath, result.output, "utf8");
+          fixed += 1;
+        }
+      }
+      const normalized = normalizeResults(rawResults);
+      return formatToolResult8({
+        fixed,
+        remainingErrors: normalized.errors,
+        remainingWarnings: normalized.warnings
+      });
+    }
+  };
+  context.registerTool(lintTool);
+  context.registerTool(lintFixTool);
+}
+
+// ../mcp/dist/tools/quality/imports-world.js
+import { z as z9 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema9 } from "zod-to-json-schema";
+
+// ../cli/src/commands/validate.ts
+import path8 from "path";
+import { spawn as spawn2 } from "child_process";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath } from "url";
+import fileSystemExtra9 from "fs-extra";
+var REQUIRED_MANIFEST_FIELDS = ["name", "version", "rendererTarget", "donutEngineVersion"];
+var ALLOWED_RENDERER_TARGETS = /* @__PURE__ */ new Set(["pixi-2d", "three-3d"]);
+var GAME_LOGIC_FORBIDDEN_RENDERER_IMPORT_PREFIXES = [
+  "@donut-games/engine/pixi",
+  "@donut-games/engine/three",
+  "@donut/pixi",
+  "@donut/three"
+];
+var WRONG_RENDERER_FORBIDDEN_IMPORT_BY_TARGET = {
+  "pixi-2d": "@donut-games/engine/three",
+  "three-3d": "@donut-games/engine/pixi"
+};
+var WRONG_RENDERER_ALLOWED_IMPORT_BY_TARGET = {
+  "pixi-2d": "@donut-games/engine/pixi",
+  "three-3d": "@donut-games/engine/three"
+};
+async function runValidation(options) {
+  const { projectDirectory } = options;
+  const errors = [];
+  const warnings = [];
+  const parsedManifest = await validateManifest(projectDirectory, errors);
+  if (options.skipTypeCheck !== true) {
+    await validateTypes(projectDirectory, errors);
+  }
+  const rendererTarget = parsedManifest?.rendererTarget;
+  await validateImportGraph(projectDirectory, rendererTarget, errors);
+  await validateAssetReferences(projectDirectory, errors);
+  return { errors, warnings };
+}
+async function validateManifest(projectDirectory, errors) {
+  const manifestPath = path8.join(projectDirectory, "donut.json");
+  if (!await fileSystemExtra9.pathExists(manifestPath)) {
+    errors.push({
+      filePath: manifestPath,
+      message: "donut.json is missing at the project root",
+      code: "MANIFEST_INVALID"
+    });
+    return null;
+  }
+  let raw;
+  try {
+    raw = await fileSystemExtra9.readFile(manifestPath, "utf8");
+  } catch (readError) {
+    errors.push({
+      filePath: manifestPath,
+      message: `Unable to read donut.json: ${readError.message}`,
+      code: "MANIFEST_INVALID"
+    });
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (parseError) {
+    errors.push({
+      filePath: manifestPath,
+      message: `donut.json is not valid JSON: ${parseError.message}`,
+      code: "MANIFEST_INVALID"
+    });
+    return null;
+  }
+  let hasRequiredFieldError = false;
+  for (const fieldName of REQUIRED_MANIFEST_FIELDS) {
+    const value = parsed[fieldName];
+    if (typeof value !== "string" || value.trim().length === 0) {
+      errors.push({
+        filePath: manifestPath,
+        message: `donut.json missing required string field "${fieldName}"`,
+        code: "MANIFEST_INVALID"
+      });
+      hasRequiredFieldError = true;
+    }
+  }
+  const rendererTargetValue = parsed.rendererTarget;
+  if (typeof rendererTargetValue === "string" && !ALLOWED_RENDERER_TARGETS.has(rendererTargetValue)) {
+    errors.push({
+      filePath: manifestPath,
+      message: `donut.json "rendererTarget" must be one of pixi-2d, three-3d (got "${rendererTargetValue}")`,
+      code: "MANIFEST_INVALID"
+    });
+  }
+  if (hasRequiredFieldError) {
+    return null;
+  }
+  return {
+    name: parsed.name,
+    version: parsed.version,
+    rendererTarget: parsed.rendererTarget,
+    donutEngineVersion: parsed.donutEngineVersion
+  };
+}
+async function validateTypes(projectDirectory, errors) {
+  const tsconfigPath = path8.join(projectDirectory, "tsconfig.json");
+  if (!await fileSystemExtra9.pathExists(tsconfigPath)) {
+    return;
+  }
+  const typeScriptCompilerPath = resolveTypeScriptCompiler2(projectDirectory);
+  if (typeScriptCompilerPath === void 0) {
+    errors.push({
+      filePath: tsconfigPath,
+      message: "Unable to locate a TypeScript compiler (tsc) to run the type-check",
+      code: "TYPE_ERROR"
+    });
+    return;
+  }
+  const { stdout, stderr } = await runProcess2(
+    process.execPath,
+    [typeScriptCompilerPath, "--noEmit", "-p", tsconfigPath],
+    projectDirectory
+  );
+  const combined = `${stdout}
+${stderr}`;
+  const diagnosticLineRegex = /^([^\s(][^(]*?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/gm;
+  let match;
+  while ((match = diagnosticLineRegex.exec(combined)) !== null) {
+    const [, rawFilePath, lineText, columnText, typeScriptCode, messageText] = match;
+    const absoluteFilePath = path8.isAbsolute(rawFilePath) ? rawFilePath : path8.join(projectDirectory, rawFilePath);
+    errors.push({
+      filePath: absoluteFilePath,
+      line: Number.parseInt(lineText, 10),
+      column: Number.parseInt(columnText, 10),
+      message: `${typeScriptCode}: ${messageText.trim()}`,
+      code: "TYPE_ERROR"
+    });
+  }
+}
+function resolveTypeScriptCompiler2(projectDirectory) {
+  const projectLocal = path8.join(
+    projectDirectory,
+    "node_modules",
+    "typescript",
+    "bin",
+    "tsc"
+  );
+  if (fileSystemExtra9.existsSync(projectLocal)) {
+    return projectLocal;
+  }
+  try {
+    const requireFromHere = createRequire2(import.meta.url);
+    const typeScriptPackageJsonPath = requireFromHere.resolve("typescript/package.json");
+    const typeScriptPackageDirectory = path8.dirname(typeScriptPackageJsonPath);
+    const fallback = path8.join(typeScriptPackageDirectory, "bin", "tsc");
+    if (fileSystemExtra9.existsSync(fallback)) {
+      return fallback;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function runProcess2(command, argumentList, workingDirectory) {
+  return new Promise((resolve) => {
+    const child = spawn2(command, argumentList, {
+      cwd: workingDirectory,
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("close", (exitCode) => {
+      resolve({ stdout, stderr, exitCode });
+    });
+    child.on("error", () => {
+      resolve({ stdout, stderr, exitCode: null });
+    });
+  });
+}
+async function validateImportGraph(projectDirectory, rendererTarget, errors) {
+  await validateGameLogicImports(projectDirectory, errors);
+  await validateWrongRendererImports(projectDirectory, rendererTarget, errors);
+}
+async function validateGameLogicImports(projectDirectory, errors) {
+  const gameLogicDirectories = [
+    path8.join(projectDirectory, "src", "components"),
+    path8.join(projectDirectory, "src", "systems")
+  ];
+  const importLineRegex = /^\s*import\s+[^;]*?from\s+['"]([^'"]+)['"]/;
+  for (const directoryPath of gameLogicDirectories) {
+    if (!await fileSystemExtra9.pathExists(directoryPath)) {
+      continue;
+    }
+    const typeScriptFiles = await collectTypeScriptFiles3(directoryPath);
+    for (const filePath of typeScriptFiles) {
+      const contents = await fileSystemExtra9.readFile(filePath, "utf8");
+      const lines = contents.split(/\r?\n/);
+      for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const lineText = lines[lineIndex];
+        const matched = importLineRegex.exec(lineText);
+        if (matched === null) {
+          continue;
+        }
+        const importedSpecifier = matched[1];
+        if (GAME_LOGIC_FORBIDDEN_RENDERER_IMPORT_PREFIXES.some(
+          (disallowedPrefix) => importedSpecifier === disallowedPrefix || importedSpecifier.startsWith(`${disallowedPrefix}/`)
+        )) {
+          errors.push({
+            filePath,
+            line: lineIndex + 1,
+            message: `Renderer import "${importedSpecifier}" is not allowed in game logic (components/systems must only import @donut-games/engine/core, @donut-games/engine/math, or relative paths)`,
+            code: "RENDERER_IMPORT_IN_GAME_LOGIC"
+          });
+        }
+      }
+    }
+  }
+}
+async function validateWrongRendererImports(projectDirectory, rendererTarget, errors) {
+  if (rendererTarget === void 0) {
+    return;
+  }
+  const wrongRendererImportSpecifierPrefix = WRONG_RENDERER_FORBIDDEN_IMPORT_BY_TARGET[rendererTarget];
+  const allowedRendererImportSpecifierPrefix = WRONG_RENDERER_ALLOWED_IMPORT_BY_TARGET[rendererTarget];
+  if (wrongRendererImportSpecifierPrefix === void 0 || allowedRendererImportSpecifierPrefix === void 0) {
+    return;
+  }
+  const sourceRoot = path8.join(projectDirectory, "src");
+  if (!await fileSystemExtra9.pathExists(sourceRoot)) {
+    return;
+  }
+  const importLineRegex = /^\s*import\s+[^;]*?from\s+['"]([^'"]+)['"]/;
+  const typeScriptFiles = await collectTypeScriptFiles3(sourceRoot);
+  for (const filePath of typeScriptFiles) {
+    const contents = await fileSystemExtra9.readFile(filePath, "utf8");
+    const lines = contents.split(/\r?\n/);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+      const lineText = lines[lineIndex];
+      const matched = importLineRegex.exec(lineText);
+      if (matched === null) {
+        continue;
+      }
+      const importedSpecifier = matched[1];
+      if (importedSpecifier === wrongRendererImportSpecifierPrefix || importedSpecifier.startsWith(`${wrongRendererImportSpecifierPrefix}/`)) {
+        errors.push({
+          filePath,
+          line: lineIndex + 1,
+          message: `Renderer import "${importedSpecifier}" is not allowed in a "${rendererTarget}" project. This project's donut.json specifies rendererTarget: "${rendererTarget}", which only permits ${allowedRendererImportSpecifierPrefix} for renderer-specific code.`,
+          code: "WRONG_RENDERER_IMPORT"
+        });
+      }
+    }
+  }
+}
+async function collectTypeScriptFiles3(directoryPath) {
+  const collected = [];
+  const entries = await fileSystemExtra9.readdir(directoryPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path8.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      collected.push(...await collectTypeScriptFiles3(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      collected.push(entryPath);
+    }
+  }
+  return collected;
+}
+async function validateAssetReferences(projectDirectory, errors) {
+  const sourceRoot = path8.join(projectDirectory, "src");
+  const assetsRoot = path8.join(projectDirectory, "assets");
+  if (!await fileSystemExtra9.pathExists(sourceRoot)) {
+    return;
+  }
+  const typeScriptFiles = await collectTypeScriptFiles3(sourceRoot);
+  const texturePathRegex = /texturePath\s*(?::[^='"]*)?=?\s*['"]([^'"]*)['"]/g;
+  const assetsLiteralRegex = /['"]assets\/([^'"]+)['"]/g;
+  for (const filePath of typeScriptFiles) {
+    const contents = await fileSystemExtra9.readFile(filePath, "utf8");
+    const lines = contents.split(/\r?\n/);
+    const referencedAssets = [];
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+      const lineText = lines[lineIndex];
+      texturePathRegex.lastIndex = 0;
+      let textureMatch;
+      while ((textureMatch = texturePathRegex.exec(lineText)) !== null) {
+        const referenced = textureMatch[1];
+        if (referenced.length === 0) {
+          continue;
+        }
+        referencedAssets.push({ relativePath: referenced, line: lineIndex + 1 });
+      }
+      assetsLiteralRegex.lastIndex = 0;
+      let assetsMatch;
+      while ((assetsMatch = assetsLiteralRegex.exec(lineText)) !== null) {
+        referencedAssets.push({
+          relativePath: assetsMatch[1],
+          line: lineIndex + 1
+        });
+      }
+    }
+    for (const { relativePath, line } of referencedAssets) {
+      const normalized = relativePath.startsWith("assets/") ? relativePath.slice("assets/".length) : relativePath;
+      const absoluteAssetPath = path8.join(assetsRoot, normalized);
+      if (!await fileSystemExtra9.pathExists(absoluteAssetPath)) {
+        errors.push({
+          filePath,
+          line,
+          message: `Referenced asset "${relativePath}" not found under assets/`,
+          code: "MISSING_ASSET"
+        });
+      }
+    }
+  }
+}
+
+// ../mcp/dist/tools/quality/imports-world.js
+var emptyInputSchema2 = z9.object({}).default({});
+function formatToolResult9(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function registerImportsAndWorldTools(context) {
+  const projectDirectory = context.projectDirectory;
+  const checkImportsTool = {
+    name: "check_imports",
+    description: "Scan src/components and src/systems for renderer imports that break the game-logic portability contract. Returns findings with the RENDERER_IMPORT_IN_GAME_LOGIC code.",
+    inputSchema: zodToJsonSchema9(emptyInputSchema2),
+    handler: async (input) => {
+      emptyInputSchema2.parse(input ?? {});
+      const report = await runValidation({
+        projectDirectory,
+        skipTypeCheck: true
+      });
+      const findings = report.errors.filter((error) => error.code === "RENDERER_IMPORT_IN_GAME_LOGIC");
+      return formatToolResult9({
+        findings,
+        findingCount: findings.length
+      });
+    }
+  };
+  const validateWorldTool = {
+    name: "validate_world",
+    description: "Run the full project validation pipeline (manifest, types, imports, asset references) via @donut/cli and return the complete report grouped by error code.",
+    inputSchema: zodToJsonSchema9(z9.object({ skipTypeCheck: z9.boolean().optional() }).default({})),
+    handler: async (input) => {
+      const parsed = z9.object({ skipTypeCheck: z9.boolean().optional() }).default({}).parse(input ?? {});
+      const report = await runValidation({
+        projectDirectory,
+        ...parsed.skipTypeCheck !== void 0 ? { skipTypeCheck: parsed.skipTypeCheck } : {}
+      });
+      const groupByCode = (findings) => {
+        const grouped = {};
+        for (const finding of findings) {
+          const bucket = grouped[finding.code] ?? [];
+          bucket.push(finding);
+          grouped[finding.code] = bucket;
+        }
+        return grouped;
+      };
+      return formatToolResult9({
+        errors: report.errors,
+        warnings: report.warnings,
+        errorsByCode: groupByCode(report.errors),
+        warningsByCode: groupByCode(report.warnings),
+        errorCount: report.errors.length,
+        warningCount: report.warnings.length
+      });
+    }
+  };
+  context.registerTool(checkImportsTool);
+  context.registerTool(validateWorldTool);
+}
+
+// ../mcp/dist/tools/quality/index.js
+function registerQualityTools(_server, context) {
+  registerTypeCheckTools(context);
+  registerLintTools(context);
+  registerImportsAndWorldTools(context);
+}
+
+// ../mcp/dist/tools/runtime/tools.js
+import { z as z10 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema10 } from "zod-to-json-schema";
+
+// ../mcp/dist/tools/runtime/runtime-session.js
+import { spawn as spawn3 } from "child_process";
+import fileSystem from "fs";
+import path9 from "path";
+var currentSession;
+async function defaultLaunchBrowser() {
+  const playwright = await import("playwright");
+  const browser = await playwright.chromium.launch({ headless: true });
+  const page = await browser.newPage();
+  return { browser, page };
+}
+function detectMonorepoRoot(startDirectory) {
+  let currentDirectory = path9.resolve(startDirectory);
+  for (let depth = 0; depth < 8; depth++) {
+    if (fileSystem.existsSync(path9.join(currentDirectory, "pnpm-workspace.yaml"))) {
+      return currentDirectory;
+    }
+    const parentDirectory = path9.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return void 0;
+    }
+    currentDirectory = parentDirectory;
+  }
+  return void 0;
+}
+async function startRuntimeSession(options) {
+  if (currentSession !== void 0) {
+    throw new Error("Runtime session is already running; call stop_game first.");
+  }
+  const monorepoRoot = detectMonorepoRoot(options.projectDirectory);
+  const cliDistEntry = monorepoRoot !== void 0 ? path9.join(monorepoRoot, "packages", "cli", "dist", "index.js") : void 0;
+  const cliSourceEntry = monorepoRoot !== void 0 ? path9.join(monorepoRoot, "packages", "cli", "src", "index.ts") : void 0;
+  let childProcess;
+  if (cliDistEntry !== void 0 && fileSystem.existsSync(cliDistEntry)) {
+    childProcess = spawn3("node", [cliDistEntry, "dev", "--no-open", "--port", String(options.port)], { cwd: options.projectDirectory, stdio: ["ignore", "pipe", "pipe"] });
+  } else if (cliSourceEntry !== void 0) {
+    childProcess = spawn3("node", [
+      "--import",
+      "tsx",
+      cliSourceEntry,
+      "dev",
+      "--no-open",
+      "--port",
+      String(options.port)
+    ], { cwd: monorepoRoot, stdio: ["ignore", "pipe", "pipe"] });
+  } else {
+    childProcess = spawn3("donut", ["dev", "--no-open", "--port", String(options.port)], { cwd: options.projectDirectory, stdio: ["ignore", "pipe", "pipe"] });
+  }
+  const url = await new Promise((resolvePromise, rejectPromise) => {
+    const timeoutHandle = setTimeout(() => {
+      rejectPromise(new Error("Timed out waiting for dev server to start (20s)."));
+    }, 2e4);
+    const handleData = (chunk) => {
+      const text = chunk.toString();
+      const match = text.match(/Dev server ready at (https?:\/\/[^\s]+)/);
+      if (match !== null && match[1] !== void 0) {
+        clearTimeout(timeoutHandle);
+        resolvePromise(match[1].replace(/\/$/, ""));
+      }
+    };
+    childProcess.stdout?.on("data", handleData);
+    childProcess.stderr?.on("data", handleData);
+    childProcess.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      rejectPromise(error);
+    });
+    childProcess.on("exit", (code) => {
+      clearTimeout(timeoutHandle);
+      rejectPromise(new Error(`Dev server exited before becoming ready (code ${code}).`));
+    });
+  });
+  const launchBrowser = options.launchBrowser ?? defaultLaunchBrowser;
+  const { browser, page } = await launchBrowser();
+  await page.goto(url);
+  const session = {
+    url,
+    pid: childProcess.pid ?? -1,
+    process: childProcess,
+    browser,
+    page
+  };
+  currentSession = session;
+  return session;
+}
+async function stopRuntimeSession() {
+  const session = currentSession;
+  if (session === void 0) {
+    return false;
+  }
+  currentSession = void 0;
+  try {
+    await session.browser.close();
+  } catch {
+  }
+  if (!session.process.killed) {
+    session.process.kill("SIGTERM");
+  }
+  return true;
+}
+function requireRuntimeSession() {
+  const session = currentSession;
+  if (session === void 0) {
+    throw new Error("No runtime session is running. Call start_game first.");
+  }
+  return session;
+}
+
+// ../mcp/dist/tools/runtime/tools.js
+var startGameInputSchema = z10.object({
+  port: z10.number().int().positive().max(65535).default(5173)
+});
+var restartGameInputSchema = z10.object({
+  port: z10.number().int().positive().max(65535).default(5173)
+});
+var emptyInputSchema3 = z10.object({}).default({});
+var takeScreenshotAfterInputSchema = z10.object({
+  delayMilliseconds: z10.number().int().nonnegative().max(6e4)
+});
+var readConsoleLogsInputSchema = z10.object({
+  count: z10.number().int().positive().max(200).default(50),
+  level: z10.enum(["log", "warn", "error"]).optional()
+});
+var sendInputActionInputSchema = z10.union([
+  z10.object({
+    actionName: z10.string().min(1),
+    value: z10.number().default(1)
+  }),
+  z10.object({
+    actionName: z10.string().min(1),
+    phase: z10.enum(["start", "end"]),
+    value: z10.number().default(1)
+  })
+]);
+var getEntityStateInputSchema = z10.object({ entityName: z10.string().min(1) });
+function formatTextResult(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+function delay(milliseconds) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+function buildStartGameTool(context) {
+  return {
+    name: "start_game",
+    description: "Spawn the Donut dev server as a child process and open a headless browser pointed at it. Fails if a session is already running.",
+    inputSchema: zodToJsonSchema10(startGameInputSchema),
+    handler: async (input) => {
+      const parsed = startGameInputSchema.parse(input ?? {});
+      const session = await startRuntimeSession({
+        projectDirectory: context.projectDirectory,
+        port: parsed.port
+      });
+      return formatTextResult({ url: session.url, pid: session.pid });
+    }
+  };
+}
+function buildStopGameTool() {
+  return {
+    name: "stop_game",
+    description: "Close the headless browser and terminate the dev server process.",
+    inputSchema: zodToJsonSchema10(emptyInputSchema3),
+    handler: async () => {
+      const stopped = await stopRuntimeSession();
+      return formatTextResult({ stopped });
+    }
+  };
+}
+function buildRestartGameTool(context) {
+  return {
+    name: "restart_game",
+    description: "Stop any running dev session, then start a fresh one.",
+    inputSchema: zodToJsonSchema10(restartGameInputSchema),
+    handler: async (input) => {
+      const parsed = restartGameInputSchema.parse(input ?? {});
+      await stopRuntimeSession();
+      const session = await startRuntimeSession({
+        projectDirectory: context.projectDirectory,
+        port: parsed.port
+      });
+      return formatTextResult({ url: session.url, pid: session.pid });
+    }
+  };
+}
+function buildTakeScreenshotTool() {
+  return {
+    name: "take_screenshot",
+    description: "Capture the contents of the #game-canvas element as a base64 PNG. Requires a running runtime session.",
+    inputSchema: zodToJsonSchema10(emptyInputSchema3),
+    handler: async () => {
+      const session = requireRuntimeSession();
+      const buffer = await session.page.locator("#game-canvas").screenshot();
+      const base64 = buffer.toString("base64");
+      return {
+        content: [{ type: "image", data: base64, mimeType: "image/png" }]
+      };
+    }
+  };
+}
+function buildTakeScreenshotAfterTool() {
+  return {
+    name: "take_screenshot_after",
+    description: "Wait `delayMilliseconds`, then capture a screenshot of #game-canvas.",
+    inputSchema: zodToJsonSchema10(takeScreenshotAfterInputSchema),
+    handler: async (input) => {
+      const parsed = takeScreenshotAfterInputSchema.parse(input);
+      const session = requireRuntimeSession();
+      await delay(parsed.delayMilliseconds);
+      const buffer = await session.page.locator("#game-canvas").screenshot();
+      const base64 = buffer.toString("base64");
+      return {
+        content: [{ type: "image", data: base64, mimeType: "image/png" }]
+      };
+    }
+  };
+}
+function buildReadConsoleLogsTool() {
+  return {
+    name: "read_console_logs",
+    description: "Return the most recent console entries captured by the runtime bridge, optionally filtered by level.",
+    inputSchema: zodToJsonSchema10(readConsoleLogsInputSchema),
+    handler: async (input) => {
+      const parsed = readConsoleLogsInputSchema.parse(input ?? {});
+      const session = requireRuntimeSession();
+      const buffer = await session.page.evaluate((() => {
+        const runtime = window.__donutRuntime;
+        return runtime?.consoleBuffer ?? [];
+      }));
+      const filtered = parsed.level === void 0 ? buffer : buffer.filter((entry) => entry.level === parsed.level);
+      const tail = filtered.slice(Math.max(0, filtered.length - parsed.count));
+      return formatTextResult({ entries: tail });
+    }
+  };
+}
+function buildReadPerformanceMetricsTool() {
+  return {
+    name: "read_performance_metrics",
+    description: "Return live FPS, last-frame duration, entity count, and per-system update timings captured by the runtime bridge.",
+    inputSchema: zodToJsonSchema10(emptyInputSchema3),
+    handler: async () => {
+      const session = requireRuntimeSession();
+      const metrics = await session.page.evaluate((() => {
+        const runtime = window.__donutRuntime;
+        if (runtime === void 0) {
+          return {
+            fps: 0,
+            frameTimeMilliseconds: 0,
+            entityCount: 0,
+            systemTimings: {}
+          };
+        }
+        return runtime.getMetrics();
+      }));
+      return formatTextResult(metrics);
+    }
+  };
+}
+function buildSendInputActionTool() {
+  return {
+    name: "send_input_action",
+    description: "Dispatch a synthetic CTRLLR action to the running game. Without a `phase`, sends a start event and an end event one frame later. With a `phase`, dispatches just that single event.",
+    inputSchema: zodToJsonSchema10(sendInputActionInputSchema),
+    handler: async (input) => {
+      const parsed = sendInputActionInputSchema.parse(input);
+      const session = requireRuntimeSession();
+      await session.page.evaluate(((argument) => {
+        const runtime = window.__donutRuntime;
+        runtime?.triggerAction(argument.actionName, argument.value, argument.phase);
+      }), {
+        actionName: parsed.actionName,
+        value: parsed.value,
+        phase: "phase" in parsed ? parsed.phase : void 0
+      });
+      return formatTextResult({ dispatched: parsed.actionName });
+    }
+  };
+}
+function buildGetEntityStateTool() {
+  return {
+    name: "get_entity_state",
+    description: "Look up an entity by name and return its tags plus each component serialized via `Component.serialize()`.",
+    inputSchema: zodToJsonSchema10(getEntityStateInputSchema),
+    handler: async (input) => {
+      const parsed = getEntityStateInputSchema.parse(input);
+      const session = requireRuntimeSession();
+      const state = await session.page.evaluate(((entityName) => {
+        const runtime = window.__donutRuntime;
+        return runtime?.getEntityState(entityName);
+      }), parsed.entityName);
+      if (state === void 0 || state === null) {
+        throw new Error(`Entity not found: ${parsed.entityName}`);
+      }
+      return formatTextResult(state);
+    }
+  };
+}
+function buildListActiveEntitiesTool() {
+  return {
+    name: "list_active_entities",
+    description: "List every entity currently in the world, with identifier, name, tags, and component type names.",
+    inputSchema: zodToJsonSchema10(emptyInputSchema3),
+    handler: async () => {
+      const session = requireRuntimeSession();
+      const entities = await session.page.evaluate((() => {
+        const runtime = window.__donutRuntime;
+        return runtime?.getEntities() ?? [];
+      }));
+      return formatTextResult({ entities });
+    }
+  };
+}
+function registerRuntimeControlTools(context) {
+  context.registerTool(buildStartGameTool(context));
+  context.registerTool(buildStopGameTool());
+  context.registerTool(buildRestartGameTool(context));
+  context.registerTool(buildTakeScreenshotTool());
+  context.registerTool(buildTakeScreenshotAfterTool());
+  context.registerTool(buildReadConsoleLogsTool());
+  context.registerTool(buildReadPerformanceMetricsTool());
+  context.registerTool(buildSendInputActionTool());
+  context.registerTool(buildGetEntityStateTool());
+  context.registerTool(buildListActiveEntitiesTool());
+}
+
+// ../mcp/dist/tools/runtime/index.js
+function registerRuntimeTools(_server, context) {
+  registerRuntimeControlTools(context);
+}
+
+// ../mcp/dist/index.js
+async function startMcpServer() {
+  const projectDirectory = path10.resolve(process.env["DONUT_PROJECT_DIRECTORY"] ?? process.cwd());
+  const registeredTools = [];
+  const toolContext = {
+    projectDirectory,
+    registerTool(definition) {
+      const alreadyRegistered = registeredTools.some((existing) => existing.name === definition.name);
+      if (alreadyRegistered) {
+        throw new Error(`Duplicate MCP tool registration: ${definition.name}`);
+      }
+      registeredTools.push(definition);
+    }
+  };
+  const server = new Server({ name: "donut-mcp", version: "0.0.1" }, { capabilities: { tools: {} } });
+  registerComponentSystemTools(server, toolContext);
+  registerEntitySceneTools(server, toolContext);
+  registerQualityTools(server, toolContext);
+  registerRuntimeTools(server, toolContext);
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: registeredTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }))
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const tool = registeredTools.find((candidate) => candidate.name === toolName);
+    if (tool === void 0) {
+      throw new Error(`Unknown tool: ${toolName}`);
+    }
+    return tool.handler(request.params.arguments ?? {});
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var isRunningAsMain = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("/donut-mcp") === true || process.argv[1]?.endsWith("\\donut-mcp") === true || process.argv[1]?.endsWith("mcp/src/index.ts") === true || process.argv[1]?.endsWith("mcp/dist/index.js") === true;
+if (isRunningAsMain) {
+  startMcpServer().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+// src/donut-mcp.ts
+startMcpServer().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+//# sourceMappingURL=donut-mcp.js.map