@donut-games/cli 0.1.0

package/dist/donut.js

@@ -0,0 +1,1724 @@
+#!/usr/bin/env node
+
+// ../cli/dist/index.js
+import path9 from "path";
+import { Command } from "commander";
+import chalk6 from "chalk";
+
+// ../cli/dist/commands/init.js
+import path2 from "path";
+import { spawn } from "child_process";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import fileSystemExtra2 from "fs-extra";
+import chalk from "chalk";
+
+// ../cli/dist/commands/template-copier.js
+import path from "path";
+import fileSystemExtra from "fs-extra";
+var TEMPLATE_FILE_SUFFIX = ".tpl";
+async function copyTemplate(options) {
+  const { sourceDirectory, destinationDirectory, variant, tokens, logProgress } = options;
+  await fileSystemExtra.ensureDir(destinationDirectory);
+  const writtenFilesInOrder = [];
+  const seenRelativePaths = /* @__PURE__ */ new Set();
+  const recordWrite = (relativePath) => {
+    if (seenRelativePaths.has(relativePath)) {
+      return;
+    }
+    seenRelativePaths.add(relativePath);
+    writtenFilesInOrder.push(relativePath);
+  };
+  const copyLayer = async (layerDirectory) => {
+    if (await fileSystemExtra.pathExists(layerDirectory) === false) {
+      return;
+    }
+    const layerEntries = await collectFilesRecursively(layerDirectory);
+    for (const sourceRelativePath of layerEntries) {
+      const destinationRelativePath = applyRenameRulesToPath(sourceRelativePath);
+      const absoluteSourcePath = path.join(layerDirectory, sourceRelativePath);
+      const absoluteDestinationPath = path.join(destinationDirectory, destinationRelativePath);
+      await fileSystemExtra.ensureDir(path.dirname(absoluteDestinationPath));
+      if (destinationRelativePath.endsWith(TEMPLATE_FILE_SUFFIX)) {
+        throw new Error(`Template suffix was not stripped for ${destinationRelativePath}`);
+      }
+      if (sourceRelativePath.endsWith(TEMPLATE_FILE_SUFFIX)) {
+        const rawContents = await fileSystemExtra.readFile(absoluteSourcePath, "utf8");
+        const renderedContents = renderTemplate(rawContents, tokens);
+        await fileSystemExtra.writeFile(absoluteDestinationPath, renderedContents, "utf8");
+      } else {
+        await fileSystemExtra.copyFile(absoluteSourcePath, absoluteDestinationPath);
+      }
+      recordWrite(destinationRelativePath);
+      if (logProgress !== void 0) {
+        logProgress(destinationRelativePath);
+      }
+    }
+  };
+  await copyLayer(path.join(sourceDirectory, "base"));
+  await copyLayer(path.join(sourceDirectory, variant));
+  return { createdFiles: writtenFilesInOrder };
+}
+function applyRenameRules(fileName) {
+  if (fileName.length > 0 && fileName.startsWith("_")) {
+    return "." + fileName.slice(1);
+  }
+  return fileName;
+}
+function renderTemplate(contents, tokens) {
+  let rendered = contents;
+  const orderedTokenNames = [
+    "projectName",
+    "rendererTarget",
+    "donutEngineVersion",
+    "pixiVersion",
+    "threeVersion"
+  ];
+  for (const tokenName of orderedTokenNames) {
+    const placeholder = "{{" + tokenName + "}}";
+    const tokenValue = tokens[tokenName];
+    rendered = rendered.split(placeholder).join(tokenValue);
+  }
+  return rendered;
+}
+function applyRenameRulesToPath(relativePath) {
+  const segments = relativePath.split(path.sep);
+  const renamedSegments = segments.map((segment) => applyRenameRules(segment));
+  const lastSegmentIndex = renamedSegments.length - 1;
+  const lastSegment = renamedSegments[lastSegmentIndex];
+  if (lastSegment.endsWith(TEMPLATE_FILE_SUFFIX)) {
+    renamedSegments[lastSegmentIndex] = lastSegment.slice(0, lastSegment.length - TEMPLATE_FILE_SUFFIX.length);
+  }
+  return renamedSegments.join(path.sep);
+}
+async function collectFilesRecursively(rootDirectory) {
+  const collectedPaths = [];
+  const walkDirectory = async (absoluteDirectory) => {
+    const directoryEntries = await fileSystemExtra.readdir(absoluteDirectory, {
+      withFileTypes: true
+    });
+    for (const directoryEntry of directoryEntries) {
+      const absoluteEntryPath = path.join(absoluteDirectory, directoryEntry.name);
+      if (directoryEntry.isDirectory()) {
+        await walkDirectory(absoluteEntryPath);
+        continue;
+      }
+      if (directoryEntry.isFile()) {
+        const relativePath = path.relative(rootDirectory, absoluteEntryPath);
+        collectedPaths.push(relativePath);
+      }
+    }
+  };
+  await walkDirectory(rootDirectory);
+  collectedPaths.sort();
+  return collectedPaths;
+}
+
+// ../cli/dist/commands/init.js
+var DEFAULT_DONUT_ENGINE_VERSION = "0.1.0";
+var DEFAULT_PIXI_VERSION = "0.1.0";
+var DEFAULT_THREE_VERSION = "0.1.0";
+async function initializeProject(options) {
+  const { projectName, rendererTarget } = options;
+  const log = options.log ?? ((message) => console.log(message));
+  const absoluteDirectory = path2.resolve(options.targetDirectory);
+  if (await fileSystemExtra2.pathExists(absoluteDirectory)) {
+    const existingEntries = await fileSystemExtra2.readdir(absoluteDirectory);
+    if (existingEntries.length > 0) {
+      throw new Error(`Target directory "${absoluteDirectory}" already exists and is not empty.`);
+    }
+  }
+  await fileSystemExtra2.ensureDir(absoluteDirectory);
+  log(chalk.cyan(`Scaffolding "${projectName}" (${rendererTarget}) at ${absoluteDirectory}`));
+  const templateSourceDirectory = await resolveTemplateDirectory();
+  const templateTokens = {
+    projectName,
+    rendererTarget,
+    donutEngineVersion: DEFAULT_DONUT_ENGINE_VERSION,
+    pixiVersion: DEFAULT_PIXI_VERSION,
+    threeVersion: DEFAULT_THREE_VERSION
+  };
+  const copyResult = await copyTemplate({
+    sourceDirectory: templateSourceDirectory,
+    destinationDirectory: absoluteDirectory,
+    variant: rendererTarget,
+    tokens: templateTokens,
+    logProgress: (relativePath) => {
+      log(chalk.green(`  created  ${relativePath}`));
+    }
+  });
+  if (options.skipInstall !== true) {
+    await runDependencyInstall(absoluteDirectory, log);
+  }
+  log(chalk.cyan(`
+Done. Next steps:`));
+  log(chalk.white(`  cd ${projectName}`));
+  if (options.skipInstall === true) {
+    log(chalk.white(`  npm install`));
+  }
+  log(chalk.white(`  npm run dev`));
+  return { absoluteDirectory, createdFiles: copyResult.createdFiles };
+}
+async function resolveTemplateDirectory() {
+  const checkedPaths = [];
+  const shippedCandidate = fileURLToPath(new URL("../template", import.meta.url));
+  checkedPaths.push(shippedCandidate);
+  if (await fileSystemExtra2.pathExists(shippedCandidate)) {
+    return shippedCandidate;
+  }
+  try {
+    const nodeRequire = createRequire(import.meta.url);
+    const createGameManifestPath = nodeRequire.resolve("@donut-games/create-game/package.json");
+    const monorepoCandidate = path2.join(path2.dirname(createGameManifestPath), "template");
+    checkedPaths.push(monorepoCandidate);
+    if (await fileSystemExtra2.pathExists(monorepoCandidate)) {
+      return monorepoCandidate;
+    }
+  } catch {
+  }
+  const thisModuleDirectory = path2.dirname(fileURLToPath(import.meta.url));
+  let walkingDirectory = thisModuleDirectory;
+  for (let walkDepth = 0; walkDepth < 8; walkDepth += 1) {
+    const candidate = path2.join(walkingDirectory, "packages", "create-donut-game", "template");
+    checkedPaths.push(candidate);
+    if (await fileSystemExtra2.pathExists(candidate)) {
+      return candidate;
+    }
+    const parentDirectory = path2.dirname(walkingDirectory);
+    if (parentDirectory === walkingDirectory) {
+      break;
+    }
+    walkingDirectory = parentDirectory;
+  }
+  throw new Error(`Unable to locate the @donut-games/create-game template directory. Checked:
+  ${checkedPaths.join("\n  ")}`);
+}
+async function runDependencyInstall(workingDirectory, log) {
+  const candidatePackageManagers = ["pnpm", "npm"];
+  for (const packageManager of candidatePackageManagers) {
+    const exitCode = await spawnInstall(packageManager, workingDirectory);
+    if (exitCode === "binary-missing") {
+      continue;
+    }
+    if (exitCode === 0) {
+      return;
+    }
+    break;
+  }
+  log(chalk.yellow("\u26A0 dependency install failed, run `npm install` manually"));
+}
+function spawnInstall(packageManager, workingDirectory) {
+  return new Promise((resolve) => {
+    const child = spawn(packageManager, ["install"], {
+      cwd: workingDirectory,
+      stdio: "inherit",
+      shell: false
+    });
+    child.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        resolve("binary-missing");
+        return;
+      }
+      resolve(1);
+    });
+    child.on("exit", (code) => {
+      resolve(code ?? 1);
+    });
+  });
+}
+
+// ../cli/dist/commands/dev.js
+import path4 from "path";
+import fileSystemExtra4 from "fs-extra";
+import chalk2 from "chalk";
+
+// ../cli/dist/shared/monorepo-aliases.js
+import path3 from "path";
+import fileSystemExtra3 from "fs-extra";
+var INTERNAL_DONUT_PACKAGE_NAMES = [
+  "core",
+  "math",
+  "pixi",
+  "three",
+  "ctrllr",
+  "player"
+];
+var PUBLISHED_ENGINE_SUBPATH_NAMES = [
+  "math",
+  "core",
+  "ctrllr",
+  "pixi",
+  "three",
+  "player"
+];
+async function resolveMonorepoDevAliases(monorepoRoot) {
+  const packagesDirectory = path3.join(monorepoRoot, "packages");
+  const resolvedAliasEntries = [];
+  const umbrellaSourceDirectory = path3.join(packagesDirectory, "donut-engine", "src");
+  for (const subpathName of PUBLISHED_ENGINE_SUBPATH_NAMES) {
+    const subpathBarrelPath = path3.join(umbrellaSourceDirectory, subpathName, "index.ts");
+    if (await fileSystemExtra3.pathExists(subpathBarrelPath)) {
+      resolvedAliasEntries.push({
+        find: `@donut-games/engine/${subpathName}`,
+        replacement: subpathBarrelPath
+      });
+    }
+  }
+  const umbrellaBarrelPath = path3.join(umbrellaSourceDirectory, "index.ts");
+  if (await fileSystemExtra3.pathExists(umbrellaBarrelPath)) {
+    resolvedAliasEntries.push({
+      find: /^@donut-games\/engine$/,
+      replacement: umbrellaBarrelPath
+    });
+  }
+  for (const internalPackageName of INTERNAL_DONUT_PACKAGE_NAMES) {
+    const internalSourceDirectory = path3.join(packagesDirectory, internalPackageName, "src");
+    if (await fileSystemExtra3.pathExists(internalSourceDirectory)) {
+      resolvedAliasEntries.push({
+        find: `@donut/${internalPackageName}`,
+        replacement: internalSourceDirectory
+      });
+    }
+  }
+  await assertEveryPublishedSubpathHasAnAlias(monorepoRoot, resolvedAliasEntries);
+  return resolvedAliasEntries;
+}
+async function assertEveryPublishedSubpathHasAnAlias(monorepoRoot, resolvedAliasEntries) {
+  const umbrellaPackageJsonPath = path3.join(monorepoRoot, "packages", "donut-engine", "package.json");
+  if (!await fileSystemExtra3.pathExists(umbrellaPackageJsonPath)) {
+    return;
+  }
+  const parsedManifest = await fileSystemExtra3.readJson(umbrellaPackageJsonPath);
+  const exportsField = parsedManifest.exports;
+  if (exportsField === void 0 || exportsField === null) {
+    return;
+  }
+  const aliasedStringFinds = new Set(resolvedAliasEntries.map((entry) => entry.find).filter((find) => typeof find === "string"));
+  const missingAliasSubpaths = [];
+  for (const exportKey of Object.keys(exportsField)) {
+    if (exportKey === "." || exportKey === "./package.json") {
+      continue;
+    }
+    if (!exportKey.startsWith("./")) {
+      continue;
+    }
+    const subpathName = exportKey.slice(2);
+    const expectedAliasKey = `@donut-games/engine/${subpathName}`;
+    if (!aliasedStringFinds.has(expectedAliasKey)) {
+      missingAliasSubpaths.push(expectedAliasKey);
+    }
+  }
+  if (missingAliasSubpaths.length > 0) {
+    throw new Error(`resolveMonorepoDevAliases: missing Vite aliases for published subpaths \u2014 ${missingAliasSubpaths.join(", ")}. Every subpath in packages/donut-engine/package.json "exports" must have a matching alias.`);
+  }
+}
+
+// ../cli/dist/commands/dev.js
+async function readProjectManifest(projectDirectory) {
+  const manifestPath = path4.join(projectDirectory, "donut.json");
+  if (!await fileSystemExtra4.pathExists(manifestPath)) {
+    throw new Error(`No donut.json found in ${projectDirectory}. Run 'donut init' first.`);
+  }
+  const parsed = await fileSystemExtra4.readJson(manifestPath);
+  if (typeof parsed.name !== "string" || parsed.name.length === 0) {
+    throw new Error(`donut.json is missing required field 'name'.`);
+  }
+  if (parsed.rendererTarget !== "pixi-2d" && parsed.rendererTarget !== "three-3d") {
+    throw new Error(`donut.json has invalid 'rendererTarget' \u2014 expected 'pixi-2d' or 'three-3d'.`);
+  }
+  return {
+    name: parsed.name,
+    rendererTarget: parsed.rendererTarget,
+    donutEngineVersion: parsed.donutEngineVersion
+  };
+}
+async function detectMonorepoRoot(projectDirectory) {
+  let currentDirectory = path4.resolve(projectDirectory);
+  for (let depth = 0; depth < 8; depth++) {
+    const workspaceFile = path4.join(currentDirectory, "pnpm-workspace.yaml");
+    if (await fileSystemExtra4.pathExists(workspaceFile)) {
+      return currentDirectory;
+    }
+    const parentDirectory = path4.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return void 0;
+    }
+    currentDirectory = parentDirectory;
+  }
+  return void 0;
+}
+async function writeDevEntryFiles(projectDirectory, manifest) {
+  const donutDirectory = path4.join(projectDirectory, ".donut");
+  await fileSystemExtra4.ensureDir(donutDirectory);
+  const gitIgnorePath = path4.join(donutDirectory, ".gitignore");
+  await fileSystemExtra4.writeFile(gitIgnorePath, "*\n", "utf8");
+  const indexHtmlPath = path4.join(donutDirectory, "index.html");
+  await fileSystemExtra4.writeFile(indexHtmlPath, buildIndexHtml(manifest), "utf8");
+  const devEntryPath = path4.join(donutDirectory, "dev-entry.ts");
+  await fileSystemExtra4.writeFile(devEntryPath, buildDevEntrySource(manifest), "utf8");
+  return donutDirectory;
+}
+function buildIndexHtml(manifest) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${manifest.name} \u2014 Donut dev</title>
+    <style>
+      html, body { margin: 0; padding: 0; height: 100%; background: #0a0a12; overflow: hidden; }
+      canvas#game-canvas { display: block; width: 100vw; height: 100vh; }
+    </style>
+  </head>
+  <body>
+    <canvas id="game-canvas"></canvas>
+    <script type="module" src="./dev-entry.ts"></script>
+  </body>
+</html>
+`;
+}
+function buildDevEntrySource(manifest) {
+  return `// AUTO-GENERATED by \`donut dev\`. Do not edit \u2014 regenerated every launch.
+import { startGame } from '@donut/player';
+import { createDefaultScene } from '../src/scenes/default-scene';
+
+const discoveredComponentModules = import.meta.glob('../src/components/**/*.ts', { eager: true });
+const discoveredSystemModules = import.meta.glob('../src/systems/**/*.ts', { eager: true });
+
+for (const modulePath of Object.keys(discoveredComponentModules)) {
+  console.log('[Donut dev] discovered component module:', modulePath);
+}
+for (const modulePath of Object.keys(discoveredSystemModules)) {
+  console.log('[Donut dev] discovered system module:', modulePath);
+}
+
+async function bootstrapDevelopmentRuntime(): Promise<void> {
+  const canvasElement = document.getElementById('game-canvas');
+  if (!(canvasElement instanceof HTMLCanvasElement)) {
+    throw new Error('[Donut dev] Missing <canvas id="game-canvas">');
+  }
+
+  await startGame({
+    canvas: canvasElement,
+    rendererTarget: '${manifest.rendererTarget}',
+    sceneFactory: createDefaultScene,
+    enableDevelopmentBridge: true,
+    enableDebugOverlay: true,
+  });
+
+  console.log('[Donut dev] booted renderer=${manifest.rendererTarget}');
+}
+
+bootstrapDevelopmentRuntime().catch((error) => {
+  console.error('[Donut dev] bootstrap failed', error);
+});
+`;
+}
+async function buildViteConfig(parameters) {
+  const { projectDirectory, donutRoot, port, open } = parameters;
+  const monorepoRoot = await detectMonorepoRoot(projectDirectory);
+  const resolveAlias = monorepoRoot !== void 0 ? await resolveMonorepoDevAliases(monorepoRoot) : [];
+  return {
+    root: donutRoot,
+    configFile: false,
+    server: {
+      port,
+      open,
+      strictPort: false,
+      fs: {
+        allow: [
+          projectDirectory,
+          ...monorepoRoot !== void 0 ? [monorepoRoot] : []
+        ]
+      }
+    },
+    resolve: {
+      alias: resolveAlias
+    },
+    optimizeDeps: {
+      // Let Vite figure out deps from the generated entry.
+    }
+  };
+}
+async function runDevServer(options) {
+  const { projectDirectory, port = 5173, open = true, log = (message) => console.log(message), startViteServer } = options;
+  const manifest = await readProjectManifest(projectDirectory);
+  log(chalk2.cyan(`Donut dev \u2014 project '${manifest.name}' (${manifest.rendererTarget})`));
+  const donutRoot = await writeDevEntryFiles(projectDirectory, manifest);
+  const viteConfig = await buildViteConfig({ projectDirectory, donutRoot, port, open });
+  const startServer = startViteServer ?? (async (configuration) => {
+    const viteModule = await import("vite");
+    return viteModule.createServer(configuration);
+  });
+  const server = await startServer(viteConfig);
+  await server.listen();
+  const resolvedLocalUrl = server.resolvedUrls?.local?.[0];
+  if (resolvedLocalUrl !== void 0) {
+    log(chalk2.green(`Dev server ready at ${resolvedLocalUrl}`));
+  } else {
+    log(chalk2.green(`Dev server listening on port ${port}`));
+  }
+}
+
+// ../cli/dist/commands/validate.js
+import path5 from "path";
+import { spawn as spawn2 } from "child_process";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fileSystemExtra5 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 = path5.join(projectDirectory, "donut.json");
+  if (!await fileSystemExtra5.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 fileSystemExtra5.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 = path5.join(projectDirectory, "tsconfig.json");
+  if (!await fileSystemExtra5.pathExists(tsconfigPath)) {
+    return;
+  }
+  const typeScriptCompilerPath = resolveTypeScriptCompiler(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 runProcess(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 = path5.isAbsolute(rawFilePath) ? rawFilePath : path5.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 resolveTypeScriptCompiler(projectDirectory) {
+  const projectLocal = path5.join(projectDirectory, "node_modules", "typescript", "bin", "tsc");
+  if (fileSystemExtra5.existsSync(projectLocal)) {
+    return projectLocal;
+  }
+  try {
+    const requireFromHere = createRequire2(import.meta.url);
+    const typeScriptPackageJsonPath = requireFromHere.resolve("typescript/package.json");
+    const typeScriptPackageDirectory = path5.dirname(typeScriptPackageJsonPath);
+    const fallback = path5.join(typeScriptPackageDirectory, "bin", "tsc");
+    if (fileSystemExtra5.existsSync(fallback)) {
+      return fallback;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function runProcess(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 = [
+    path5.join(projectDirectory, "src", "components"),
+    path5.join(projectDirectory, "src", "systems")
+  ];
+  const importLineRegex = /^\s*import\s+[^;]*?from\s+['"]([^'"]+)['"]/;
+  for (const directoryPath of gameLogicDirectories) {
+    if (!await fileSystemExtra5.pathExists(directoryPath)) {
+      continue;
+    }
+    const typeScriptFiles = await collectTypeScriptFiles(directoryPath);
+    for (const filePath of typeScriptFiles) {
+      const contents = await fileSystemExtra5.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 = path5.join(projectDirectory, "src");
+  if (!await fileSystemExtra5.pathExists(sourceRoot)) {
+    return;
+  }
+  const importLineRegex = /^\s*import\s+[^;]*?from\s+['"]([^'"]+)['"]/;
+  const typeScriptFiles = await collectTypeScriptFiles(sourceRoot);
+  for (const filePath of typeScriptFiles) {
+    const contents = await fileSystemExtra5.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 collectTypeScriptFiles(directoryPath) {
+  const collected = [];
+  const entries = await fileSystemExtra5.readdir(directoryPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path5.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      collected.push(...await collectTypeScriptFiles(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      collected.push(entryPath);
+    }
+  }
+  return collected;
+}
+async function validateAssetReferences(projectDirectory, errors) {
+  const sourceRoot = path5.join(projectDirectory, "src");
+  const assetsRoot = path5.join(projectDirectory, "assets");
+  if (!await fileSystemExtra5.pathExists(sourceRoot)) {
+    return;
+  }
+  const typeScriptFiles = await collectTypeScriptFiles(sourceRoot);
+  const texturePathRegex = /texturePath\s*(?::[^='"]*)?=?\s*['"]([^'"]*)['"]/g;
+  const assetsLiteralRegex = /['"]assets\/([^'"]+)['"]/g;
+  for (const filePath of typeScriptFiles) {
+    const contents = await fileSystemExtra5.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 = path5.join(assetsRoot, normalized);
+      if (!await fileSystemExtra5.pathExists(absoluteAssetPath)) {
+        errors.push({
+          filePath,
+          line,
+          message: `Referenced asset "${relativePath}" not found under assets/`,
+          code: "MISSING_ASSET"
+        });
+      }
+    }
+  }
+}
+
+// ../cli/dist/commands/build.js
+import path6 from "path";
+import fileSystemExtra6 from "fs-extra";
+import chalk3 from "chalk";
+import JSZip from "jszip";
+var BuildViolationError = class extends Error {
+  violations;
+  constructor(message, violations) {
+    super(message);
+    this.name = "BuildViolationError";
+    this.violations = violations;
+  }
+};
+var FORBIDDEN_PATTERNS = [
+  { pattern: /\bfetch\s*\(/g, severity: "error" },
+  { pattern: /\blocalStorage\b/g, severity: "error" },
+  { pattern: /\bsessionStorage\b/g, severity: "error" },
+  { pattern: /\bXMLHttpRequest\b/g, severity: "error" },
+  { pattern: /\bWebSocket\b/g, severity: "error" },
+  { pattern: /\beval\s*\(/g, severity: "error" },
+  { pattern: /new\s+Function\s*\(/g, severity: "error" },
+  { pattern: /\bimport\s*\(/g, severity: "error" },
+  { pattern: /\.innerHTML\s*=/g, severity: "error" },
+  { pattern: /\bwindow\b/g, severity: "warning" },
+  { pattern: /\bdocument\b/g, severity: "warning" }
+];
+async function collectTypeScriptFilesRecursively(directoryPath) {
+  if (!await fileSystemExtra6.pathExists(directoryPath)) {
+    return [];
+  }
+  const collected = [];
+  const entries = await fileSystemExtra6.readdir(directoryPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path6.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      collected.push(...await collectTypeScriptFilesRecursively(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      collected.push(entryPath);
+    }
+  }
+  return collected;
+}
+async function scanUserSourcesForForbiddenPatterns(projectDirectory) {
+  const directoriesToScan = [
+    path6.join(projectDirectory, "src", "components"),
+    path6.join(projectDirectory, "src", "systems")
+  ];
+  const violations = [];
+  for (const directoryPath of directoriesToScan) {
+    const files = await collectTypeScriptFilesRecursively(directoryPath);
+    for (const filePath of files) {
+      const contents = await fileSystemExtra6.readFile(filePath, "utf8");
+      const lines = contents.split(/\r?\n/);
+      for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const lineText = lines[lineIndex];
+        for (const { pattern, severity } of FORBIDDEN_PATTERNS) {
+          pattern.lastIndex = 0;
+          let match;
+          while ((match = pattern.exec(lineText)) !== null) {
+            violations.push({
+              filePath,
+              line: lineIndex + 1,
+              pattern: pattern.source,
+              match: match[0],
+              severity
+            });
+          }
+        }
+      }
+    }
+  }
+  return violations;
+}
+async function detectProjectSourceKind(projectDirectory, log) {
+  const projectPackageJsonPath = path6.join(projectDirectory, "package.json");
+  if (!await fileSystemExtra6.pathExists(projectPackageJsonPath)) {
+    throw new Error(`Cannot determine project source kind \u2014 no package.json found at ${projectPackageJsonPath}.`);
+  }
+  const parsedManifest = await fileSystemExtra6.readJson(projectPackageJsonPath);
+  const mergedDependencies = {
+    ...parsedManifest.dependencies ?? {},
+    ...parsedManifest.devDependencies ?? {}
+  };
+  const hasPublishedEngineDependency = "@donut-games/engine" in mergedDependencies;
+  const hasAnyInternalWorkspaceDependency = Object.keys(mergedDependencies).some((dependencyName) => dependencyName.startsWith("@donut/"));
+  if (hasPublishedEngineDependency && hasAnyInternalWorkspaceDependency) {
+    log(chalk3.yellow("\u26A0 Both @donut-games/engine and internal @donut/* workspace dependencies are declared. Preferring published imports for the build entry."));
+    return "published";
+  }
+  if (hasPublishedEngineDependency) {
+    return "published";
+  }
+  if (hasAnyInternalWorkspaceDependency) {
+    return "workspace";
+  }
+  throw new Error(`Cannot determine project source kind \u2014 package.json at ${projectPackageJsonPath} declares neither "@donut-games/engine" nor any internal "@donut/*" workspace dependency. Add "@donut-games/engine" to dependencies to build against the published engine surface.`);
+}
+function buildBuildEntrySource(manifest, projectSourceKind) {
+  const usesPixi = manifest.rendererTarget.startsWith("pixi");
+  const coreSpecifier = projectSourceKind === "published" ? "@donut-games/engine/core" : "@donut/core";
+  const ctrllrSpecifier = projectSourceKind === "published" ? "@donut-games/engine/ctrllr" : "@donut/ctrllr";
+  const pixiSpecifier = projectSourceKind === "published" ? "@donut-games/engine/pixi" : "@donut/pixi";
+  return `// AUTO-GENERATED by \`donut build\`. Do not edit.
+import { World, SystemType, MotionSystem } from '${coreSpecifier}';
+import { MockCtrllrManager, CtrllrInputSystem } from '${ctrllrSpecifier}';
+${usesPixi ? `import { PixiRendererAdapter, PixiRenderSystem } from '${pixiSpecifier}';
+` : ""}import { createDefaultScene } from '../src/scenes/default-scene';
+
+const discoveredComponentModules = import.meta.glob('../src/components/**/*.ts', { eager: true });
+const discoveredSystemModules = import.meta.glob('../src/systems/**/*.ts', { eager: true });
+const discoveredSceneModules = import.meta.glob('../src/scenes/**/*.ts', { eager: true });
+void discoveredComponentModules;
+void discoveredSystemModules;
+void discoveredSceneModules;
+
+export interface StartGameOptions {
+  readonly canvas: HTMLCanvasElement;
+}
+
+export async function startGame(options: StartGameOptions): Promise<void> {
+  const world = new World();
+  world.addSystem(new CtrllrInputSystem(world));
+  world.addSystem(new MotionSystem(world));
+
+  ${usesPixi ? `const rendererAdapter = new PixiRendererAdapter({
+    canvas: options.canvas,
+    width: options.canvas.width || 800,
+    height: options.canvas.height || 600,
+    backgroundColor: 0x0a0a12,
+  });
+  await rendererAdapter.initialize();
+  world.addSystem(new PixiRenderSystem(world, rendererAdapter));` : `console.warn('[Donut] three-3d renderer target is not yet implemented');`}
+
+  const ctrllrManager = new MockCtrllrManager();
+
+  createDefaultScene(world, ctrllrManager);
+
+  let previousTimestamp: number | undefined;
+  function gameLoop(currentTimestamp: number): void {
+    if (previousTimestamp === undefined) previousTimestamp = currentTimestamp;
+    const elapsedMilliseconds = currentTimestamp - previousTimestamp;
+    previousTimestamp = currentTimestamp;
+    world.update(SystemType.Update, elapsedMilliseconds);
+    world.update(SystemType.Draw, elapsedMilliseconds);
+    requestAnimationFrame(gameLoop);
+  }
+  requestAnimationFrame(gameLoop);
+}
+
+// Auto-start when a canvas with id="game-canvas" is present.
+if (typeof document !== 'undefined') {
+  const canvasElement = document.getElementById('game-canvas');
+  if (canvasElement instanceof HTMLCanvasElement) {
+    startGame({ canvas: canvasElement }).catch((error) => {
+      console.error('[Donut] startGame failed', error);
+    });
+  }
+}
+`;
+}
+async function writeBuildEntryFile(projectDirectory, manifest, projectSourceKind) {
+  const donutDirectory = path6.join(projectDirectory, ".donut");
+  await fileSystemExtra6.ensureDir(donutDirectory);
+  const gitIgnorePath = path6.join(donutDirectory, ".gitignore");
+  if (!await fileSystemExtra6.pathExists(gitIgnorePath)) {
+    await fileSystemExtra6.writeFile(gitIgnorePath, "*\n", "utf8");
+  }
+  const entryPath = path6.join(donutDirectory, "build-entry.ts");
+  await fileSystemExtra6.writeFile(entryPath, buildBuildEntrySource(manifest, projectSourceKind), "utf8");
+  return entryPath;
+}
+async function buildViteBuildConfig(parameters) {
+  const { projectDirectory, donutRoot, buildEntryPath, stagingDirectory } = parameters;
+  const monorepoRoot = await detectMonorepoRoot(projectDirectory);
+  const resolveAlias = monorepoRoot !== void 0 ? await resolveMonorepoDevAliases(monorepoRoot) : [];
+  return {
+    root: donutRoot,
+    configFile: false,
+    logLevel: "warn",
+    resolve: { alias: resolveAlias },
+    build: {
+      outDir: stagingDirectory,
+      emptyOutDir: true,
+      minify: "esbuild",
+      lib: {
+        entry: buildEntryPath,
+        formats: ["es"],
+        fileName: () => "game.js"
+      },
+      rollupOptions: {
+        output: {
+          inlineDynamicImports: true,
+          entryFileNames: "game.js"
+        }
+      }
+    }
+  };
+}
+async function copyAssetsAndCollectEntries(projectAssetsDirectory, stagingAssetsDirectory, imageAssetOptimizer, log) {
+  let sharpUnavailableWarningEmitted = false;
+  if (!await fileSystemExtra6.pathExists(projectAssetsDirectory)) {
+    return [];
+  }
+  await fileSystemExtra6.ensureDir(stagingAssetsDirectory);
+  const entries = [];
+  async function walk(currentSource, currentDestination, relativePrefix) {
+    const directoryEntries = await fileSystemExtra6.readdir(currentSource, { withFileTypes: true });
+    for (const directoryEntry of directoryEntries) {
+      if (directoryEntry.name === ".gitkeep") {
+        continue;
+      }
+      const sourcePath = path6.join(currentSource, directoryEntry.name);
+      const destinationPath = path6.join(currentDestination, directoryEntry.name);
+      const relativePath = relativePrefix === "" ? directoryEntry.name : `${relativePrefix}/${directoryEntry.name}`;
+      if (directoryEntry.isDirectory()) {
+        await fileSystemExtra6.ensureDir(destinationPath);
+        await walk(sourcePath, destinationPath, relativePath);
+      } else if (directoryEntry.isFile()) {
+        const extensionWithDot = path6.extname(directoryEntry.name).toLowerCase();
+        const extension = extensionWithDot.startsWith(".") ? extensionWithDot.slice(1) : extensionWithDot;
+        const isOptimizableImage = ["png", "jpg", "jpeg", "webp"].includes(extension);
+        let wroteOptimizedOutput = false;
+        if (isOptimizableImage) {
+          const optimizedBuffer = await imageAssetOptimizer(sourcePath, extension);
+          if (optimizedBuffer !== null) {
+            await fileSystemExtra6.writeFile(destinationPath, optimizedBuffer);
+            wroteOptimizedOutput = true;
+          } else if (!sharpUnavailableWarningEmitted) {
+            log(chalk3.yellow("\u2139 sharp not installed \u2014 assets copied uncompressed"));
+            sharpUnavailableWarningEmitted = true;
+          }
+        }
+        if (!wroteOptimizedOutput) {
+          await fileSystemExtra6.copy(sourcePath, destinationPath);
+        }
+        const stat = await fileSystemExtra6.stat(destinationPath);
+        entries.push({
+          name: directoryEntry.name,
+          path: `assets/${relativePath}`,
+          type: extension,
+          sizeBytes: stat.size
+        });
+      }
+    }
+  }
+  await walk(projectAssetsDirectory, stagingAssetsDirectory, "");
+  return entries;
+}
+async function collectRuntimeVersions(projectDirectory) {
+  const runtimeVersions = {};
+  const monorepoRoot = await detectMonorepoRoot(projectDirectory);
+  const donutPackageNames = ["core", "math", "pixi", "three", "ctrllr", "player"];
+  if (monorepoRoot !== void 0) {
+    const packagesDirectory = path6.join(monorepoRoot, "packages");
+    for (const packageName of donutPackageNames) {
+      const packageJsonPath = path6.join(packagesDirectory, packageName, "package.json");
+      if (await fileSystemExtra6.pathExists(packageJsonPath)) {
+        const parsed = await fileSystemExtra6.readJson(packageJsonPath);
+        if (typeof parsed.name === "string" && typeof parsed.version === "string") {
+          runtimeVersions[parsed.name] = parsed.version;
+        }
+      }
+    }
+  }
+  return runtimeVersions;
+}
+async function runViteBuildProgrammatically(viteConfig) {
+  const viteModule = await import("vite");
+  await viteModule.build(viteConfig);
+}
+async function runBuild(options) {
+  const log = options.log ?? ((message) => console.log(message));
+  const startTimeMilliseconds = Date.now();
+  const projectDirectory = path6.resolve(options.projectDirectory);
+  const outputDirectory = path6.resolve(options.outputDirectory ?? path6.join(projectDirectory, "dist"));
+  const validationReport = await runValidation({
+    projectDirectory,
+    skipTypeCheck: true
+  });
+  if (validationReport.errors.length > 0) {
+    const formattedErrors = validationReport.errors.map((validationError) => `  ${validationError.filePath}: ${validationError.message}`).join("\n");
+    throw new BuildViolationError(`Validation failed with ${validationReport.errors.length} error(s):
+${formattedErrors}`, []);
+  }
+  const scanFindings = await scanUserSourcesForForbiddenPatterns(projectDirectory);
+  const fatalViolations = scanFindings.filter((finding) => finding.severity === "error");
+  const warnings = scanFindings.filter((finding) => finding.severity === "warning");
+  if (fatalViolations.length > 0) {
+    throw new BuildViolationError(`Security scan failed with ${fatalViolations.length} violation(s)`, fatalViolations);
+  }
+  const donutManifest = await readProjectManifest(projectDirectory);
+  log(`Donut build \u2014 project '${donutManifest.name}' (${donutManifest.rendererTarget})`);
+  const projectSourceKind = await detectProjectSourceKind(projectDirectory, log);
+  const buildEntryPath = await writeBuildEntryFile(projectDirectory, donutManifest, projectSourceKind);
+  const stagingDirectory = path6.join(outputDirectory, "bundle-staging");
+  await fileSystemExtra6.ensureDir(outputDirectory);
+  await fileSystemExtra6.remove(stagingDirectory);
+  await fileSystemExtra6.ensureDir(stagingDirectory);
+  const donutRoot = path6.join(projectDirectory, ".donut");
+  const viteConfig = await buildViteBuildConfig({
+    projectDirectory,
+    donutRoot,
+    buildEntryPath,
+    stagingDirectory
+  });
+  const runVite = options.runViteBuild ?? runViteBuildProgrammatically;
+  await runVite(viteConfig);
+  const builtGameJsPath = path6.join(stagingDirectory, "game.js");
+  if (!await fileSystemExtra6.pathExists(builtGameJsPath)) {
+    throw new Error(`Expected Vite build to emit game.js at ${builtGameJsPath} \u2014 file not found.`);
+  }
+  const projectAssetsDirectory = path6.join(projectDirectory, "assets");
+  const stagingAssetsDirectory = path6.join(stagingDirectory, "assets");
+  const imageAssetOptimizer = options.optimizeImageAsset ?? optimizeImageAssetIfPossible;
+  const assetEntries = await copyAssetsAndCollectEntries(projectAssetsDirectory, stagingAssetsDirectory, imageAssetOptimizer, log);
+  const runtimeVersions = await collectRuntimeVersions(projectDirectory);
+  const gameJsContents = await fileSystemExtra6.readFile(builtGameJsPath);
+  const bundleFileName = `${donutManifest.name}-${donutManifest.version ?? "0.0.0"}.donut`;
+  const bundlePath = path6.join(outputDirectory, bundleFileName);
+  const projectManifestVersion = await readProjectManifestVersion(projectDirectory);
+  const partialManifest = {
+    name: donutManifest.name,
+    version: projectManifestVersion,
+    rendererTarget: donutManifest.rendererTarget,
+    entryPoint: "game.js",
+    donutEngineVersion: donutManifest.donutEngineVersion ?? "0.0.0",
+    runtimeVersions,
+    assets: assetEntries,
+    buildTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const zipArchive = new JSZip();
+  zipArchive.file("game.js", gameJsContents);
+  for (const assetEntry of assetEntries) {
+    const absoluteAssetPath = path6.join(stagingDirectory, assetEntry.path);
+    const assetBuffer = await fileSystemExtra6.readFile(absoluteAssetPath);
+    zipArchive.file(assetEntry.path, assetBuffer);
+  }
+  let candidateBundleSize = 0;
+  let paddingLength = 8;
+  let finalBuffer = Buffer.alloc(0);
+  let finalManifest = { ...partialManifest, bundleSizeBytes: 0 };
+  for (let iteration = 0; iteration < 16; iteration += 1) {
+    finalManifest = { ...partialManifest, bundleSizeBytes: candidateBundleSize };
+    const renderedManifest = renderManifestJsonWithPadding(finalManifest, paddingLength);
+    zipArchive.file("manifest.json", renderedManifest, { compression: "STORE" });
+    finalBuffer = await zipArchive.generateAsync({
+      type: "nodebuffer",
+      compression: "DEFLATE"
+    });
+    if (finalBuffer.byteLength === candidateBundleSize) {
+      break;
+    }
+    const previousDigits = String(candidateBundleSize).length;
+    const newDigits = String(finalBuffer.byteLength).length;
+    if (newDigits !== previousDigits) {
+      paddingLength += Math.abs(newDigits - previousDigits) + 2;
+    }
+    candidateBundleSize = finalBuffer.byteLength;
+  }
+  await fileSystemExtra6.writeFile(bundlePath, finalBuffer);
+  const bundleStat = await fileSystemExtra6.stat(bundlePath);
+  if (bundleStat.size !== finalManifest.bundleSizeBytes) {
+    throw new Error(`Internal build error: bundleSizeBytes (${finalManifest.bundleSizeBytes}) does not match on-disk archive size (${bundleStat.size}).`);
+  }
+  const buildTimeMilliseconds = Date.now() - startTimeMilliseconds;
+  return {
+    bundlePath,
+    bundleSizeBytes: bundleStat.size,
+    buildTimeMilliseconds,
+    warnings,
+    violations: [],
+    manifest: finalManifest
+  };
+}
+function renderManifestJsonWithPadding(manifest, paddingLength) {
+  const manifestWithPadding = {
+    ...manifest,
+    _sizePadding: " ".repeat(Math.max(0, paddingLength))
+  };
+  return JSON.stringify(manifestWithPadding, null, 2);
+}
+async function optimizeImageAssetIfPossible(sourcePath, extension) {
+  let sharpModule;
+  try {
+    sharpModule = await import(
+      /* @vite-ignore */
+      "sharp"
+    );
+  } catch {
+    return null;
+  }
+  try {
+    const pipeline = sharpModule.default(sourcePath).rotate();
+    let configured;
+    if (extension === "png") {
+      configured = pipeline.png({ compressionLevel: 9 });
+    } else if (extension === "jpg" || extension === "jpeg") {
+      configured = pipeline.jpeg({ quality: 82, mozjpeg: true });
+    } else if (extension === "webp") {
+      configured = pipeline.webp({ quality: 82 });
+    } else {
+      return null;
+    }
+    const output = await configured.toBuffer();
+    return output;
+  } catch {
+    return null;
+  }
+}
+async function readProjectManifestVersion(projectDirectory) {
+  const manifestPath = path6.join(projectDirectory, "donut.json");
+  if (!await fileSystemExtra6.pathExists(manifestPath)) {
+    return "0.0.0";
+  }
+  const raw = await fileSystemExtra6.readJson(manifestPath);
+  return typeof raw.version === "string" ? raw.version : "0.0.0";
+}
+
+// ../cli/dist/commands/publish.js
+import path7 from "path";
+import fileSystemExtra7 from "fs-extra";
+import chalk4 from "chalk";
+import JsZip from "jszip";
+import * as acorn from "acorn";
+import * as acornWalk from "acorn-walk";
+var StubBundleUploader = class {
+  logger;
+  constructor(logger = (message) => console.log(message)) {
+    this.logger = logger;
+  }
+  async upload(parameters) {
+    const { manifest, bundleBuffer } = parameters;
+    this.logger(chalk4.yellow(`[StubBundleUploader] Would upload ${manifest.name}@${manifest.version} (${bundleBuffer.byteLength} bytes)`));
+    const gameUrl = `https://donut.games/${encodeURIComponent(manifest.name)}/${encodeURIComponent(manifest.version)}`;
+    return { gameUrl };
+  }
+};
+var FORBIDDEN_CALL_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "fetch",
+  "eval",
+  "Function",
+  "XMLHttpRequest",
+  "WebSocket"
+]);
+async function runPublish(options) {
+  const log = options.log ?? ((message) => console.log(message));
+  const uploader = options.uploader ?? new StubBundleUploader(log);
+  const authToken = options.authToken ?? "stub-auth-token";
+  const bundlePath = await resolveBundlePath(options.projectDirectory, options.bundlePath);
+  log(chalk4.cyan(`donut publish: using bundle ${bundlePath}`));
+  const bundleBuffer = await fileSystemExtra7.readFile(bundlePath);
+  const zipArchive = await JsZip.loadAsync(bundleBuffer);
+  const manifest = await readAndValidateManifest(zipArchive);
+  await validateGameEntryExists(zipArchive);
+  await validateAssetsExist(zipArchive, manifest);
+  const gameSource = await readZipTextFile(zipArchive, "game.js");
+  const violations = scanBundleSourceForViolations(gameSource);
+  if (violations.length > 0) {
+    const formatted = violations.map((violation) => `  - [${violation.pattern}] ${violation.description}` + (violation.line !== void 0 ? ` (line ${violation.line})` : "")).join("\n");
+    throw new Error(`Publish aborted: bundled game.js contains forbidden APIs:
+${formatted}`);
+  }
+  const warnings = [];
+  const assetCount = manifest.assets.length;
+  const bundleSizeBytes = bundleBuffer.byteLength;
+  log(chalk4.green("\nBundle validated:"));
+  log(`  name:         ${manifest.name}`);
+  log(`  version:      ${manifest.version}`);
+  log(`  renderer:     ${manifest.rendererTarget}`);
+  log(`  assets:       ${assetCount}`);
+  log(`  bundle size:  ${bundleSizeBytes} bytes`);
+  log(chalk4.yellow("\nDRY RUN \u2014 no network request made"));
+  const { gameUrl } = await uploader.upload({
+    bundleBuffer,
+    manifest,
+    authToken
+  });
+  log(chalk4.cyan(`
+Placeholder game URL: ${gameUrl}`));
+  return {
+    success: true,
+    gameUrl,
+    bundleSizeBytes,
+    warnings,
+    violations
+  };
+}
+async function resolveBundlePath(projectDirectory, explicitBundlePath) {
+  if (explicitBundlePath !== void 0) {
+    const absoluteBundlePath = path7.isAbsolute(explicitBundlePath) ? explicitBundlePath : path7.join(projectDirectory, explicitBundlePath);
+    if (!await fileSystemExtra7.pathExists(absoluteBundlePath)) {
+      throw new Error(`Bundle not found at ${absoluteBundlePath}`);
+    }
+    return absoluteBundlePath;
+  }
+  const distDirectory = path7.join(projectDirectory, "dist");
+  if (!await fileSystemExtra7.pathExists(distDirectory)) {
+    throw new Error(`No bundle specified and no dist/ directory found at ${distDirectory}. Run "donut build" first.`);
+  }
+  const entries = await fileSystemExtra7.readdir(distDirectory);
+  const donutBundles = entries.filter((entry) => entry.endsWith(".donut"));
+  if (donutBundles.length === 0) {
+    throw new Error(`No .donut bundles found in ${distDirectory}. Run "donut build" first.`);
+  }
+  const statsByPath = await Promise.all(donutBundles.map(async (entry) => {
+    const fullPath = path7.join(distDirectory, entry);
+    const stats = await fileSystemExtra7.stat(fullPath);
+    return { fullPath, modifiedTimeMilliseconds: stats.mtimeMs };
+  }));
+  statsByPath.sort((left, right) => right.modifiedTimeMilliseconds - left.modifiedTimeMilliseconds);
+  return statsByPath[0].fullPath;
+}
+async function readAndValidateManifest(zipArchive) {
+  const manifestFile = zipArchive.file("manifest.json");
+  if (manifestFile === null) {
+    throw new Error("Bundle is missing required /manifest.json");
+  }
+  const manifestText = await manifestFile.async("string");
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestText);
+  } catch (parseError) {
+    throw new Error(`Bundle manifest.json is not valid JSON: ${parseError.message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("Bundle manifest.json is not an object");
+  }
+  const candidate = parsed;
+  const requiredStringFields = [
+    "name",
+    "version",
+    "rendererTarget",
+    "entryPoint",
+    "donutEngineVersion",
+    "buildTimestamp"
+  ];
+  for (const fieldName of requiredStringFields) {
+    if (typeof candidate[fieldName] !== "string" || candidate[fieldName].length === 0) {
+      throw new Error(`Bundle manifest.json is missing required string field "${fieldName}"`);
+    }
+  }
+  const rendererTarget = candidate.rendererTarget;
+  if (rendererTarget !== "pixi-2d" && rendererTarget !== "three-3d") {
+    throw new Error(`Bundle manifest.json has invalid rendererTarget "${String(rendererTarget)}"`);
+  }
+  if (candidate.entryPoint !== "game.js") {
+    throw new Error(`Bundle manifest.json entryPoint must be "game.js" (got "${String(candidate.entryPoint)}")`);
+  }
+  if (typeof candidate.bundleSizeBytes !== "number") {
+    throw new Error('Bundle manifest.json is missing required number field "bundleSizeBytes"');
+  }
+  if (typeof candidate.runtimeVersions !== "object" || candidate.runtimeVersions === null) {
+    throw new Error('Bundle manifest.json is missing required object field "runtimeVersions"');
+  }
+  if (!Array.isArray(candidate.assets)) {
+    throw new Error('Bundle manifest.json is missing required array field "assets"');
+  }
+  return parsed;
+}
+async function validateGameEntryExists(zipArchive) {
+  const entry = zipArchive.file("game.js");
+  if (entry === null) {
+    throw new Error("Bundle is missing required /game.js");
+  }
+}
+async function validateAssetsExist(zipArchive, manifest) {
+  for (const asset of manifest.assets) {
+    const entry = zipArchive.file(asset.path);
+    if (entry === null) {
+      throw new Error(`Bundle manifest declares asset "${asset.path}" but it is missing from the archive`);
+    }
+  }
+}
+async function readZipTextFile(zipArchive, pathInZip) {
+  const entry = zipArchive.file(pathInZip);
+  if (entry === null) {
+    throw new Error(`Bundle is missing required file ${pathInZip}`);
+  }
+  return entry.async("string");
+}
+function scanBundleSourceForViolations(sourceText) {
+  const violations = [];
+  let ast;
+  try {
+    ast = acorn.parse(sourceText, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      locations: true,
+      allowHashBang: true
+    });
+  } catch (parseError) {
+    violations.push({
+      pattern: "parse-error",
+      description: `Bundle game.js failed to parse: ${parseError.message}`
+    });
+    return violations;
+  }
+  acornWalk.simple(ast, {
+    CallExpression(rawNode) {
+      const node = rawNode;
+      const callee = node.callee;
+      if (callee.type === "Identifier") {
+        const identifierNode = callee;
+        if (FORBIDDEN_CALL_IDENTIFIERS.has(identifierNode.name)) {
+          violations.push({
+            pattern: identifierNode.name,
+            description: `Forbidden call to ${identifierNode.name}(...)`,
+            line: node.loc?.start.line,
+            column: node.loc?.start.column
+          });
+        }
+      }
+    },
+    NewExpression(rawNode) {
+      const node = rawNode;
+      const callee = node.callee;
+      if (callee.type === "Identifier") {
+        const identifierNode = callee;
+        if (FORBIDDEN_CALL_IDENTIFIERS.has(identifierNode.name)) {
+          violations.push({
+            pattern: identifierNode.name,
+            description: `Forbidden construction of ${identifierNode.name}`,
+            line: node.loc?.start.line,
+            column: node.loc?.start.column
+          });
+        }
+      }
+    },
+    AssignmentExpression(rawNode) {
+      const node = rawNode;
+      if (node.left.type === "MemberExpression") {
+        const memberNode = node.left;
+        if (memberNode.property.type === "Identifier" && memberNode.property.name === "innerHTML") {
+          violations.push({
+            pattern: "innerHTML",
+            description: "Forbidden assignment to .innerHTML",
+            line: node.loc?.start.line,
+            column: node.loc?.start.column
+          });
+        }
+      }
+    },
+    ImportExpression(rawNode) {
+      const node = rawNode;
+      violations.push({
+        pattern: "dynamic-import",
+        description: "Forbidden dynamic import() expression",
+        line: node.loc?.start.line,
+        column: node.loc?.start.column
+      });
+    }
+  });
+  return violations;
+}
+
+// ../cli/dist/commands/review.js
+import path8 from "path";
+import fileSystemExtra8 from "fs-extra";
+import chalk5 from "chalk";
+import JsZip2 from "jszip";
+var REVIEW_PROMPT_TEXT = 'You are reviewing code for the Donut game engine. Games must only use the Donut framework API. Check each file for: direct DOM access (document, window, innerHTML), network requests (fetch, XMLHttpRequest, WebSocket), code execution (eval, new Function, dynamic import()), storage (localStorage, sessionStorage, indexedDB), or any attempt to escape the game runtime. Respond with a JSON array of findings: [{ "severity": "violation"|"warning"|"pass", "file": "path", "description": "what and why" }]. Return [{"severity":"pass","description":"clean"}] if nothing is wrong.';
+var StubClaudeReviewClient = class {
+  logger;
+  constructor(logger = (message) => console.log(message)) {
+    this.logger = logger;
+  }
+  async review(_request) {
+    this.logger(chalk5.yellow("AI review skipped (no ANTHROPIC_API_KEY set)"));
+    const findings = [
+      { severity: "pass", description: "clean" }
+    ];
+    return { findings, rawResponse: JSON.stringify(findings) };
+  }
+};
+function createDefaultClaudeReviewClient(logger = (message) => console.log(message)) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (apiKey === void 0 || apiKey.length === 0) {
+    return new StubClaudeReviewClient(logger);
+  }
+  return new AnthropicClaudeReviewClient(apiKey);
+}
+var AnthropicClaudeReviewClient = class {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async review(request) {
+    const { default: AnthropicClient } = await import("@anthropic-ai/sdk");
+    const client = new AnthropicClient({ apiKey: this.apiKey });
+    const message = await client.messages.create({
+      model: "claude-opus-4-6",
+      max_tokens: 4096,
+      system: request.prompt,
+      messages: [
+        {
+          role: "user",
+          content: request.sourceText
+        }
+      ]
+    });
+    const firstTextBlock = message.content.find((block) => block.type === "text");
+    const rawResponse = firstTextBlock?.text ?? "";
+    const findings = parseReviewFindingsFromText(rawResponse);
+    return { findings, rawResponse };
+  }
+};
+function parseReviewFindingsFromText(text) {
+  const firstArrayStart = text.indexOf("[");
+  const lastArrayEnd = text.lastIndexOf("]");
+  if (firstArrayStart === -1 || lastArrayEnd === -1 || lastArrayEnd <= firstArrayStart) {
+    return [
+      {
+        severity: "warning",
+        description: `Could not parse review findings as JSON array: ${text.slice(0, 200)}`
+      }
+    ];
+  }
+  const candidate = text.slice(firstArrayStart, lastArrayEnd + 1);
+  try {
+    const parsed = JSON.parse(candidate);
+    if (!Array.isArray(parsed)) {
+      throw new Error("Expected JSON array");
+    }
+    return parsed.map((entry) => {
+      const record = entry;
+      const severity = record.severity;
+      const normalizedSeverity = severity === "violation" || severity === "warning" || severity === "pass" ? severity : "warning";
+      return {
+        severity: normalizedSeverity,
+        file: typeof record.file === "string" ? record.file : void 0,
+        description: typeof record.description === "string" ? record.description : "no description"
+      };
+    });
+  } catch (parseError) {
+    return [
+      {
+        severity: "warning",
+        description: `Could not parse review findings: ${parseError.message}`
+      }
+    ];
+  }
+}
+async function runReview(options) {
+  const log = options.log ?? ((message) => console.log(message));
+  const claudeClient = options.claudeClient ?? createDefaultClaudeReviewClient(log);
+  const sources = await collectReviewSources(options.projectDirectory, options.bundlePath);
+  if (sources.length === 0) {
+    log(chalk5.yellow("donut review: no source files found to review"));
+    return {
+      overallPass: true,
+      findings: [
+        { severity: "pass", description: "No reviewable sources found" }
+      ]
+    };
+  }
+  const sourceText = sources.map((file) => `// === FILE: ${file.displayPath} ===
+${file.contents}
+// === END FILE: ${file.displayPath} ===`).join("\n\n");
+  log(chalk5.cyan(`donut review: sending ${sources.length} file(s) for AI review`));
+  const response = await claudeClient.review({
+    sourceText,
+    prompt: REVIEW_PROMPT_TEXT
+  });
+  const hasViolation = response.findings.some((finding) => finding.severity === "violation");
+  for (const finding of response.findings) {
+    const prefix = `[${finding.severity.toUpperCase()}]${finding.file !== void 0 ? ` ${finding.file}` : ""}`;
+    const line = `${prefix}: ${finding.description}`;
+    if (finding.severity === "violation") {
+      log(chalk5.red(line));
+    } else if (finding.severity === "warning") {
+      log(chalk5.yellow(line));
+    } else {
+      log(chalk5.green(line));
+    }
+  }
+  return {
+    overallPass: hasViolation === false,
+    findings: response.findings
+  };
+}
+async function collectReviewSources(projectDirectory, bundlePath) {
+  if (bundlePath !== void 0) {
+    const collected = await collectReviewSourcesFromBundle(projectDirectory, bundlePath);
+    if (collected.length > 0) {
+      return collected;
+    }
+  }
+  return collectReviewSourcesFromDisk(projectDirectory);
+}
+async function collectReviewSourcesFromBundle(projectDirectory, bundlePath) {
+  const absoluteBundlePath = path8.isAbsolute(bundlePath) ? bundlePath : path8.join(projectDirectory, bundlePath);
+  if (!await fileSystemExtra8.pathExists(absoluteBundlePath)) {
+    throw new Error(`Bundle not found at ${absoluteBundlePath}`);
+  }
+  const buffer = await fileSystemExtra8.readFile(absoluteBundlePath);
+  const zipArchive = await JsZip2.loadAsync(buffer);
+  const sources = [];
+  const entries = [];
+  zipArchive.forEach((relativePath, file) => {
+    if (relativePath.startsWith("src/") && (relativePath.endsWith(".ts") || relativePath.endsWith(".js")) && file.dir === false) {
+      entries.push({ path: relativePath, file });
+    }
+  });
+  for (const entry of entries) {
+    const contents = await entry.file.async("string");
+    sources.push({ displayPath: entry.path, contents });
+  }
+  return sources;
+}
+async function collectReviewSourcesFromDisk(projectDirectory) {
+  const componentsDirectory = path8.join(projectDirectory, "src", "components");
+  const systemsDirectory = path8.join(projectDirectory, "src", "systems");
+  const sources = [];
+  for (const directoryPath of [componentsDirectory, systemsDirectory]) {
+    if (!await fileSystemExtra8.pathExists(directoryPath)) {
+      continue;
+    }
+    const typeScriptFiles = await collectTypeScriptFilesRecursively2(directoryPath);
+    for (const filePath of typeScriptFiles) {
+      const contents = await fileSystemExtra8.readFile(filePath, "utf8");
+      sources.push({
+        displayPath: path8.relative(projectDirectory, filePath),
+        contents
+      });
+    }
+  }
+  return sources;
+}
+async function collectTypeScriptFilesRecursively2(directoryPath) {
+  const collected = [];
+  const entries = await fileSystemExtra8.readdir(directoryPath, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const entryPath = path8.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      collected.push(...await collectTypeScriptFilesRecursively2(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      collected.push(entryPath);
+    }
+  }
+  return collected;
+}
+
+// ../cli/dist/index.js
+var program = new Command();
+program.name("donut").description("Donut game engine command-line tooling").version("0.1.0");
+program.command("init").description("Scaffold a new Donut game project").argument("<project-name>", "name of the new project directory").option("--2d", "use the 2D (Pixi) renderer target", false).option("--3d", "use the 3D (Three) renderer target", false).option("--skip-install", "skip running pnpm/npm install after scaffolding", false).action(async (projectName, options) => {
+  const useThreeDimensional = options["3d"] === true;
+  const rendererTarget = useThreeDimensional ? "three-3d" : "pixi-2d";
+  try {
+    await initializeProject({
+      projectName,
+      rendererTarget,
+      targetDirectory: projectName,
+      skipInstall: options.skipInstall === true
+    });
+  } catch (error) {
+    console.error(chalk6.red(error.message));
+    process.exit(1);
+  }
+});
+program.command("dev").description("Run the project in a local development server").option("--port <port>", "port for the dev server", "5173").option("--no-open", "do not automatically open a browser window").action(async (options) => {
+  const parsedPort = Number.parseInt(options.port, 10);
+  try {
+    await runDevServer({
+      projectDirectory: process.cwd(),
+      port: Number.isFinite(parsedPort) ? parsedPort : 5173,
+      open: options.open
+    });
+  } catch (error) {
+    console.error(chalk6.red(error.message));
+    process.exit(1);
+  }
+});
+program.command("validate").description("Validate project structure, types, and asset references").action(async () => {
+  try {
+    const report = await runValidation({ projectDirectory: process.cwd() });
+    const formatFinding = (finding) => {
+      const locationParts = [finding.filePath];
+      if (finding.line !== void 0) {
+        locationParts.push(String(finding.line));
+        if (finding.column !== void 0) {
+          locationParts.push(String(finding.column));
+        }
+      }
+      return `${locationParts.join(":")}: ${finding.code}: ${finding.message}`;
+    };
+    for (const warning of report.warnings) {
+      console.warn(chalk6.yellow(formatFinding(warning)));
+    }
+    for (const error of report.errors) {
+      console.error(chalk6.red(formatFinding(error)));
+    }
+    if (report.errors.length === 0 && report.warnings.length === 0) {
+      console.log(chalk6.green("donut validate: no problems found"));
+    }
+    process.exit(report.errors.length === 0 ? 0 : 1);
+  } catch (error) {
+    console.error(chalk6.red(error.message));
+    process.exit(1);
+  }
+});
+program.command("build").description("Build a distributable .donut bundle for the project").option("--output <dir>", "output directory for the bundle", "dist").action(async (options) => {
+  const projectDirectory = process.cwd();
+  const outputDirectory = path9.isAbsolute(options.output) ? options.output : path9.join(projectDirectory, options.output);
+  try {
+    const report = await runBuild({ projectDirectory, outputDirectory });
+    for (const warning of report.warnings) {
+      console.warn(chalk6.yellow(`${warning.filePath}:${warning.line}: warning: matched /${warning.pattern}/ ("${warning.match}")`));
+    }
+    console.log(chalk6.green(`donut build: wrote ${report.bundlePath} (${report.bundleSizeBytes} bytes) in ${report.buildTimeMilliseconds}ms`));
+  } catch (error) {
+    if (error instanceof BuildViolationError) {
+      console.error(chalk6.red(error.message));
+      for (const violation of error.violations) {
+        console.error(chalk6.red(`  ${violation.filePath}:${violation.line}: matched /${violation.pattern}/ ("${violation.match}")`));
+      }
+    } else {
+      console.error(chalk6.red(error.message));
+    }
+    process.exit(1);
+  }
+});
+program.command("publish").description("Publish a built .donut bundle (dry-run by default)").option("--bundle <path>", "explicit path to a .donut bundle to publish").option("--auth-token <token>", "bearer token for the upload endpoint").action(async (options) => {
+  try {
+    const report = await runPublish({
+      projectDirectory: process.cwd(),
+      bundlePath: options.bundle,
+      authToken: options.authToken
+    });
+    if (report.success) {
+      console.log(chalk6.green(`donut publish: ${report.gameUrl}`));
+    }
+  } catch (error) {
+    console.error(chalk6.red(error.message));
+    process.exit(1);
+  }
+});
+program.command("review").description("Run AI-assisted security/style review on the project sources").option("--bundle <path>", "review the sources packaged into a built bundle").action(async (options) => {
+  try {
+    const report = await runReview({
+      projectDirectory: process.cwd(),
+      bundlePath: options.bundle
+    });
+    if (report.overallPass === false) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk6.red(error.message));
+    process.exit(1);
+  }
+});
+var isRunningAsMain = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("/donut") === true || process.argv[1]?.endsWith("\\donut") === true || process.argv[1]?.endsWith("cli/src/index.ts") === true || process.argv[1]?.endsWith("cli/dist/index.js") === true;
+if (isRunningAsMain) {
+  program.parseAsync(process.argv);
+}
+
+// src/donut.ts
+await program.parseAsync(process.argv);
+//# sourceMappingURL=donut.js.map