@volter/game-editor 0.5.65

package/dist-node/create.js

@@ -0,0 +1,3239 @@
+// node/create.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join6, resolve as resolve4 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// node/scaffold/additions.ts
+var SCAFFOLD_ADDITIONS = ["three", "ui", "server", "blender", "studio"];
+var ADDITION_REQUIRES = {
+  studio: ["three"]
+};
+function closeAdditions(additions) {
+  const wanted = /* @__PURE__ */ new Set();
+  const visit2 = (addition) => {
+    if (wanted.has(addition)) return;
+    wanted.add(addition);
+    for (const required of ADDITION_REQUIRES[addition] ?? []) visit2(required);
+  };
+  for (const addition of additions) visit2(addition);
+  return SCAFFOLD_ADDITIONS.filter((addition) => wanted.has(addition));
+}
+var THREE_OWNED_PATHS = [
+  "src/lib/audio",
+  "src/world.tsx",
+  "src/scenes",
+  "src/prefabs",
+  "src/components",
+  "src/bot"
+];
+var KIT_DECLARED_PACKAGES = [
+  "@volter/editor-blender",
+  "@volter/blender-engine",
+  "@volter/editor-core",
+  "@volter/editor-sdk",
+  "@volter/game-runtime",
+  "@volter/editor-live",
+  "@volter/game-live",
+  "@volter/editor-project",
+  "@volter/threejs-runtime"
+];
+var STUDIO_OWNED_PATHS = [
+  "src/contributions/data.document.tsx",
+  "src/contributions/tester.inspector.tsx",
+  "src/contributions/analytics.analytics.tsx"
+];
+var REACT_ONLY_REMOVED_PATHS = [
+  "src/runtime",
+  "src/scripts",
+  "src/prefabs",
+  "src/stage",
+  "src/world.tsx",
+  "src/lib/humanoid",
+  "src/lib/mesh",
+  "src/lib/native-three",
+  "src/components",
+  "public"
+];
+var REACT_ONLY_PAGE_SOURCE = `export interface ReactGamePageProps {
+  readonly lastInput: string;
+  readonly title?: string;
+}
+
+/** Pure React-only game page. Runtime input ownership stays in game.tsx. */
+export function ReactGamePage({ lastInput, title = 'My Game' }: ReactGamePageProps) {
+  return (
+    <main
+      data-testid="game-ui-root"
+      style={{
+        position: 'absolute',
+        inset: 0,
+        display: 'grid',
+        placeItems: 'center',
+        pointerEvents: 'auto',
+        color: '#f7f4ea',
+        background: 'radial-gradient(circle at 50% 30%, #26314b 0%, #111827 68%)',
+        fontFamily: 'system-ui, sans-serif',
+      }}
+    >
+      <section style={{ textAlign: 'center', padding: 32 }}>
+        <p style={{ margin: 0, color: '#93c5fd', fontWeight: 700, letterSpacing: 2 }}>
+          REACT ADAPTER ROOT
+        </p>
+        <h1 style={{ margin: '8px 0', fontSize: 'clamp(42px, 8vw, 86px)' }}>{title}</h1>
+        <p aria-live="polite" style={{ margin: 0, color: '#cbd5e1' }}>
+          Last input: {lastInput}
+        </p>
+      </section>
+    </main>
+  );
+}
+`;
+var REACT_ONLY_GAME_SOURCE = `import { useEffect, useState } from 'react';
+import { useDebugProvider } from '@volter/game-runtime/react/world-state';
+import { ReactGamePage } from './game-page';
+
+/** React-only live connector: DOM input is gameplay input; no canvas adapter is required. */
+export default function GameUI() {
+  const [lastInput, setLastInput] = useState('Ready');
+
+  useEffect(() => {
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key.startsWith('Arrow')) setLastInput(event.key);
+    };
+    window.addEventListener('keydown', onKeyDown);
+    return () => window.removeEventListener('keydown', onKeyDown);
+  }, []);
+
+  useDebugProvider('react-starter', () => ({ lastInput }));
+
+  return <ReactGamePage lastInput={lastInput} />;
+}
+`;
+var REACT_ONLY_STORY_SOURCE = `import type { Meta, StoryObj } from '@storybook/react';
+import GameUI from './game';
+import { ReactGamePage } from './game-page';
+
+const meta = {
+  title: 'Game/React Root',
+  // \`component\` is what associates this CSF document with a root: the editor
+  // derives it from the component the stories are about, and \`GameUI\` is the
+  // \`ui\` root's manifest entry. It owns live input state, so the design-time
+  // states below render its presentational body with authored props.
+  component: GameUI,
+  render: (args) => <ReactGamePage {...args} />,
+  parameters: { vgai: { defaultStory: 'Ready' } },
+  args: { lastInput: 'Ready', title: 'My Game' },
+} satisfies Meta<typeof ReactGamePage>;
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+export const Ready: Story = {};
+export const ArrowUp: Story = { args: { lastInput: 'ArrowUp' } };
+export const ArrowLeft: Story = { args: { lastInput: 'ArrowLeft' } };
+export const LongTitle: Story = {
+  args: { title: 'The Long Way Home', lastInput: 'ArrowRight' },
+};
+`;
+var REACT_ONLY_MAIN_SOURCE = `import { manifestEntryModules } from 'virtual:vgai-manifest-entries';
+import { registerReactAdapter } from './lib/react-root';
+import { mountGameFromManifest, type ManifestHost } from '@volter/game-runtime/runtime/mount-game';
+import manifest from '../vgai.project.json';
+
+registerReactAdapter();
+
+async function main() {
+  document.title = manifest.name;
+  const container = document.getElementById('game-canvas') as HTMLElement;
+  const host: ManifestHost = {
+    container,
+    async loadEntryModule(path) {
+      const entryModule = manifestEntryModules[path];
+      if (!entryModule) {
+        throw new Error(
+          \`main.ts: entry module "\${path}" was not generated from vgai.project.json.\`,
+        );
+      }
+      return entryModule;
+    },
+  };
+  const session = await mountGameFromManifest(manifest, host);
+  const resize = () => session.resize(window.innerWidth, window.innerHeight);
+  resize();
+  window.addEventListener('resize', resize);
+}
+
+main().catch(console.error);
+`;
+var REACT_ONLY_FILES = {
+  "src/main.ts": REACT_ONLY_MAIN_SOURCE,
+  "src/ui/game-page.tsx": REACT_ONLY_PAGE_SOURCE,
+  "src/ui/game.tsx": REACT_ONLY_GAME_SOURCE,
+  "src/ui/game.stories.tsx": REACT_ONLY_STORY_SOURCE
+};
+function withEditorDeclaration(source, declaration2) {
+  if (!source.includes("defineAdapter({"))
+    throw new Error("Starter vgai.adapter.ts must call defineAdapter({ ... }).");
+  const look = [
+    declaration2.style ? `, style: ${declaration2.style.name}` : "",
+    declaration2.keymap ? `, keymap: ${declaration2.keymap.name}` : ""
+  ].join("");
+  const editor = `  editor: { Layout: ${declaration2.layout.name}${look}, inspector: '${declaration2.inspector}' },`;
+  const byModule = /* @__PURE__ */ new Map();
+  for (const value of [declaration2.layout, declaration2.style, declaration2.keymap]) {
+    if (!value) continue;
+    const names = byModule.get(value.from) ?? /* @__PURE__ */ new Set();
+    names.add(value.name);
+    byModule.set(value.from, names);
+  }
+  const imports = [...byModule].map(([from, names]) => `import { ${[...names].sort().join(", ")} } from '${from}';
+`).join("");
+  return `${imports}${source.replace("defineAdapter({", `defineAdapter({
+${editor}`)}`;
+}
+var MODELS_AGENTS_CONTRACT = `# AGENTS.md \u2014 VGAI Models Project
+
+A standalone modeling project built with VGAI \u2014 Blender itself, compiled to
+WebAssembly and running headless in the editor tab's worker, over this
+project's own \`.blend\` files. Work here, not in the engine repo. The editor
+is the authoring and verification surface; nothing here plays.
+
+## Route the request first
+
+| Intent | First action |
+| --- | --- |
+| Model, revise or add a model | \`src/models/<name>.blend\` \u2014 read \`src/models/cube.py\`'s docstring first |
+| Open the editor, look, or verify | \`.agents/skills/editor/SKILL.md\` |
+| Blender-style modeling craft | \`.agents/skills/vgai-3d-models/SKILL.md\` |
+
+\`.agents/\` is canonical; \`.claude/skills/\` and \`.github/skills/\` are
+generated projections (never edit); \`CLAUDE.md\` and
+\`.github/copilot-instructions.md\` only point here.
+
+## What a model is
+
+A model is a \`.blend\` under \`src/models/\` \u2014 Blender's own document, opened,
+edited and saved by the Blender running in the editor tab. Beside it sits the
+bpy script that authored it (\`cube.blend\` / \`cube.py\`): the script is the
+asset's SOURCE and stays in the project, the \`.blend\` is what the editor
+opens. The document does not run the script \u2014 you do, through the session's
+Blender:
+
+\`\`\`bash
+npm run --silent vgai -- blender-mcp    # the MCP transport onto the tab's Blender
+\`\`\`
+
+Every call is ordinary bpy against the open document, and the session saves it
+about a second after your last call. The adapter's \`modelsFromBlendFiles\`
+finder lists every \`.blend\` as a document. Coordinates are metres and Z is up
+(Blender's); the glTF export converts to the game's Y-up.
+
+## The editor
+
+Workspaces: \`model\`, \`sculpt\`, \`texture\`, \`animate\`, \`design\`, \`look\`
+(\`npm run --silent vgai -- eval 'editor.workspace("sculpt")'\`; a wrong id
+refuses and names the list). The look and keymap are Blender's
+(\`@volter/editor-blender\` contributes them). There is no Game workspace and
+\`vgai play\` refuses: this project declares no roots.
+
+## Verification contract \u2014 after every change
+
+1. \`npm run typecheck\` \u2014 the gate.
+2. Open the model's document and read the change through a door:
+   \`npm run --silent vgai -- eval 'editor.currentView()'\` names the open
+   document; \`npm run --silent vgai -- screenshot editor\` shows it; and
+   \`get_scene_info\` over \`blender-mcp\` is what the engine itself says is in
+   the file.
+3. \`npm run --silent vgai -- console\` silent \u2014 an unresolved entry is
+   remaining work, never noise.
+
+## Commands
+
+\\\`\\\`\\\`bash
+npm run dev                            # open/reuse this project's editor
+npm run --silent vgai -- status        # require connected: true
+npm run --silent vgai -- screenshot    # visible evidence
+npm run --silent vgai -- eval '<js>'   # THE door onto the editor
+npm run typecheck                      # THE gate
+\\\`\\\`\\\`
+
+Always \`npm run --silent vgai -- <verb>\`, never a bare \`vgai\` (a global one may
+belong to another checkout).
+`;
+function withAgentsContract(source, additions) {
+  const plays = additions.has("three") || additions.has("ui");
+  return additions.has("blender") && !plays ? MODELS_AGENTS_CONTRACT : source;
+}
+var PAGES_FINDER_SELECTION = "{ finder: 'pagesFromUiModules', include: ['src/ui/**/*page.tsx'] }";
+var MODELS_FINDER_SELECTION = "{ finder: 'modelsFromBlendFiles', include: ['src/models/**/*.blend'] }";
+var UI_REGION_INCLUDE = "ui: {\n      include: ['src/ui/**/*.tsx'],\n    },";
+function joinAdditionFinders(adapterSource, additions) {
+  const joined = [];
+  if (additions.has("ui")) joined.push(PAGES_FINDER_SELECTION);
+  if (additions.has("blender")) joined.push(MODELS_FINDER_SELECTION);
+  if (joined.length === 0) return adapterSource;
+  const withRegion = additions.has("ui") ? adapterSource.replace("regionIncludes: {", `regionIncludes: {
+    ${UI_REGION_INCLUDE}`) : adapterSource;
+  return withRegion.replace(
+    "{ finder: 'prefabsFromStories' },",
+    `{ finder: 'prefabsFromStories' },${joined.map((f) => `
+      ${f},`).join("")}`
+  );
+}
+function adapterSourceFor(additions) {
+  const finders = [];
+  if (additions.has("ui")) {
+    finders.push(PAGES_FINDER_SELECTION);
+  }
+  if (additions.has("blender")) {
+    finders.push(MODELS_FINDER_SELECTION);
+  }
+  const regions = additions.has("ui") ? `
+  regionIncludes: {
+    ${UI_REGION_INCLUDE}
+  },` : "";
+  const documents = finders.length > 0 ? `
+  documents: {
+    find: [${finders.map((f) => `
+      ${f},`).join("")}
+    ],
+  },
+` : "";
+  return `import { defineAdapter } from '@volter/editor-project/adapter/adapter-module';
+
+export default defineAdapter({${regions}${documents}});
+`;
+}
+
+// node/scaffold/product.ts
+function fail(source, message) {
+  throw new Error(`${source}: ${message}`);
+}
+function assertImportedValue(value, source, field) {
+  const record = value;
+  if (typeof record?.name !== "string" || record.name.length === 0)
+    fail(source, `${field}.name must be the exported binding to import, e.g. "GameLayout"`);
+  if (typeof record.from !== "string" || record.from.length === 0)
+    fail(
+      source,
+      `${field}.from must be the module it is imported from, e.g. "@volter/editor-blender/layouts"`
+    );
+  return { name: record.name, from: record.from };
+}
+function assertScaffoldComposition(value, source, product) {
+  const composition = value;
+  const packages = composition?.editorPackages;
+  if (!Array.isArray(packages) || packages.some((name) => typeof name !== "string" || !name))
+    fail(source, "compose() must return editorPackages: a list of package names");
+  if (!packages.includes(product))
+    fail(
+      source,
+      `compose() returned editorPackages ${JSON.stringify(packages)}, which omits ${product}. A scaffolded project declares the product it opens in \u2014 that declaration is how \`vgai edit\` finds the editor to run (ARCHITECTURE-CORE \xA7The target shape, rule 4).`
+    );
+  const editor = composition?.editor;
+  if (typeof editor?.inspector !== "string" || editor.inspector.length === 0)
+    fail(
+      source,
+      "compose() must return editor.inspector \u2014 which Inspector presentation this project opens with"
+    );
+  return {
+    editorPackages: [...packages],
+    editor: {
+      layout: assertImportedValue(editor.layout, source, "compose().editor.layout"),
+      ...editor.style === void 0 ? {} : { style: assertImportedValue(editor.style, source, "compose().editor.style") },
+      ...editor.keymap === void 0 ? {} : { keymap: assertImportedValue(editor.keymap, source, "compose().editor.keymap") },
+      inspector: editor.inspector
+    }
+  };
+}
+
+// node/scaffold/scaffold.ts
+import { spawnSync } from "node:child_process";
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync3,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { basename, dirname as dirname2, join as join4, relative as relative3, resolve as resolve2 } from "node:path";
+
+// ../../node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// ../../node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// ../../node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+
+// ../editor-project/src/manifest/locate.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+// ../editor-project/src/manifest/filename.ts
+var MANIFEST_FILENAME = "vgai.project.json";
+var REMOVED_MANIFEST_FILENAME = "vgai.game.json";
+function removedManifestFilenameMessage(where) {
+  return `${where}: found \`${REMOVED_MANIFEST_FILENAME}\` and no \`${MANIFEST_FILENAME}\`. \`${REMOVED_MANIFEST_FILENAME}\` was REMOVED (the legacy-removal doctrine, docs/ARCHITECTURE-CORE.md \xA7Vocabulary) \u2014 nothing reads it any more, and it is deliberately NOT read as a fallback, because a second accepted name is the defect.
+Fix: rename it \u2014 \`git mv ${REMOVED_MANIFEST_FILENAME} ${MANIFEST_FILENAME}\`. The contents are unchanged; only the filename moved.`;
+}
+
+// ../editor-project/src/manifest/locate.ts
+function assertNoRemovedManifestFilename(dir) {
+  if (existsSync(join(dir, MANIFEST_FILENAME))) return;
+  if (!existsSync(join(dir, REMOVED_MANIFEST_FILENAME))) return;
+  throw new Error(removedManifestFilenameMessage(join(dir, REMOVED_MANIFEST_FILENAME)));
+}
+function resolveManifestPath(dir) {
+  assertNoRemovedManifestFilename(dir);
+  return join(dir, MANIFEST_FILENAME);
+}
+function hasManifest(dir) {
+  assertNoRemovedManifestFilename(dir);
+  return existsSync(join(dir, MANIFEST_FILENAME));
+}
+
+// node/scaffold/baseline.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+var SCAFFOLD_BASELINE_RELATIVE_PATH = ".vgai/scaffold-baseline.json";
+function readEngineSourceState(engineDir) {
+  try {
+    const sha = execFileSync("git", ["-C", engineDir, "rev-parse", "HEAD"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const status = execFileSync("git", ["-C", engineDir, "status", "--porcelain", "--", "."], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return { sha, dirty: status.trim().length > 0 };
+  } catch {
+    return void 0;
+  }
+}
+function hashFile(absPath) {
+  return createHash("sha256").update(readFileSync(absPath)).digest("hex");
+}
+function listFilesRecursive(dir, base = dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listFilesRecursive(full, base));
+    } else if (entry.isFile()) {
+      out.push(relative(base, full).split(sep).join("/"));
+    }
+  }
+  return out;
+}
+function buildScaffoldBaseline(targetDir, engineVersion, engineDir) {
+  const relPaths = listFilesRecursive(targetDir).filter((p) => p !== SCAFFOLD_BASELINE_RELATIVE_PATH).sort();
+  const files = {};
+  for (const relPath of relPaths) {
+    files[relPath] = hashFile(join2(targetDir, relPath));
+  }
+  const engineSource = engineDir ? readEngineSourceState(engineDir) : void 0;
+  return { engineVersion, ...engineSource ? { engineSource } : {}, files };
+}
+function writeScaffoldBaseline(targetDir, engineVersion, engineDir) {
+  const baseline = buildScaffoldBaseline(targetDir, engineVersion, engineDir);
+  mkdirSync(join2(targetDir, ".vgai"), { recursive: true });
+  writeFileSync(
+    join2(targetDir, SCAFFOLD_BASELINE_RELATIVE_PATH),
+    `${JSON.stringify(baseline, null, 2)}
+`,
+    "utf-8"
+  );
+  return baseline;
+}
+
+// node/scaffold/catalog.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname, isAbsolute, join as join3, relative as relative2, resolve, sep as sep2 } from "node:path";
+
+// node/scaffold/adapter-region-merge.ts
+import ts from "typescript";
+function quoteLike(source, sample) {
+  const double = sample !== void 0 && source[sample.getStart()] === '"';
+  return (value) => double || value.includes("'") ? JSON.stringify(value) : `'${value}'`;
+}
+function stringLiteralOf(node) {
+  return node && ts.isStringLiteralLike(node) ? node.text : void 0;
+}
+function propertyOf(object, name) {
+  for (const member of object.properties) {
+    if (!ts.isPropertyAssignment(member)) continue;
+    const key = ts.isIdentifier(member.name) ? member.name.text : stringLiteralOf(member.name);
+    if (key === name) return member;
+  }
+  return void 0;
+}
+function definitionObject(source) {
+  for (const statement of source.statements) {
+    if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+    const call = statement.expression;
+    if (!ts.isCallExpression(call)) {
+      return { reason: "its default export is not a direct `defineAdapter({\u2026})` call" };
+    }
+    const arg = call.arguments[0];
+    if (arg === void 0) {
+      return { reason: "its default export takes no argument object to declare into" };
+    }
+    if (!ts.isObjectLiteralExpression(arg)) {
+      return { reason: "its default export is not called with an object literal" };
+    }
+    return { object: arg };
+  }
+  return { reason: "it has no default export" };
+}
+function indentAt(text, position) {
+  const lineStart = text.lastIndexOf("\n", position - 1) + 1;
+  const match = /^[ \t]*/.exec(text.slice(lineStart, position));
+  return match?.[0] ?? "";
+}
+function appendToArray(text, array, globs) {
+  const last = array.elements[array.elements.length - 1];
+  const closing = array.getEnd() - 1;
+  const inner = last ? indentAt(text, last.getStart()) : `${indentAt(text, array.getStart())}  `;
+  const quote = quoteLike(text, last);
+  const body = globs.map((glob) => `${inner}${quote(glob)},`).join("\n");
+  const start = text.slice(0, closing).replace(/\s+$/, "").length;
+  const needsComma = last !== void 0 && text[start - 1] !== ",";
+  return {
+    start,
+    end: closing,
+    text: `${needsComma ? "," : ""}
+${body}
+${indentAt(text, array.getStart())}`
+  };
+}
+function appendProperty(text, object, property) {
+  const last = object.properties[object.properties.length - 1];
+  const closing = object.getEnd() - 1;
+  const outer = indentAt(text, object.getStart());
+  const inner = last ? indentAt(text, last.getStart()) : `${outer}  `;
+  const start = text.slice(0, closing).replace(/\s+$/, "").length;
+  const needsComma = last !== void 0 && text[start - 1] !== ",";
+  return { start, end: closing, text: `${needsComma ? "," : ""}
+${property(inner)}
+${outer}` };
+}
+function regionEntryText(indent, addition, quote) {
+  const globs = addition.globs.map((glob) => `${indent}    ${quote(glob)},`).join("\n");
+  const key = /^[A-Za-z_$][\w$]*$/.test(addition.rootId) ? addition.rootId : quote(addition.rootId);
+  return `${indent}${key}: {
+${indent}  include: [
+${globs}
+${indent}  ],
+${indent}},`;
+}
+function mergeAdapterRegionIncludes(source, additions) {
+  if (additions.length === 0) return { kind: "unchanged" };
+  const parsed = ts.createSourceFile("vgai.adapter.ts", source, ts.ScriptTarget.Latest, true);
+  const definition = definitionObject(parsed);
+  if ("reason" in definition) return { kind: "unreadable", reason: definition.reason };
+  const listed = propertyOf(definition.object, "regions");
+  if (listed && !ts.isStringLiteralLike(listed.initializer)) {
+    return {
+      kind: "unreadable",
+      reason: "it states an explicit `regions` list, whose entries carry their own `include`"
+    };
+  }
+  const splices = [];
+  const added = [];
+  const overlay = propertyOf(definition.object, "regionIncludes");
+  const quote = quoteLike(source, void 0);
+  if (!overlay) {
+    for (const addition of additions) added.push(...addition.globs);
+    splices.push(
+      appendProperty(source, definition.object, (indent) => {
+        const entries = additions.map((addition) => regionEntryText(`${indent}  `, addition, quote)).join("\n");
+        return `${indent}regionIncludes: {
+${entries}
+${indent}},`;
+      })
+    );
+  } else {
+    if (!ts.isObjectLiteralExpression(overlay.initializer)) {
+      return { kind: "unreadable", reason: "`regionIncludes` is not an object literal" };
+    }
+    const table = overlay.initializer;
+    for (const addition of additions) {
+      const entry = propertyOf(table, addition.rootId);
+      if (!entry) {
+        added.push(...addition.globs);
+        splices.push(
+          appendProperty(source, table, (indent) => regionEntryText(indent, addition, quote))
+        );
+        continue;
+      }
+      if (!ts.isObjectLiteralExpression(entry.initializer)) {
+        return {
+          kind: "unreadable",
+          reason: `\`regionIncludes.${addition.rootId}\` is not an object literal`
+        };
+      }
+      const include = propertyOf(entry.initializer, "include");
+      if (!include) {
+        added.push(...addition.globs);
+        splices.push(
+          appendProperty(source, entry.initializer, (indent) => {
+            const globs = addition.globs.map((glob) => `${indent}  ${quote(glob)},`).join("\n");
+            return `${indent}include: [
+${globs}
+${indent}],`;
+          })
+        );
+        continue;
+      }
+      if (!ts.isArrayLiteralExpression(include.initializer)) {
+        return {
+          kind: "unreadable",
+          reason: `\`regionIncludes.${addition.rootId}.include\` is not an array literal`
+        };
+      }
+      const declared = new Set(
+        include.initializer.elements.map((element) => stringLiteralOf(element))
+      );
+      if (declared.has(void 0)) {
+        return {
+          kind: "unreadable",
+          reason: `\`regionIncludes.${addition.rootId}.include\` holds something other than string literals`
+        };
+      }
+      const missing = addition.globs.filter((glob) => !declared.has(glob));
+      if (missing.length === 0) continue;
+      added.push(...missing);
+      splices.push(appendToArray(source, include.initializer, missing));
+    }
+  }
+  if (splices.length === 0) return { kind: "unchanged" };
+  let text = source;
+  for (const splice of [...splices].sort((a, b) => b.start - a.start)) {
+    text = text.slice(0, splice.start) + splice.text + text.slice(splice.end);
+  }
+  return { kind: "merged", text, added };
+}
+
+// node/scaffold/catalog.ts
+var PROJECT_CATALOG_DIR = join3(".vgai", "catalog");
+var DEFAULT_REACT_CAPABILITIES = ["react-root"];
+var CATALOG_SURFACES = ["three", "canvas", "dom"];
+var CAPABILITY_STAMP_FILENAME = "capability.json";
+function capabilityStampPath(entry) {
+  const libDir = entry.files.filter((file) => file.startsWith(`src/lib/${entry.id}/`)).map((file) => file.split("/").slice(0, 3).join("/"))[0];
+  return libDir ? `${libDir}/${CAPABILITY_STAMP_FILENAME}` : `src/tools/${entry.id}.${CAPABILITY_STAMP_FILENAME}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value, field, manifestPath) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`${manifestPath}: ${field} must be an array of strings`);
+  }
+  return value;
+}
+var RENAMED_CAPABILITY_IDS = /* @__PURE__ */ new Map([["mesh", "blender"]]);
+function renamedCapabilityIdMessage(where, oldId, newId) {
+  return `${where}: capability id \`${oldId}\` was RENAMED to \`${newId}\` (2026-09-19). Nothing reads \`${oldId}\` any more, and it is deliberately NOT mapped onto \`${newId}\`, because a second accepted name is the defect.
+Fix: in this project, rename the file \u2014 \`git mv .vgai/catalog/${oldId}.json .vgai/catalog/${newId}.json\` \u2014 and change its \`"id"\` to \`"${newId}"\`. If a stamp file names the old id, rename that too (\`src/tools/${oldId}.*\` -> \`src/tools/${newId}.*\`). Then \`vgai outdated\` will report against the current entry. Nothing else about the capability changed.`;
+}
+function readCatalogEntry(path) {
+  const parsed = JSON.parse(readFileSync2(path, "utf8"));
+  if (!isRecord(parsed)) throw new Error(`${path}: capability manifest must be an object`);
+  for (const field of ["description", "id", "title"]) {
+    if (typeof parsed[field] !== "string" || parsed[field].length === 0) {
+      throw new Error(`${path}: ${field} must be a non-empty string`);
+    }
+  }
+  const renamedTo = RENAMED_CAPABILITY_IDS.get(parsed["id"]);
+  if (renamedTo !== void 0) {
+    throw new Error(renamedCapabilityIdMessage(path, parsed["id"], renamedTo));
+  }
+  if (typeof parsed["version"] !== "string" || !/^\d+\.\d+\.\d+$/.test(parsed["version"])) {
+    throw new Error(`${path}: version must be a semver string like "0.1.0"`);
+  }
+  const manifest = {
+    description: parsed["description"],
+    files: stringArray(parsed["files"], "files", path),
+    id: parsed["id"],
+    requires: stringArray(parsed["requires"], "requires", path),
+    skills: stringArray(parsed["skills"], "skills", path),
+    title: parsed["title"],
+    version: parsed["version"]
+  };
+  if (parsed["packageJson"] !== void 0) {
+    if (!isRecord(parsed["packageJson"])) {
+      throw new Error(`${path}: packageJson must be an object`);
+    }
+    const packageJson = parsed["packageJson"];
+    const dependencies = readStringRecord(packageJson["dependencies"], "dependencies", path);
+    const devDependencies = readStringRecord(
+      packageJson["devDependencies"],
+      "devDependencies",
+      path
+    );
+    const scripts = readStringRecord(packageJson["scripts"], "scripts", path);
+    const vgaiTools = packageJson["vgaiTools"];
+    if (vgaiTools !== void 0 && (!Array.isArray(vgaiTools) || vgaiTools.some((entry) => typeof entry !== "string" && !isRecord(entry)))) {
+      throw new Error(`${path}: packageJson.vgaiTools must be an array of module paths`);
+    }
+    manifest.packageJson = {
+      ...dependencies ? { dependencies } : {},
+      ...devDependencies ? { devDependencies } : {},
+      ...scripts ? { scripts } : {},
+      ...vgaiTools ? { vgaiTools } : {}
+    };
+  }
+  const assetPacks = readAssetPacks(parsed["assetPacks"], path);
+  if (assetPacks) manifest.assetPacks = assetPacks;
+  const regions = readRegions(parsed["regions"], path);
+  if (regions) manifest.regions = regions;
+  assertJsxSurfacesDeclared(manifest, path);
+  return manifest;
+}
+function readRegions(value, manifestPath) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) throw new Error(`${manifestPath}: regions must be an object`);
+  const regions = {};
+  for (const [surface, globs] of Object.entries(value)) {
+    if (!CATALOG_SURFACES.includes(surface)) {
+      throw new Error(
+        `${manifestPath}: regions key must be one of ${CATALOG_SURFACES.join(", ")} \u2014 got ${surface}`
+      );
+    }
+    const list = stringArray(globs, `regions.${surface}`, manifestPath);
+    if (list.length === 0) {
+      throw new Error(`${manifestPath}: regions.${surface} must name at least one glob`);
+    }
+    for (const glob of list) assertRelativeProjectPath(glob);
+    regions[surface] = list;
+  }
+  return regions;
+}
+function globToRegExp(glob) {
+  let out = "";
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        out += glob[i + 2] === "/" ? "(?:.*/)?" : ".*";
+        i += glob[i + 2] === "/" ? 3 : 2;
+        continue;
+      }
+      out += "[^/]*";
+      i += 1;
+      continue;
+    }
+    if (ch === "?") {
+      out += "[^/]";
+      i += 1;
+      continue;
+    }
+    out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    i += 1;
+  }
+  return new RegExp(`^${out}$`);
+}
+function assertJsxSurfacesDeclared(manifest, manifestPath) {
+  const globs = Object.values(manifest.regions ?? {}).flat().map(globToRegExp);
+  const undeclared = manifest.files.filter(
+    (file) => file.endsWith(".tsx") && !file.startsWith("src/tools/") && !file.startsWith("src/contributions/") && !globs.some((pattern) => pattern.test(file))
+  );
+  if (undeclared.length > 0) {
+    throw new Error(
+      `${manifestPath}: these .tsx files name no surface in \`regions\` \u2014 ${undeclared.join(", ")}. The editor stamps one source-id attribute per file and the default (\`data-oid\`) is correct only for React DOM; an R3F component that takes it breaks the running game (fiber pierces the dash and throws on the second apply). Declare each file under the surface it renders on \u2014 \`three\`, \`canvas\`, or \`dom\`.`
+    );
+  }
+}
+function readAssetPacks(value, manifestPath) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) throw new Error(`${manifestPath}: assetPacks must be an object`);
+  const packs = {};
+  for (const [pack, entries] of Object.entries(value)) {
+    if (pack.length === 0) throw new Error(`${manifestPath}: an assetPacks name must be non-empty`);
+    if (!Array.isArray(entries)) {
+      throw new Error(`${manifestPath}: assetPacks.${pack} must be an array`);
+    }
+    packs[pack] = entries.map((entry) => {
+      if (!isRecord(entry))
+        throw new Error(`${manifestPath}: assetPacks.${pack} entries must be objects`);
+      const { key, dest, sha256 } = entry;
+      if (typeof key !== "string" || !/^[^:]+:.+$/.test(key)) {
+        throw new Error(`${manifestPath}: assetPacks.${pack} entry key must be "source:id"`);
+      }
+      if (typeof dest !== "string" || dest.length === 0) {
+        throw new Error(`${manifestPath}: assetPacks.${pack} entry dest must be a non-empty path`);
+      }
+      assertRelativeProjectPath(dest);
+      if (typeof sha256 !== "string" || !/^[a-f0-9]{64}$/.test(sha256)) {
+        throw new Error(
+          `${manifestPath}: assetPacks.${pack} entry sha256 must be 64 lowercase hex digits`
+        );
+      }
+      return { key, dest, sha256 };
+    });
+  }
+  return packs;
+}
+function readStringRecord(value, field, manifestPath) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value) || Object.values(value).some((entry) => typeof entry !== "string")) {
+    throw new Error(`${manifestPath}: packageJson.${field} must map strings to strings`);
+  }
+  return value;
+}
+function listManifestPaths(catalogDir) {
+  if (!existsSync2(catalogDir)) throw new Error(`Catalog entries not found: ${catalogDir}`);
+  return readdirSync2(catalogDir).filter((name) => name.endsWith(".json")).sort().map((name) => join3(catalogDir, name));
+}
+function readCatalog(catalogDir) {
+  const manifests = listManifestPaths(join3(catalogDir, "entries")).map(readCatalogEntry);
+  const ids = /* @__PURE__ */ new Set();
+  for (const manifest of manifests) {
+    if (ids.has(manifest.id)) throw new Error(`Duplicate capability id: ${manifest.id}`);
+    ids.add(manifest.id);
+  }
+  for (const manifest of manifests) {
+    for (const required of manifest.requires) {
+      if (!ids.has(required)) {
+        throw new Error(`Capability ${manifest.id} requires unknown capability ${required}`);
+      }
+    }
+  }
+  return manifests;
+}
+function initializeProjectCatalog(projectDir, catalogDir) {
+  const targetDir = join3(projectDir, PROJECT_CATALOG_DIR);
+  mkdirSync2(targetDir, { recursive: true });
+  for (const manifestPath of listManifestPaths(join3(catalogDir, "entries"))) {
+    const targetPath = join3(targetDir, manifestPath.slice(manifestPath.lastIndexOf(sep2) + 1));
+    writeFileSync2(targetPath, readFileSync2(manifestPath));
+  }
+}
+function presentCapabilityIds(projectDir, catalogDir) {
+  const resolvedProject = resolve(projectDir);
+  const resolvedCatalog = resolve(catalogDir);
+  let catalog;
+  try {
+    catalog = readCatalog(resolvedCatalog);
+  } catch {
+    return [];
+  }
+  return catalog.filter((manifest) => {
+    if (existsSync2(join3(resolvedProject, capabilityStampPath(manifest)))) return true;
+    const files = entryFiles(manifest, resolvedCatalog);
+    if (files.length === 0) return false;
+    const matching = files.filter((file) => {
+      const target = join3(resolvedProject, file.relativePath);
+      return existsSync2(target) && readFileSync2(target).equals(file.bytes);
+    }).length;
+    return matching * 2 > files.length;
+  }).map((manifest) => manifest.id).sort();
+}
+function assertRelativeProjectPath(path) {
+  if (path.length === 0 || isAbsolute(path) || path.split(/[\\/]/).includes("..")) {
+    throw new Error(`Capability file must be project-relative: ${path}`);
+  }
+}
+function collectFiles(root) {
+  const files = [];
+  const visit2 = (dir) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      const path = join3(dir, entry.name);
+      if (entry.isDirectory()) visit2(path);
+      else if (entry.isFile()) files.push(path);
+    }
+  };
+  visit2(root);
+  return files.sort();
+}
+var PROJECT_SKILL_ROOTS = [
+  join3(".agents", "skills"),
+  join3(".claude", "skills"),
+  join3(".github", "skills")
+];
+function entryFiles(manifest, catalogDir) {
+  const files = [];
+  for (const relativePath of manifest.files) {
+    assertRelativeProjectPath(relativePath);
+    const source = join3(catalogDir, "project-source", relativePath);
+    if (!existsSync2(source) || !statSync(source).isFile()) {
+      throw new Error(`Capability ${manifest.id} source file is missing: ${source}`);
+    }
+    files.push({ bytes: readFileSync2(source), owner: manifest.id, relativePath });
+  }
+  for (const skill of manifest.skills) {
+    if (!/^[a-z0-9-]+$/.test(skill)) throw new Error(`Invalid skill name: ${skill}`);
+    const skillRoot = join3(dirname(catalogDir), "template", ".agents", "skills", skill);
+    if (!existsSync2(skillRoot) || !statSync(skillRoot).isDirectory()) {
+      throw new Error(`Capability ${manifest.id} skill is missing: ${skillRoot}`);
+    }
+    for (const source of collectFiles(skillRoot)) {
+      for (const projectSkillRoot of PROJECT_SKILL_ROOTS) {
+        files.push({
+          bytes: readFileSync2(source),
+          owner: manifest.id,
+          relativePath: join3(projectSkillRoot, skill, relative2(skillRoot, source))
+        });
+      }
+    }
+  }
+  return files;
+}
+function dependencyOrder(ids, byId) {
+  const ordered = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit2 = (id) => {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) throw new Error(`Capability dependency cycle includes ${id}`);
+    const manifest = byId.get(id);
+    if (!manifest) {
+      const renamedTo = RENAMED_CAPABILITY_IDS.get(id);
+      if (renamedTo !== void 0) {
+        throw new Error(
+          `Capability id \`${id}\` was RENAMED to \`${renamedTo}\` (2026-09-19). Nothing accepts \`${id}\` any more, and it is deliberately NOT mapped onto \`${renamedTo}\`, because a second accepted name is the defect.
+Fix: use the current name \u2014 \`${renamedTo}\`. Nothing else changed.`
+        );
+      }
+      throw new Error(
+        `Unknown capability: ${id}
+Available: ${[...byId.keys()].sort().join(", ")}`
+      );
+    }
+    visiting.add(id);
+    for (const required of manifest.requires) visit2(required);
+    visiting.delete(id);
+    visited.add(id);
+    ordered.push(manifest);
+  };
+  for (const id of ids) visit2(id);
+  return ordered;
+}
+function specParts(spec) {
+  const m = /^\s*([\^~]?)=?v?(\d+\.\d+\.\d+(?:-[\w.]+)?)\s*$/.exec(spec);
+  return m ? { prefix: m[1] ?? "", core: m[2] } : null;
+}
+var SPEC_WIDTH = { "^": 2, "~": 1, "": 0 };
+function widerSpec(a, b) {
+  if (a === b) return a;
+  const pa = specParts(a);
+  const pb = specParts(b);
+  if (!pa || !pb || pa.core !== pb.core) return null;
+  return (SPEC_WIDTH[pa.prefix] ?? 0) >= (SPEC_WIDTH[pb.prefix] ?? 0) ? a : b;
+}
+function mergeStringDependencies(target, field, incoming, owner, origins, resolveSpec) {
+  if (!incoming) return;
+  const current = target[field];
+  if (current !== void 0 && !isRecord(current)) {
+    throw new Error(`package.json ${field} must be an object`);
+  }
+  const merged = { ...current ?? {} };
+  for (const [name, declared] of Object.entries(incoming)) {
+    const spec = field === "scripts" ? declared : resolveSpec?.(name, declared) ?? declared;
+    const existing = merged[name];
+    const key = `${field}.${name}`;
+    if (existing !== void 0) {
+      const projectOwned = !origins.has(key);
+      const winner = typeof existing !== "string" ? null : field === "scripts" ? existing === spec ? existing : null : projectOwned ? widerSpec(existing, spec) === null ? null : existing : widerSpec(existing, spec);
+      if (winner === null) {
+        const from = origins.get(key) ?? "the project package.json";
+        throw new Error(
+          `Capability ${owner} requires ${key}=${spec}, but ${from} already set ${key}=${String(existing)}`
+        );
+      }
+      merged[name] = winner;
+      if (winner !== existing) origins.set(key, `capability ${owner}`);
+      continue;
+    }
+    merged[name] = spec;
+    origins.set(key, `capability ${owner}`);
+  }
+  target[field] = Object.fromEntries(Object.entries(merged).sort(([a], [b]) => a.localeCompare(b)));
+}
+function toolIdentity(tool) {
+  if (typeof tool === "string") return tool;
+  const identity = tool["entry"] ?? tool["id"];
+  if (typeof identity !== "string" || identity.length === 0) {
+    throw new Error("Capability tool requires an entry or id");
+  }
+  return identity;
+}
+function planCapabilityPackageJson(originalBytes, manifests, label = "package.json", resolveSpec) {
+  const original = Buffer.from(originalBytes);
+  const parsed = JSON.parse(original.toString("utf8"));
+  if (!isRecord(parsed)) throw new Error(`${label}: package.json must be an object`);
+  const origins = /* @__PURE__ */ new Map();
+  for (const manifest of manifests) {
+    const patch = manifest.packageJson;
+    if (!patch) continue;
+    mergeStringDependencies(
+      parsed,
+      "dependencies",
+      patch.dependencies,
+      manifest.id,
+      origins,
+      resolveSpec
+    );
+    mergeStringDependencies(
+      parsed,
+      "devDependencies",
+      patch.devDependencies,
+      manifest.id,
+      origins,
+      resolveSpec
+    );
+    mergeStringDependencies(parsed, "scripts", patch.scripts, manifest.id, origins);
+    if (patch.vgaiTools) {
+      const vgai = parsed["vgai"] === void 0 ? {} : parsed["vgai"];
+      if (!isRecord(vgai)) throw new Error(`${label}: vgai must be an object`);
+      const currentTools = vgai["tools"] === void 0 ? [] : vgai["tools"];
+      if (!Array.isArray(currentTools) || currentTools.some((tool) => typeof tool !== "string" && !isRecord(tool))) {
+        throw new Error(`${label}: vgai.tools must be an array of strings or objects`);
+      }
+      const tools = currentTools.map(
+        (tool) => typeof tool === "string" ? tool : { ...tool }
+      );
+      for (const tool of patch.vgaiTools) {
+        const id = toolIdentity(tool);
+        const existing = tools.find((candidate) => toolIdentity(candidate) === id);
+        if (existing && JSON.stringify(existing) !== JSON.stringify(tool)) {
+          throw new Error(
+            `Capability ${manifest.id} conflicts with existing vgai.tools entry ${id}`
+          );
+        }
+        if (!existing) tools.push(tool);
+      }
+      tools.sort((a, b) => toolIdentity(a).localeCompare(toolIdentity(b)));
+      vgai["tools"] = tools;
+      parsed["vgai"] = vgai;
+    }
+  }
+  return Buffer.from(`${JSON.stringify(parsed, null, 2)}
+`);
+}
+function mergedPackageJson(projectDir, manifests, resolveSpec) {
+  const path = join3(projectDir, "package.json");
+  const needsMerge = manifests.some((manifest) => manifest.packageJson !== void 0);
+  if (!needsMerge) return void 0;
+  if (!existsSync2(path))
+    throw new Error(`Cannot install capability package changes: ${path} is missing`);
+  const original = readFileSync2(path);
+  const bytes = Buffer.from(planCapabilityPackageJson(original, manifests, path, resolveSpec));
+  return { bytes, changed: !original.equals(bytes) };
+}
+var ASSET_MANIFEST_FILE = "asset-manifest.json";
+function mergedAssetManifest(projectDir, manifests) {
+  const declared = [];
+  for (const manifest of manifests) {
+    for (const [pack, entries] of Object.entries(manifest.assetPacks ?? {})) {
+      for (const entry of entries) declared.push({ ...entry, pack });
+    }
+  }
+  if (declared.length === 0) return void 0;
+  const file = join3(projectDir, ASSET_MANIFEST_FILE);
+  const original = existsSync2(file) ? readFileSync2(file) : Buffer.alloc(0);
+  const parsed = original.length > 0 ? JSON.parse(original.toString("utf8")) : {};
+  if (parsed.packs !== void 0 && !isRecord(parsed.packs)) {
+    throw new Error(`${ASSET_MANIFEST_FILE}: packs must be an object`);
+  }
+  const packs = parsed.packs ?? {};
+  const claimed = new Set(
+    Object.values(packs).flatMap((entries) => entries.map((entry) => entry.dest))
+  );
+  for (const entry of declared) {
+    if (claimed.has(entry.dest)) continue;
+    const existing = packs[entry.pack] ?? [];
+    existing.push({ key: entry.key, dest: entry.dest, sha256: entry.sha256 });
+    packs[entry.pack] = existing;
+    claimed.add(entry.dest);
+  }
+  parsed.packs = packs;
+  const bytes = Buffer.from(`${JSON.stringify(parsed, null, 2)}
+`);
+  const byDest = /* @__PURE__ */ new Map();
+  for (const [pack, entries] of Object.entries(packs)) {
+    for (const entry of entries) {
+      byDest.set(entry.dest, { key: entry.key, dest: entry.dest, sha256: entry.sha256, pack });
+    }
+  }
+  const merged = [...new Set(declared.map((entry) => entry.dest))].map(
+    (dest) => byDest.get(dest)
+  );
+  return { bytes, changed: !original.equals(bytes), declared: merged };
+}
+var ADAPTER_MODULE_FILE = "vgai.adapter.ts";
+function rootSurfaces(projectDir) {
+  const surfaces = /* @__PURE__ */ new Map();
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync2(resolveManifestPath(projectDir), "utf8"));
+  } catch {
+    return surfaces;
+  }
+  if (!isRecord(manifest) || !Array.isArray(manifest["roots"])) return surfaces;
+  for (const root of manifest["roots"]) {
+    if (!isRecord(root) || typeof root["id"] !== "string") continue;
+    const adapter = root["adapter"];
+    const surface = typeof adapter === "string" ? adapter : isRecord(adapter) && typeof adapter["surface"] === "string" ? adapter["surface"] : void 0;
+    if (surface && CATALOG_SURFACES.includes(surface)) {
+      surfaces.set(root["id"], surface);
+    }
+  }
+  return surfaces;
+}
+function mergedAdapterModule(projectDir, manifests) {
+  const declaring = manifests.filter((manifest) => manifest.regions !== void 0);
+  if (declaring.length === 0) return void 0;
+  const surfaces = rootSurfaces(projectDir);
+  const unplaced = [];
+  const byRootId = /* @__PURE__ */ new Map();
+  for (const manifest of declaring) {
+    for (const surface of CATALOG_SURFACES) {
+      const globs = manifest.regions?.[surface];
+      if (globs === void 0) continue;
+      const roots = [...surfaces].filter(([, value]) => value === surface).map(([id]) => id);
+      if (roots.length !== 1) {
+        if (surface === "dom" && roots.length === 0) continue;
+        unplaced.push({
+          capability: manifest.id,
+          globs,
+          reason: roots.length === 0 ? `${projectDir} declares no \`${surface}\` root to own them` : `${projectDir} declares ${roots.length} \`${surface}\` roots (${roots.join(", ")}) \u2014 only the game can say which owns them`,
+          surface
+        });
+        continue;
+      }
+      const rootId = roots[0];
+      byRootId.set(rootId, [...byRootId.get(rootId) ?? [], ...globs]);
+    }
+  }
+  const path = join3(projectDir, ADAPTER_MODULE_FILE);
+  if (byRootId.size === 0 || !existsSync2(path)) {
+    for (const [rootId, globs] of byRootId) {
+      unplaced.push({
+        capability: declaring.map((manifest) => manifest.id).join(", "),
+        globs,
+        reason: `${path} does not exist \u2014 add \`regionIncludes: { ${rootId}: { include: [...] } }\` to one`,
+        surface: surfaces.get(rootId)
+      });
+    }
+    return { bytes: Buffer.alloc(0), changed: false, unplaced };
+  }
+  const additions = [...byRootId].map(([rootId, globs]) => ({ rootId, globs: [...new Set(globs)].sort() })).sort((a, b) => a.rootId.localeCompare(b.rootId));
+  const original = readFileSync2(path);
+  const merge = mergeAdapterRegionIncludes(original.toString("utf8"), additions);
+  if (merge.kind === "unreadable") {
+    for (const addition of additions) {
+      unplaced.push({
+        capability: declaring.map((manifest) => manifest.id).join(", "),
+        globs: [...addition.globs],
+        reason: `${path} could not be edited automatically \u2014 ${merge.reason}. Declare them on the \`${addition.rootId}\` region by hand`,
+        surface: surfaces.get(addition.rootId)
+      });
+    }
+    return { bytes: original, changed: false, unplaced };
+  }
+  if (merge.kind === "unchanged") return { bytes: original, changed: false, unplaced };
+  return { bytes: Buffer.from(merge.text), changed: true, unplaced };
+}
+function addCapabilities(options) {
+  const projectDir = resolve(options.projectDir);
+  const catalogDir = resolve(options.catalogDir);
+  const catalog = readCatalog(catalogDir);
+  const byId = new Map(catalog.map((manifest) => [manifest.id, manifest]));
+  const ordered = dependencyOrder(options.ids, byId);
+  const plannedFiles = ordered.flatMap((manifest) => entryFiles(manifest, catalogDir));
+  const targets = /* @__PURE__ */ new Map();
+  for (const file of plannedFiles) {
+    const prior = targets.get(file.relativePath);
+    if (prior && !prior.bytes.equals(file.bytes)) {
+      throw new Error(
+        `Capabilities ${prior.owner} and ${file.owner} provide different contents for ${file.relativePath}`
+      );
+    }
+    targets.set(file.relativePath, file);
+  }
+  const present = new Set(presentCapabilityIds(projectDir, catalogDir));
+  const alreadyInstalled = ordered.filter((m) => present.has(m.id)).map((m) => m.id);
+  const newManifests = ordered.filter((manifest) => !present.has(manifest.id));
+  const toWrite = [];
+  const kept = [];
+  for (const file of targets.values()) {
+    const target = join3(projectDir, file.relativePath);
+    if (!existsSync2(target)) {
+      toWrite.push(file);
+      continue;
+    }
+    if (!readFileSync2(target).equals(file.bytes) && !present.has(file.owner)) {
+      throw new Error(
+        `Capability ${file.owner} would overwrite existing file: ${file.relativePath}`
+      );
+    }
+    kept.push(file.relativePath);
+  }
+  const packageMerge = mergedPackageJson(projectDir, ordered, options.resolveDependencySpec);
+  const assetMerge = mergedAssetManifest(projectDir, ordered);
+  const adapterMerge = mergedAdapterModule(projectDir, ordered);
+  const writtenFiles = toWrite.map((file) => file.relativePath);
+  if (packageMerge?.changed) writtenFiles.push("package.json");
+  if (assetMerge?.changed) writtenFiles.push(ASSET_MANIFEST_FILE);
+  if (adapterMerge?.changed) writtenFiles.push(ADAPTER_MODULE_FILE);
+  const stamps = newManifests.map((manifest) => ({
+    bytes: Buffer.from(
+      `${JSON.stringify({ id: manifest.id, version: manifest.version }, null, 2)}
+`
+    ),
+    relativePath: capabilityStampPath(manifest)
+  }));
+  for (const stamp of stamps) writtenFiles.push(stamp.relativePath);
+  const dependencyNames = packageMerge?.changed ? [
+    ...new Set(
+      ordered.flatMap((manifest) => [
+        ...Object.keys(manifest.packageJson?.dependencies ?? {}),
+        ...Object.keys(manifest.packageJson?.devDependencies ?? {})
+      ])
+    )
+  ].sort() : [];
+  if (!options.dryRun) {
+    if (options.installDependencies && dependencyNames.length > 0 && packageMerge) {
+      const packagePath = join3(projectDir, "package.json");
+      const original = readFileSync2(packagePath);
+      const prepared = JSON.parse(original.toString("utf8"));
+      const merged = JSON.parse(packageMerge.bytes.toString("utf8"));
+      for (const section of ["dependencies", "devDependencies"]) {
+        if (merged[section]) prepared[section] = merged[section];
+      }
+      const preparedBytes = Buffer.from(`${JSON.stringify(prepared, null, 2)}
+`);
+      writeFileSync2(packagePath, preparedBytes);
+      try {
+        options.installDependencies(dependencyNames);
+      } catch (error) {
+        if (existsSync2(packagePath) && readFileSync2(packagePath).equals(preparedBytes)) {
+          writeFileSync2(packagePath, original);
+        }
+        throw error;
+      }
+      if (!existsSync2(packagePath) || !readFileSync2(packagePath).equals(preparedBytes)) {
+        throw new Error(
+          "package.json changed during dependency installation; edits were preserved. Retry the capability addition."
+        );
+      }
+      const { installDependencies: _installer, ...publishOptions } = options;
+      const published = addCapabilities(publishOptions);
+      return {
+        ...published,
+        dependencyNames,
+        writtenFiles: [.../* @__PURE__ */ new Set([...published.writtenFiles, "package.json"])].sort()
+      };
+    }
+    const isContribution = (file) => file.relativePath.replaceAll("\\", "/").startsWith("src/contributions/");
+    const write = (file) => {
+      const target = join3(projectDir, file.relativePath);
+      mkdirSync2(dirname(target), { recursive: true });
+      writeFileSync2(target, file.bytes);
+    };
+    for (const file of toWrite.filter((file2) => !isContribution(file2))) write(file);
+    if (assetMerge?.changed) {
+      writeFileSync2(join3(projectDir, ASSET_MANIFEST_FILE), assetMerge.bytes);
+    }
+    if (adapterMerge?.changed) {
+      writeFileSync2(join3(projectDir, ADAPTER_MODULE_FILE), adapterMerge.bytes);
+    }
+    if (packageMerge?.changed) writeFileSync2(join3(projectDir, "package.json"), packageMerge.bytes);
+    for (const file of toWrite.filter(isContribution)) write(file);
+    for (const stamp of stamps) write(stamp);
+  }
+  return {
+    alreadyInstalled,
+    declaredAssets: assetMerge?.declared ?? [],
+    unplacedRegions: adapterMerge?.unplaced ?? [],
+    dependencyNames,
+    dryRun: options.dryRun ?? false,
+    installed: newManifests.map((manifest) => manifest.id),
+    kept: kept.sort(),
+    planned: ordered.map((manifest) => manifest.id),
+    projectDir,
+    writtenFiles: writtenFiles.sort()
+  };
+}
+
+// node/scaffold/engine-version.ts
+var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-.]+))?(?:\+([0-9A-Za-z-.]+))?$/;
+function parseSemver(version) {
+  const match = SEMVER_RE.exec(version);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareTuples(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] < b[i]) return -1;
+    if (a[i] > b[i]) return 1;
+  }
+  return 0;
+}
+function satisfiesRange(version, range) {
+  const versionTuple = parseSemver(version);
+  if (!versionTuple) return false;
+  if (range.startsWith("^")) {
+    const base = parseSemver(range.slice(1));
+    return base ? satisfiesCaret(versionTuple, base) : true;
+  }
+  if (range.startsWith("~")) {
+    const base = parseSemver(range.slice(1));
+    return base ? satisfiesTilde(versionTuple, base) : true;
+  }
+  const exact = parseSemver(range);
+  return exact ? compareTuples(versionTuple, exact) === 0 : true;
+}
+function satisfiesCaret(version, base) {
+  if (compareTuples(version, base) < 0) return false;
+  const [vMaj, vMin, vPat] = version;
+  const [bMaj, bMin, bPat] = base;
+  if (bMaj > 0) return vMaj === bMaj;
+  if (bMin > 0) return vMaj === 0 && vMin === bMin;
+  return vMaj === 0 && vMin === 0 && vPat === bPat;
+}
+function satisfiesTilde(version, base) {
+  if (compareTuples(version, base) < 0) return false;
+  return version[0] === base[0] && version[1] === base[1];
+}
+
+// node/scaffold/templates.json
+var templates_default = {
+  $comment: 'The empty project and the named presets of additions. NO EXAMPLES SHIP IN THE FIRST LAUNCH (2026-09-19, docs/WORK.md \xA7The examples are ARCHIVED): the three promoted `source: "example:<id>"` rows went with them to the tag archive/examples-2026-09-19. The `example:` source form is still parsed and scaffoldable \u2014 restoring the tag restores the rows without a code change.',
+  registryVersion: 1,
+  templates: [
+    {
+      id: "empty",
+      title: "Empty project",
+      description: "A project that declares nothing yet \u2014 add a 3D world, a UI, a server or models from here.",
+      source: "template:empty",
+      whatsInside: [
+        "No roots, no configurations",
+        "The four settings layers",
+        "Add what the project needs"
+      ]
+    },
+    {
+      id: "prototype",
+      title: "Game prototype",
+      description: "A 3D world with modeling tools for a playable prototype, without required Data, Game Inspector or Analytics panels.",
+      source: "template:prototype",
+      whatsInside: [
+        "Three.js world root",
+        "Blender modeling tools",
+        "Neutral daylight scene + focal cube prefab",
+        "No required development panels",
+        "No preselected genre"
+      ]
+    },
+    {
+      id: "game",
+      title: "Game development",
+      description: "A 3D world with modeling tools and multiplayer configuration. Nothing preselected errors; add the Data / Game Inspector / Analytics panels with --with studio when the game wants them.",
+      source: "template:game",
+      whatsInside: [
+        "Three.js world root",
+        "Blender modeling tools",
+        "Neutral daylight scene + focal cube prefab",
+        "server + multiplayer configurations",
+        "No required development panels",
+        "No preselected genre"
+      ]
+    },
+    {
+      id: "website",
+      title: "Website / UI",
+      description: "A React root mounted as a DOM layer \u2014 JSX as the authored truth.",
+      source: "template:website",
+      whatsInside: [
+        "React DOM root",
+        "Styled shell page",
+        "react-root capability"
+      ]
+    },
+    {
+      id: "models",
+      title: "Models",
+      description: "The blender capability alone: Blender in the tab \u2014 .blend models under src/models/ with the bpy that authored them, the Model document and the model finder. No world to run.",
+      source: "template:models",
+      whatsInside: [
+        "blender capability (@volter/editor-blender + @volter/blender-engine)",
+        "src/models/ + the model finder",
+        "Opens in the Model workspace"
+      ]
+    },
+    {
+      id: "full",
+      title: "Everything",
+      description: "Every addition in one project \u2014 a 3D world, a UI root, a multiplayer server, development panels and models. The composition acceptance: nothing here special-cases the presence of anything else.",
+      source: "template:full",
+      whatsInside: [
+        "Three.js world + React DOM root",
+        "server + multiplayer configurations",
+        "Data, Game Inspector and Analytics stubs",
+        "blender capability",
+        "Game, Model and every other workspace"
+      ]
+    }
+  ]
+};
+
+// node/scaffold/templates.ts
+var SCAFFOLD_PRESENTATIONS = ["blank"];
+function parseTemplateSource(source) {
+  const exampleId = source.startsWith("example:") ? source.slice("example:".length) : void 0;
+  if (exampleId !== void 0) {
+    if (exampleId.length === 0) throw new Error("Template registry: empty example id in source");
+    return { type: "example", exampleId };
+  }
+  const template = source.startsWith("template:") ? source.slice("template:".length) : void 0;
+  if (template !== void 0) {
+    if (template.length === 0) throw new Error("Template registry: empty preset name in source");
+    return { type: "template", template };
+  }
+  throw new Error(
+    `Template registry: unparseable source "${source}" (expected "template:<id>" or "example:<id>")`
+  );
+}
+function assertEntry(value, index) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`Template registry: entry ${index} is not an object`);
+  }
+  const entry = value;
+  for (const field of ["id", "title", "description", "source"]) {
+    if (typeof entry[field] !== "string" || entry[field].length === 0) {
+      throw new Error(`Template registry: entry ${index} is missing a non-empty "${field}"`);
+    }
+  }
+  if (entry["thumbnail"] !== void 0 && typeof entry["thumbnail"] !== "string") {
+    throw new Error(`Template registry: entry ${index} has a non-string "thumbnail"`);
+  }
+  if (entry["whatsInside"] !== void 0) {
+    const bullets = entry["whatsInside"];
+    if (!Array.isArray(bullets) || bullets.length === 0 || bullets.some((item) => typeof item !== "string" || item.length === 0)) {
+      throw new Error(
+        `Template registry: entry ${index} has an invalid "whatsInside" (non-empty string array expected)`
+      );
+    }
+  }
+  if (entry["presentation"] !== void 0) {
+    const presentation = entry["presentation"];
+    if (typeof presentation !== "string" || !SCAFFOLD_PRESENTATIONS.includes(presentation)) {
+      throw new Error(
+        `Template registry: entry ${index} declares presentation "${String(presentation)}" (expected one of ${SCAFFOLD_PRESENTATIONS.join(", ")})`
+      );
+    }
+  }
+  parseTemplateSource(entry["source"]);
+  return entry;
+}
+function loadTemplateRegistry() {
+  const raw = templates_default;
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Template registry: templates.json is not an object");
+  }
+  const doc = raw;
+  if (doc["registryVersion"] !== 1) {
+    throw new Error(
+      `Template registry: unsupported registryVersion ${String(doc["registryVersion"])}`
+    );
+  }
+  if (!Array.isArray(doc["templates"]) || doc["templates"].length === 0) {
+    throw new Error('Template registry: "templates" must be a non-empty array');
+  }
+  const templates = doc["templates"].map((entry, index) => assertEntry(entry, index));
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of templates) {
+    if (seen.has(entry.id)) throw new Error(`Template registry: duplicate id "${entry.id}"`);
+    seen.add(entry.id);
+  }
+  return { registryVersion: 1, templates };
+}
+
+// node/scaffold/scaffold.ts
+var RUNTIME_PACKAGES = [
+  { name: "@volter/editor-project", dir: "editor-project" },
+  { name: "@volter/threejs-runtime", dir: "threejs-runtime" },
+  { name: "@volter/game-runtime", dir: "game-runtime" }
+];
+function resolveScaffoldPackageDir(monoRoot, checkoutRelativePath, packageName) {
+  const checkoutDir = join4(monoRoot, checkoutRelativePath);
+  if (existsSync3(checkoutDir)) return checkoutDir;
+  const installedDir = join4(monoRoot, "node_modules", packageName);
+  if (existsSync3(installedDir)) return installedDir;
+  return checkoutDir;
+}
+function resolveScaffoldExamplesDir(monoRoot, productDir) {
+  const checkoutExamples = join4(monoRoot, "examples");
+  if (existsSync3(checkoutExamples)) return checkoutExamples;
+  return join4(productDir, "examples");
+}
+var STARTER_MODEL_FILES = ["cube.blend", "cube.py"];
+function resolveScaffoldStarterDir(productDir) {
+  return join4(productDir, "starter");
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function writeJson(path, data) {
+  writeFileSync3(path, `${JSON.stringify(data, null, 2)}
+`, "utf-8");
+}
+function rewriteEngineRelativeFilePath(original, _engineRelPath) {
+  for (const pkg of RUNTIME_PACKAGES) {
+    const marker = `${pkg.dir}/src/`;
+    const idx = original.indexOf(marker);
+    if (idx === -1) continue;
+    return `node_modules/${pkg.name}/src/${original.slice(idx + marker.length)}`;
+  }
+  return original;
+}
+function pinSharedDependencyVersions(pkg, engineDir, monoRoot, fallbackDir) {
+  const engineDeps = resolveEngineDependencyNames(engineDir, fallbackDir);
+  if (!engineDeps) return;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = pkg[field];
+    if (!deps) continue;
+    for (const name of Object.keys(deps)) {
+      if (!engineDeps.has(name) || name.startsWith("@volter/")) continue;
+      const installedVersion = readInstalledVersionWithFallback(monoRoot, fallbackDir, name);
+      if (!installedVersion) continue;
+      if (satisfiesRange(installedVersion, deps[name])) {
+        deps[name] = installedVersion;
+      }
+    }
+  }
+}
+var STANDALONE_PINNED_DEPENDENCIES = ["@playwright/test", "ztrack"];
+function pinStandaloneDependencyVersions(pkg, monoRoot) {
+  const deps = pkg.devDependencies;
+  if (!deps) return;
+  for (const name of STANDALONE_PINNED_DEPENDENCIES) {
+    const declaredRange = deps[name];
+    if (!declaredRange) continue;
+    const installedVersion = readInstalledVersion(monoRoot, name);
+    if (!installedVersion) continue;
+    if (satisfiesRange(installedVersion, declaredRange)) {
+      deps[name] = installedVersion;
+    }
+  }
+}
+var PROJECT_ROADMAP_RELATIVE_PATH = "ROADMAP.md";
+var PROJECT_DEVELOPMENT_LOG_RELATIVE_PATH = "DEVLOG.md";
+function rewriteRoadmap(targetDir, name) {
+  const path = join4(targetDir, PROJECT_ROADMAP_RELATIVE_PATH);
+  if (!existsSync3(path)) return;
+  const body = readFileSync3(path, "utf-8").replace(/^# .*$/m, `# Roadmap \u2014 ${name}`);
+  writeFileSync3(path, body, "utf-8");
+}
+function resolveEngineDependencyNames(engineDir, fallbackDir) {
+  const primary = readEngineDependencyNames(engineDir);
+  if (primary) return primary;
+  if (!fallbackDir) return void 0;
+  return readEngineDependencyNames(join4(fallbackDir, "node_modules", "@volter", "game-runtime"));
+}
+function readInstalledVersionWithFallback(monoRoot, fallbackDir, name) {
+  const primary = readInstalledVersion(monoRoot, name);
+  if (primary) return primary;
+  if (!fallbackDir) return void 0;
+  return readInstalledVersion(fallbackDir, name);
+}
+function readEngineDependencyNames(engineDir) {
+  try {
+    const enginePkg = JSON.parse(readFileSync3(join4(engineDir, "package.json"), "utf-8"));
+    return new Set(Object.keys(enginePkg.dependencies ?? {}));
+  } catch {
+    return void 0;
+  }
+}
+function readInstalledVersion(monoRoot, packageName) {
+  try {
+    const installed = JSON.parse(
+      readFileSync3(join4(monoRoot, "node_modules", packageName, "package.json"), "utf-8")
+    );
+    return installed.version;
+  } catch {
+    return void 0;
+  }
+}
+function materializeTemplate(templateDir, targetDir, examplesDir, exampleId) {
+  if (exampleId === void 0) {
+    mkdirSync3(targetDir, { recursive: true });
+    cpSync(templateDir, targetDir, {
+      recursive: true,
+      filter: (src) => shouldCopyStarterPath(templateDir, src)
+    });
+    return;
+  }
+  {
+    const examplesSrcDir = join4(examplesDir, exampleId);
+    if (!existsSync3(examplesSrcDir) || !hasManifest(examplesSrcDir)) {
+      if (!existsSync3(examplesDir) || readdirSync3(examplesDir).length === 0) {
+        throw new Error(
+          `Cannot scaffold from example "${exampleId}": NO EXAMPLES SHIP IN THIS RELEASE.
+They are archived whole at the git tag \`archive/examples-2026-09-19\` and are restored from it when their turn comes (docs/WORK.md \xA7The examples are ARCHIVED).
+Fix: create the project without --example, which scaffolds from the starter template your product composes.`
+        );
+      }
+      throw new Error(
+        `Unknown example id "${exampleId}": no vgai.project.json found at ${examplesSrcDir}`
+      );
+    }
+    mkdirSync3(targetDir, { recursive: true });
+    if (!copyTrackedExampleFiles(examplesSrcDir, targetDir)) {
+      cpSync(examplesSrcDir, targetDir, {
+        recursive: true,
+        filter: (src) => shouldCopyExamplePath(examplesSrcDir, src)
+      });
+    }
+    return;
+  }
+}
+function restorePackagedTemplateDotfiles(productDir, targetDir) {
+  for (const filename of [".gitignore"]) {
+    const destination = join4(targetDir, filename);
+    if (existsSync3(destination)) continue;
+    const source = join4(productDir, "template-dotfiles", filename.slice(1));
+    if (!existsSync3(source)) {
+      throw new Error(
+        `Editor distribution omitted ${filename} and its template-dotfiles/${filename.slice(1)} fallback`
+      );
+    }
+    copyFileSync(source, destination);
+  }
+}
+var EXAMPLE_PROJECT_SUPPORT_PATHS = [
+  ".agents",
+  ".claude",
+  ".github",
+  ".mcp.json",
+  ".npmrc",
+  "AGENTS.md",
+  "CLAUDE.md",
+  PROJECT_DEVELOPMENT_LOG_RELATIVE_PATH
+];
+function installExampleProjectSupport(templateDir, targetDir) {
+  for (const relativePath of EXAMPLE_PROJECT_SUPPORT_PATHS) {
+    const source = join4(templateDir, relativePath);
+    const destination = join4(targetDir, relativePath);
+    if (!existsSync3(source)) continue;
+    copyMissingProjectSupport(templateDir, source, destination);
+  }
+}
+function assertDevelopmentLog(targetDir) {
+  const path = join4(targetDir, PROJECT_DEVELOPMENT_LOG_RELATIVE_PATH);
+  if (!existsSync3(path)) {
+    throw new Error(
+      `Scaffolded project is missing ${PROJECT_DEVELOPMENT_LOG_RELATIVE_PATH}; restore it from the VGAI starter template`
+    );
+  }
+}
+function copyMissingProjectSupport(templateDir, source, destination) {
+  if (!shouldCopyStarterPath(templateDir, source)) return;
+  const sourceStat = lstatSync(source);
+  if (sourceStat.isDirectory()) {
+    if (existsSync3(destination) && !lstatSync(destination).isDirectory()) return;
+    mkdirSync3(destination, { recursive: true });
+    for (const entry of readdirSync3(source)) {
+      copyMissingProjectSupport(templateDir, join4(source, entry), join4(destination, entry));
+    }
+    return;
+  }
+  if (!sourceStat.isFile() || existsSync3(destination)) return;
+  mkdirSync3(dirname2(destination), { recursive: true });
+  copyFileSync(source, destination);
+}
+function trackedExampleFiles(exampleDir) {
+  const result = spawnSync("git", ["-C", exampleDir, "ls-files", "--cached", "-z", "--", "."], {
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0 || !result.stdout) return null;
+  const paths = result.stdout.toString("utf8").split("\0").filter(Boolean);
+  return paths.includes("vgai.project.json") ? paths : null;
+}
+function copyTrackedExampleFiles(exampleDir, targetDir) {
+  const paths = trackedExampleFiles(exampleDir);
+  if (!paths) return false;
+  for (const relativePath of paths) {
+    const source = join4(exampleDir, relativePath);
+    if (!shouldCopyExamplePath(exampleDir, source)) continue;
+    if (!existsSync3(source)) continue;
+    const sourceStat = lstatSync(source);
+    if (!sourceStat.isFile()) {
+      throw new Error(`Example remixes only accept regular tracked files: ${source}`);
+    }
+    const destination = join4(targetDir, relativePath);
+    mkdirSync3(dirname2(destination), { recursive: true });
+    copyFileSync(source, destination);
+  }
+  return true;
+}
+function applyPresentation(_targetDir, presentation) {
+  switch (presentation) {
+    case "blank":
+      return;
+  }
+}
+function writeExampleReadme(targetDir, projectName, exampleId) {
+  const path = join4(targetDir, "README.md");
+  if (existsSync3(path)) return;
+  writeFileSync3(
+    path,
+    `# ${projectName}
+
+An editable standalone VGAI project scaffolded from the \`${exampleId ?? "example"}\` reference. Its gameplay source and assets were copied unchanged; this folder is now your project.
+
+\`\`\`bash
+npm run dev                 # open/reuse the visual editor
+npm run vgai -- play        # verify Play mode
+npm run typecheck
+npm run validate-manifest
+npm run validate-assets
+\`\`\`
+
+Coding agents start with \`AGENTS.md\`; MCP-compatible hosts discover the project-scoped server through \`.mcp.json\`.
+`,
+    "utf-8"
+  );
+}
+function shouldCopyExamplePath(exampleDir, sourcePath) {
+  const relativePath = relative3(exampleDir, sourcePath).replaceAll("\\", "/");
+  const topLevel = relativePath.split("/")[0] ?? "";
+  const segments = relativePath.split("/");
+  return !["node_modules", "dist", "logs", ".vgai", ".git", "package-lock.json"].includes(topLevel) && !segments.some((segment) => segment === ".env" || segment.startsWith(".env."));
+}
+function shouldCopyStarterPath(templateDir, sourcePath) {
+  const relativePath = relative3(templateDir, sourcePath).replaceAll("\\", "/");
+  const topLevel = relativePath.split("/")[0] ?? "";
+  return !["node_modules", "dist", "logs", ".vgai"].includes(topLevel);
+}
+function rewritePackageJson(targetDir, slug, engineDir, monoRoot) {
+  const pkgPath = join4(targetDir, "package.json");
+  if (!existsSync3(pkgPath)) return;
+  const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+  pkg.name = slug;
+  pkg.dependencies = pkg.dependencies ?? {};
+  for (const runtime of RUNTIME_PACKAGES)
+    pkg.dependencies[runtime.name] = engineDependencySpec(monoRoot, runtime.name);
+  for (const name of ["@volter/editor-live", "@volter/game-live", "@volter/editor-sdk"]) {
+    if (pkg.devDependencies?.[name] !== void 0) {
+      pkg.devDependencies[name] = engineDependencySpec(monoRoot, name);
+    }
+  }
+  for (const section of ["dependencies", "devDependencies"]) {
+    const deps = pkg[section];
+    if (!deps) continue;
+    for (const [name, spec] of Object.entries(deps)) {
+      if (!name.startsWith("@volter/") || !spec.startsWith("file:")) continue;
+      deps[name] = engineDependencySpec(monoRoot, name, spec.slice("file:".length));
+    }
+  }
+  pkg.scripts ??= {};
+  for (const [name, script] of Object.entries(pkg.scripts)) {
+    if (name !== "vgai" && script.startsWith("vgai ")) {
+      pkg.scripts[name] = `npm run vgai -- ${script.slice("vgai ".length)}`;
+    }
+  }
+  pkg.devDependencies = pkg.devDependencies ?? {};
+  pkg.devDependencies["@volter/editor-core"] = engineDependencySpec(monoRoot, "@volter/editor-core");
+  pinSharedDependencyVersions(pkg, engineDir, monoRoot);
+  pinStandaloneDependencyVersions(pkg, monoRoot);
+  writeJson(pkgPath, pkg);
+}
+function resolvePackageRoots() {
+  return {
+    engineRelPath: "node_modules/@volter/game-runtime",
+    editorRelPath: "node_modules/@volter/editor-core",
+    liveRelPath: "node_modules/@volter/editor-live",
+    editorSdkRelPath: "node_modules/@volter/editor-sdk"
+  };
+}
+function versionFromCheckout(monoRoot, relPath) {
+  const cleaned = relPath.replace(/^(\.\.\/)+/, "");
+  const candidate = resolve2(monoRoot, cleaned, "package.json");
+  if (!existsSync3(candidate)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync3(candidate, "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function engineDependencySpec(monoRoot, packageName, checkoutRelPath = "") {
+  const version = readInstalledVersion(monoRoot, packageName) ?? versionFromCheckout(monoRoot, checkoutRelPath);
+  if (!version) {
+    throw new Error(`Cannot scaffold: ${packageName} has no resolvable version in ${monoRoot}.`);
+  }
+  return `^${version}`;
+}
+function rewriteGameManifest(targetDir, name, slug, additions, monoRoot) {
+  const manifestPath = join4(targetDir, "vgai.project.json");
+  const engineVersion = readInstalledVersion(monoRoot, "@volter/editor-project");
+  let manifest;
+  if (existsSync3(manifestPath)) {
+    manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } else {
+    manifest = {
+      manifestVersion: 2,
+      name,
+      version: "0.1.0",
+      engine: { version: engineVersion ?? "0.0.0" },
+      // A three root's document IS its TSX entry. (This branch only fires when
+      // the template shipped NO manifest, which it always does.)
+      roots: [{ id: "world", adapter: "three", entry: "src/world.tsx" }],
+      resolution: { width: 1280, height: 720 }
+    };
+  }
+  manifest["name"] = name;
+  manifest["manifestVersion"] = 2;
+  manifest["$schema"] = "./node_modules/@volter/editor-project/schemas/vgai-project.schema.json";
+  manifest["appId"] = `com.example.${slug.replace(/[^a-zA-Z0-9]/g, "")}`;
+  if (additions) {
+    const roots = [];
+    if (additions.has("three"))
+      roots.push({ id: "world", adapter: "three", entry: "src/world.tsx" });
+    if (additions.has("ui"))
+      roots.push({ id: "ui", adapter: "dom", entry: "src/ui/game.tsx", zOrder: 0 });
+    manifest["roots"] = roots;
+    const configurations = manifest["configurations"] ?? [];
+    manifest["configurations"] = configurations.filter((configuration) => {
+      const kind = configuration["kind"];
+      if (kind === "process" || kind === "compound") return additions.has("server");
+      return true;
+    });
+  }
+  if (engineVersion) {
+    manifest["engine"] = {
+      ...manifest["engine"],
+      version: engineVersion
+    };
+  }
+  writeJson(manifestPath, manifest);
+  return manifest;
+}
+function repinEngineAfterInstall(targetDir) {
+  const installed = readInstalledVersion(targetDir, "@volter/editor-project");
+  if (!installed) return null;
+  const manifestPath = resolveManifestPath(targetDir);
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const engine = manifest["engine"] ?? {};
+  const from = typeof engine["version"] === "string" ? engine["version"] : "";
+  if (from === installed) return null;
+  manifest["engine"] = { ...engine, version: installed };
+  writeJson(manifestPath, manifest);
+  const baselinePath = join4(targetDir, SCAFFOLD_BASELINE_RELATIVE_PATH);
+  try {
+    const baseline = JSON.parse(readFileSync3(baselinePath, "utf-8"));
+    baseline.engineVersion = installed;
+    baseline.files["vgai.project.json"] = hashFile(manifestPath);
+    writeFileSync3(baselinePath, `${JSON.stringify(baseline, null, 2)}
+`, "utf-8");
+  } catch {
+  }
+  return { from, to: installed };
+}
+function checkoutVgaiPackageDirs(monoRoot) {
+  const found = /* @__PURE__ */ new Map();
+  const packagesDir = join4(monoRoot, "packages");
+  let entries;
+  try {
+    entries = readdirSync3(packagesDir);
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    const dir = join4(packagesDir, entry);
+    try {
+      if (!statSync2(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    let name;
+    try {
+      name = JSON.parse(readFileSync3(join4(dir, "package.json"), "utf-8")).name;
+    } catch {
+      continue;
+    }
+    if (typeof name === "string" && name.startsWith("@volter/")) found.set(name, dir);
+  }
+  return found;
+}
+function pointUnpublishedPackagesAtCheckout(projectDir, monoRoot) {
+  const pkgPath = join4(projectDir, "package.json");
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const rewritten = [];
+  for (const section of ["dependencies", "devDependencies"]) {
+    const deps = pkg[section];
+    if (!deps) continue;
+    for (const name of Object.keys(deps)) {
+      const spec = checkoutPackageSpec(name, monoRoot);
+      if (spec === null || deps[name] === spec) continue;
+      deps[name] = spec;
+      rewritten.push(name);
+    }
+  }
+  if (rewritten.length > 0) writeJson(pkgPath, pkg);
+  return rewritten;
+}
+function checkoutPackageSpec(name, monoRoot) {
+  const dir = checkoutVgaiPackageDirs(monoRoot).get(name);
+  return dir === void 0 ? null : `file:${dir}`;
+}
+function writeEditorPackages(targetDir, wanted) {
+  const pkgPath = join4(targetDir, "package.json");
+  const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+  const kit = new Set(KIT_DECLARED_PACKAGES);
+  const replaced = Object.keys(pkg.devDependencies ?? {}).filter(
+    (name) => name.startsWith("@volter/") && !kit.has(name)
+  );
+  const spec = pkg.devDependencies?.["@volter/editor-core"] ?? replaced.map((name) => pkg.devDependencies?.[name]).find((value) => value !== void 0) ?? "*";
+  for (const name of [...replaced, ...wanted]) {
+    delete pkg.dependencies?.[name];
+    delete pkg.devDependencies?.[name];
+  }
+  pkg.devDependencies ??= {};
+  for (const name of wanted) pkg.devDependencies[name] = spec;
+  pkg.devDependencies = Object.fromEntries(
+    Object.entries(pkg.devDependencies).sort(([a], [b]) => a.localeCompare(b))
+  );
+  writeJson(pkgPath, pkg);
+}
+function rewriteTemplateVariantFiles(targetDir, composition, additions, starterDir) {
+  if (!additions.has("three") || !additions.has("studio")) {
+    for (const relative4 of STUDIO_OWNED_PATHS) {
+      rmSync2(join4(targetDir, relative4), { force: true });
+    }
+  }
+  writeEditorPackages(targetDir, composition.editorPackages);
+  if (!additions.has("three")) {
+    for (const relative4 of THREE_OWNED_PATHS) {
+      rmSync2(join4(targetDir, relative4), { recursive: true, force: true });
+    }
+    writeFileSync3(join4(targetDir, "vgai.adapter.ts"), adapterSourceFor(additions), "utf-8");
+  } else {
+    const adapterPath = join4(targetDir, "vgai.adapter.ts");
+    const source = joinAdditionFinders(readFileSync3(adapterPath, "utf-8"), additions);
+    writeFileSync3(adapterPath, source, "utf-8");
+  }
+  if (additions.has("blender")) {
+    mkdirSync3(join4(targetDir, "src", "models"), { recursive: true });
+    for (const file of STARTER_MODEL_FILES) {
+      const source = join4(starterDir, file);
+      if (!existsSync3(source))
+        throw new Error(
+          `Cannot scaffold a models project: the starter model ${file} is missing from ${starterDir}. It is a real Blender document, not a string this scaffolder can write, so there is nothing to fall back to.`
+        );
+      writeFileSync3(join4(targetDir, "src", "models", file), readFileSync3(source));
+    }
+  }
+  if (!additions.has("ui")) return;
+  if (additions.has("three")) {
+    for (const [relative4, source] of Object.entries(REACT_ONLY_FILES)) {
+      if (relative4 === "src/main.ts") continue;
+      mkdirSync3(dirname2(join4(targetDir, relative4)), { recursive: true });
+      writeFileSync3(join4(targetDir, relative4), source, "utf-8");
+    }
+    return;
+  }
+  for (const relative4 of REACT_ONLY_REMOVED_PATHS) {
+    rmSync2(join4(targetDir, relative4), { recursive: true, force: true });
+  }
+  mkdirSync3(join4(targetDir, "public"), { recursive: true });
+  mkdirSync3(join4(targetDir, "src", "ui"), { recursive: true });
+  for (const [relative4, source] of Object.entries(REACT_ONLY_FILES)) {
+    writeFileSync3(join4(targetDir, relative4), source, "utf-8");
+  }
+}
+function rewriteTsconfig(targetDir, engineRelPath, editorRelPath) {
+  const tsconfigPath = join4(targetDir, "tsconfig.json");
+  if (!existsSync3(tsconfigPath)) return;
+  const parseErrors = [];
+  const tsconfig = parse2(readFileSync3(tsconfigPath, "utf-8"), parseErrors, {
+    allowTrailingComma: true
+  });
+  if (parseErrors.length > 0) {
+    const details = parseErrors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
+    throw new Error(`Invalid TypeScript config ${tsconfigPath}: ${details}`);
+  }
+  tsconfig.compilerOptions = tsconfig.compilerOptions ?? {};
+  tsconfig.compilerOptions.paths = {
+    ...Object.fromEntries(
+      RUNTIME_PACKAGES.map((runtime) => [
+        `${runtime.name}/*`,
+        [`node_modules/${runtime.name}/src/*`]
+      ])
+    ),
+    // `@volter/editor-blender`'s two VALUE exports — the look and the layout a models
+    // project's `vgai.adapter.ts` imports. Spelled entry by entry rather than
+    // as a wildcard because the package's `exports` names them individually;
+    // both entries are inert for a project that never declares the package.
+    "@volter/editor-blender/looks": ["node_modules/@volter/editor-blender/src/looks.ts"],
+    "@volter/editor-blender/layouts": ["node_modules/@volter/editor-blender/src/layouts.tsx"]
+  };
+  if (editorRelPath) {
+    tsconfig.compilerOptions.paths["@editor/*"] = [`${editorRelPath}/src/*`];
+  }
+  if (Array.isArray(tsconfig.files)) {
+    tsconfig.files = tsconfig.files.map((f) => rewriteEngineRelativeFilePath(f, engineRelPath));
+  }
+  writeJson(tsconfigPath, tsconfig);
+}
+function rewriteViteConfig(targetDir) {
+  const vitePath = join4(targetDir, "vite.config.ts");
+  if (!existsSync3(vitePath)) return;
+  writeFileSync3(vitePath, rewriteViteConfigContent(readFileSync3(vitePath, "utf-8")), "utf-8");
+}
+function rewriteViteConfigContent(content) {
+  return ensureReactDedupe(content);
+}
+function ensureReactDedupe(content) {
+  const REQUIRED = ["react", "react-dom"];
+  const dedupeMatch = content.match(/dedupe:\s*\[([^\]]*)\]/);
+  if (dedupeMatch) {
+    const inner = dedupeMatch[1] ?? "";
+    const missing = REQUIRED.filter((name) => !new RegExp(`['"]${name}['"]`).test(inner));
+    if (missing.length === 0) return content;
+    const trimmed = inner.trim();
+    const additions = missing.map((name) => `'${name}'`).join(", ");
+    const newInner = trimmed.length === 0 ? additions : `${inner.replace(/,\s*$/, "")}, ${additions}`;
+    return content.replace(dedupeMatch[0], `dedupe: [${newInner}]`);
+  }
+  if (!/resolve:\s*{/.test(content)) return content;
+  return content.replace(
+    /resolve:\s*{/,
+    "resolve: {\n    // react/react-dom dedupe (GH #123): see packages/editor/template/vite.config.ts's\n    // matching comment for the dual-React-instance root cause this avoids.\n    dedupe: ['react', 'react-dom'],"
+  );
+}
+function rewriteIndexHtml(targetDir, name) {
+  const htmlPath = join4(targetDir, "index.html");
+  if (!existsSync3(htmlPath)) return;
+  const html = readFileSync3(htmlPath, "utf-8").replace(
+    /<title>.*<\/title>/,
+    `<title>${name}</title>`
+  );
+  writeFileSync3(htmlPath, html, "utf-8");
+}
+function scaffoldProject(opts) {
+  const { name, targetDir, monoRoot, exampleId } = opts;
+  const composed = exampleId === void 0;
+  const additions = composed ? new Set(closeAdditions(opts.additions ?? [])) : null;
+  if (composed && !opts.composition) {
+    throw new Error(
+      "scaffoldProject: a composed project needs `composition` \u2014 the editor-side packages and editor declaration its PRODUCT declares (./product.ts). Only an `exampleId` scaffold goes without one."
+    );
+  }
+  const composition = opts.composition;
+  const slug = slugify(name) || slugify(basename(targetDir));
+  if (!slug) throw new Error("Invalid project name");
+  if (existsSync3(targetDir)) {
+    throw new Error(`Directory already exists: ${targetDir}`);
+  }
+  const { productDir } = opts;
+  const templateDir = join4(productDir, "template");
+  const examplesDir = resolveScaffoldExamplesDir(monoRoot, productDir);
+  const catalogDir = join4(productDir, "catalog");
+  const engineDir = resolveScaffoldPackageDir(
+    monoRoot,
+    join4("packages", "game-runtime"),
+    "@volter/game-runtime"
+  );
+  if (!existsSync3(templateDir)) {
+    throw new Error(`Template not found at ${templateDir}. Is this product installed intact?`);
+  }
+  const hasCapabilityDistribution = existsSync3(catalogDir);
+  materializeTemplate(templateDir, targetDir, examplesDir, exampleId);
+  restorePackagedTemplateDotfiles(productDir, targetDir);
+  if (exampleId !== void 0) {
+    installExampleProjectSupport(templateDir, targetDir);
+    writeExampleReadme(targetDir, name, exampleId);
+  }
+  assertDevelopmentLog(targetDir);
+  if (opts.presentation) applyPresentation(targetDir, opts.presentation);
+  const { engineRelPath, editorRelPath } = resolvePackageRoots();
+  rewritePackageJson(targetDir, slug, engineDir, monoRoot);
+  const manifest = rewriteGameManifest(targetDir, name, slug, additions, monoRoot);
+  if (additions && composition) {
+    rewriteTemplateVariantFiles(
+      targetDir,
+      composition,
+      additions,
+      resolveScaffoldStarterDir(productDir)
+    );
+    const adapterPath = join4(targetDir, "vgai.adapter.ts");
+    writeFileSync3(
+      adapterPath,
+      withEditorDeclaration(readFileSync3(adapterPath, "utf-8"), composition.editor),
+      "utf-8"
+    );
+    const agentsPath = join4(targetDir, "AGENTS.md");
+    writeFileSync3(
+      agentsPath,
+      withAgentsContract(readFileSync3(agentsPath, "utf-8"), additions),
+      "utf-8"
+    );
+  }
+  rewriteTsconfig(targetDir, engineRelPath, editorRelPath);
+  rewriteViteConfig(targetDir);
+  rewriteIndexHtml(targetDir, name);
+  rewriteRoadmap(targetDir, name);
+  if (hasCapabilityDistribution) initializeProjectCatalog(targetDir, catalogDir);
+  if (hasCapabilityDistribution && additions) {
+    const ids = [
+      ...additions.has("ui") ? DEFAULT_REACT_CAPABILITIES : [],
+      ...additions.has("blender") ? ["blender"] : []
+    ];
+    if (ids.length > 0)
+      addCapabilities({
+        catalogDir,
+        ids: [...ids],
+        projectDir: targetDir,
+        resolveDependencySpec: (name2, spec) => checkoutPackageSpec(name2, monoRoot) ?? spec
+      });
+  }
+  pointUnpublishedPackagesAtCheckout(targetDir, monoRoot);
+  const engineVersion = readInstalledVersion(monoRoot, "@volter/editor-project") ?? "0.0.0";
+  writeScaffoldBaseline(targetDir, engineVersion, engineDir);
+  return { targetDir, slug, manifest };
+}
+
+// node/runtime-image.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync4, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readlinkSync, symlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname3, join as join5, resolve as resolve3 } from "node:path";
+var PRODUCT = "@volter/game-editor";
+function installRootOf(productRoot2) {
+  for (let dir = productRoot2; ; dir = dirname3(dir)) {
+    if (existsSync4(join5(dir, "node_modules", "@volter", "editor-project", "package.json"))) return dir;
+    if (dirname3(dir) === dir) throw new Error(`@volter/editor-project is not installed above ${productRoot2}.`);
+  }
+}
+function isCheckout(root) {
+  return existsSync4(join5(root, "packages", "game-editor", "package.json"));
+}
+function imageDirFor(version) {
+  const home = process.env["VOLTER_HOME"] ?? join5(homedir(), ".volter");
+  return join5(home, "images", `game-editor-${version}`);
+}
+function imageVersion(nodeModules) {
+  try {
+    return JSON.parse(readFileSync4(join5(nodeModules, "@volter", "game-editor", "package.json"), "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function ensureRuntimeImage(productRoot2, version) {
+  const root = installRootOf(productRoot2);
+  if (isCheckout(root)) return join5(root, "node_modules");
+  const dir = imageDirFor(version);
+  const nodeModules = join5(dir, "node_modules");
+  if (imageVersion(nodeModules) === version) return nodeModules;
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync4(
+    join5(dir, "package.json"),
+    `${JSON.stringify({ name: `game-editor-image-${version}`, private: true, dependencies: { [PRODUCT]: version } }, null, 2)}
+`
+  );
+  console.error(`Installing the Volter Game Editor ${version} runtime image (once per version) into ${dir}`);
+  await new Promise((done, fail2) => {
+    const child = spawn(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "--no-audit", "--no-fund"], {
+      cwd: dir,
+      stdio: "inherit"
+    });
+    child.once("error", fail2);
+    child.once("exit", (code) => code === 0 ? done() : fail2(new Error(`The runtime image did not install (${code}); retry creating the project.`)));
+  });
+  if (imageVersion(nodeModules) !== version) throw new Error(`The runtime image at ${dir} does not carry ${PRODUCT}@${version}.`);
+  return nodeModules;
+}
+function linkRuntimeImage(projectDir, imageNodeModules) {
+  const link = join5(projectDir, "node_modules");
+  if (existsSync4(link) || isDanglingLink(link)) {
+    if (!lstatSync2(link).isSymbolicLink())
+      throw new Error(`${link} is a real directory: this game installs its own dependencies, so it is not linked to the runtime image.`);
+    if (resolve3(projectDir, readlinkSync(link)) === resolve3(imageNodeModules)) return;
+    throw new Error(`${link} already links ${readlinkSync(link)}; remove it to link the runtime image.`);
+  }
+  symlinkSync(imageNodeModules, link, "dir");
+}
+function isDanglingLink(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+// node/scaffold/git-init.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+function runGit(cwd, args) {
+  const result = spawnSync2("git", args, { cwd, encoding: "utf-8" });
+  if (result.error) {
+    const code = result.error.code;
+    return { status: null, stdout: "", stderr: "", unavailable: code === "ENOENT" };
+  }
+  return {
+    status: result.status,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim(),
+    unavailable: false
+  };
+}
+function hasCommitterIdentity(cwd) {
+  const name = runGit(cwd, ["config", "--get", "user.name"]);
+  const email = runGit(cwd, ["config", "--get", "user.email"]);
+  return name.status === 0 && name.stdout !== "" && email.status === 0 && email.stdout !== "";
+}
+function initGitRepo(targetDir, projectName) {
+  const insideWorkTree = runGit(targetDir, ["rev-parse", "--is-inside-work-tree"]);
+  if (insideWorkTree.unavailable) {
+    return {
+      status: "skipped",
+      reason: "git-unavailable",
+      notice: "Skipped git init \u2014 git is not on PATH."
+    };
+  }
+  if (insideWorkTree.status === 0 && insideWorkTree.stdout === "true") {
+    return {
+      status: "skipped",
+      reason: "already-in-repo",
+      notice: "Skipped git init \u2014 the project is already inside a git work tree."
+    };
+  }
+  const authorFallback = hasCommitterIdentity(targetDir) ? [] : ["-c", "user.name=vgai", "-c", "user.email=scaffold@vgai"];
+  const steps = [
+    { label: "git init", args: ["init", "--quiet"] },
+    { label: "git add", args: ["add", "-A"] },
+    {
+      label: "git commit",
+      args: [...authorFallback, "commit", "--quiet", "-m", `scaffold ${projectName}`]
+    }
+  ];
+  for (const step of steps) {
+    const run = runGit(targetDir, step.args);
+    if (run.status !== 0) {
+      const detail = run.stderr !== "" ? run.stderr.split("\n")[0] : `exit ${run.status ?? "null"}`;
+      return {
+        status: "failed",
+        reason: "git-command-failed",
+        notice: `Skipped git init \u2014 ${step.label} failed: ${detail}`
+      };
+    }
+  }
+  return {
+    status: "initialized",
+    notice: `Initialized a git repository \u2014 one commit: "scaffold ${projectName}".`
+  };
+}
+
+// node/create.ts
+var productRoot = resolve4(dirname4(fileURLToPath(import.meta.url)), "..");
+var PRODUCT2 = "@volter/game-editor";
+var presets = {
+  product: PRODUCT2,
+  // Listed most-wanted first: this order IS the `--template` line in
+  // `volter-game-editor --help`.
+  templates: {
+    // NOTHING PRESELECTED MAY ERROR. `studio` brings three stub contributions
+    // that THROW on render, so a fresh `game` scaffold could never reach the
+    // silent console the agent contract requires; they are an author's TODO
+    // from the moment the author ASKS for those panels (`--with studio`, or
+    // `--template full`).
+    game: { additions: ["three", "server", "blender"] },
+    /** A 3D world and its models: the smallest thing that plays. */
+    prototype: { additions: ["three", "blender"] },
+    // EVERY addition in one project — the composition acceptance made
+    // permanent. Check it against `SCAFFOLD_ADDITIONS` (./scaffold/additions.ts)
+    // when the scaffolder grows one.
+    full: { additions: ["three", "ui", "server", "blender", "studio"] },
+    /** The design skew: a React root and no 3D world. */
+    website: { additions: ["ui"] },
+    /** Nothing but the project — the shape an author adds to. */
+    empty: { additions: [] }
+  },
+  // A bare `create` makes a game that plays; `empty` is asked for by name.
+  defaultTemplate: "game",
+  examples: true,
+  compose(additions) {
+    const three = additions.has("three");
+    const studio = additions.has("studio");
+    const layouts = "@volter/editor-sdk/layouts";
+    const design = additions.has("ui") && !three;
+    return {
+      // THE PRODUCT THIS PROJECT OPENS IN, and the 3D lane beside it:
+      // `@volter/editor-game` is the 3D world's lane, and a project with no 3D
+      // root has nothing for Play, the Game workspace or the instruments over
+      // a running game to run.
+      editorPackages: [PRODUCT2, ...three ? ["@volter/editor-game"] : []],
+      editor: {
+        layout: { name: design ? "DesignLayout" : studio ? "StudioLayout" : "GameLayout", from: layouts },
+        inspector: studio ? "column" : "card"
+      }
+    };
+  }
+};
+function installRoot() {
+  for (let dir = productRoot; ; dir = dirname4(dir)) {
+    if (existsSync5(join6(dir, "node_modules", "@volter", "editor-project", "package.json"))) return dir;
+    if (dirname4(dir) === dir) throw new Error(`Cannot scaffold: @volter/editor-project is not installed above ${productRoot}.`);
+  }
+}
+function writeProject({ name, targetDir, template, additions = [] }) {
+  if (!name.trim()) throw new Error("A project name is required.");
+  const id = template ?? presets.defaultTemplate;
+  const preset = presets.templates[id];
+  if (!preset) throw new Error(`--template must be one of: ${Object.keys(presets.templates).join(", ")}`);
+  const closed = new Set(closeAdditions([...preset.additions, ...additions]));
+  const composition = assertScaffoldComposition(presets.compose(closed), "node/create.ts", PRODUCT2);
+  return scaffoldProject({
+    name,
+    targetDir: resolve4(targetDir),
+    monoRoot: installRoot(),
+    productDir: productRoot,
+    additions: [...closed],
+    composition
+  });
+}
+async function createGameProject(request) {
+  const result = writeProject(request);
+  const version = JSON.parse(readFileSync5(join6(productRoot, "package.json"), "utf8")).version;
+  linkRuntimeImage(result.targetDir, await ensureRuntimeImage(productRoot, version));
+  repinEngineAfterInstall(result.targetDir);
+  console.error(initGitRepo(result.targetDir, request.name).notice);
+  return { targetDir: result.targetDir, manifest: result.manifest };
+}
+var registry = new Map(loadTemplateRegistry().templates.map((entry) => [entry.id, entry]));
+var declaration = {
+  product: PRODUCT2,
+  templates: Object.keys(presets.templates).map((id) => {
+    const entry = registry.get(id);
+    if (!entry) throw new Error(`templates.json has no entry for preset "${id}".`);
+    return { id, name: entry.title, description: entry.description };
+  }),
+  create: (request) => createGameProject(request)
+};
+export {
+  createGameProject,
+  declaration,
+  installRoot,
+  presets,
+  productRoot,
+  writeProject
+};