@vgai/editor 0.2.0 → 0.4.0-canary.20260715.0

package/src/project-manager.ts

@@ -6,22 +6,38 @@
  * Projects can also be switched at runtime via `switchProject()`.
  */
 
-import { getCurrentServerProject, openProjectOnServer } from './editor-api';
+import { loadGameManifest } from '@engine/manifest/load';
+import { BUNDLED_EDITOR_COMPATIBILITY } from './build-identity';
+import {
+  getCurrentServerProject,
+  openProjectOnServer,
+  requireEditorCompatibility,
+} from './editor-api';
+import { assertProjectCompatibility } from './editor-compatibility';
 import { getEditorMode } from './editor-mode';
+import { type HierarchyProjection, parseHierarchyProjection } from './hierarchy-projection';
 import { getStorageBackend, restorePersistedProjectRoot } from './storage';
 import { readProjectManifest, seedIfEmpty } from './storage/seed';
 
 export interface ProjectConfig {
+  /** Project-file schema version. Kept distinct from game and engine versions. */
+  manifestVersion: 2;
   name: string;
+  /** The authored game's own release version. */
+  version: string;
+  /** Exact engine identity the project is pinned to. */
+  engine: { version: string };
+  /** Editor-only organization. It never changes which runtime roots mount. */
+  authoring?: { hierarchy?: HierarchyProjection | undefined } | undefined;
   resolution?: { width: number; height: number } | undefined;
   appId?: string | undefined;
+  /** Stable preferred port generated with the project; launchers may fall forward when occupied. */
+  editorPort?: number | undefined;
   /**
    * The project's default scene path, or `null` when the manifest's first
    * world declares no scene (e.g. an `entry`-only world — §7.1-12). Always
-   * present when synthesized from a manifest (`readProjectView`, server-side);
-   * a hand-authored legacy `project.json` may still omit the key entirely
-   * (verbatim pass-through — §1C), which `loadInitialScene` treats the same
-   * as `null`. Consumers must NOT default a missing/null value to a guessed
+   * present when derived from the manifest (`readProjectView`, server-side).
+   * Consumers must NOT default a missing/null value to a guessed
    * path — that was the bug (initial-scene.ts guessing
    * 'scenes/default.vscn.json' and silently writing a placeholder scene).
    */
@@ -31,7 +47,7 @@ export interface ProjectConfig {
 export interface ActiveProject {
   /** Absolute path to the project root (as passed via URL param / env). */
   rootPath: string;
-  /** Parsed project.json contents. */
+  /** Parsed vgai.game.json project configuration plus derived editor fields. */
   config: ProjectConfig;
   /**
    * Set when this project is a BUNDLED EXAMPLE opened in the hosted (browser)
@@ -50,13 +66,74 @@ function _notify(): void {
   for (const fn of _listeners) fn();
 }
 
-/** Open a project by its root path. Fetches project.json from the server. */
+function describeManifestError(error: unknown): string {
+  const issues =
+    error && typeof error === 'object' && Array.isArray((error as { issues?: unknown }).issues)
+      ? (error as { issues: unknown[] }).issues
+      : null;
+  if (!issues) return error instanceof Error ? error.message : String(error);
+
+  return issues
+    .map((issue) => {
+      if (!issue || typeof issue !== 'object') return String(issue);
+      const candidate = issue as { path?: unknown; message?: unknown };
+      const path = Array.isArray(candidate.path)
+        ? candidate.path.map(String).join('.') || '(root)'
+        : '(root)';
+      const message =
+        typeof candidate.message === 'string' ? candidate.message : 'Invalid manifest value';
+      return `${path}: ${message}`;
+    })
+    .join('\n');
+}
+
+/** Open a project by its root path. Fetches the sole v2 project manifest. */
 export async function openProject(rootPath: string): Promise<ActiveProject> {
-  const res = await fetch('/project.json');
+  const compatibility = await requireEditorCompatibility();
+  const res = await fetch('/vgai.game.json');
   if (!res.ok) {
-    throw new Error(`Failed to load project.json: ${res.status} ${res.statusText}`);
+    throw new Error(
+      `Could not open project at ${rootPath}.\n` +
+        `Failed to load vgai.game.json: ${res.status} ${res.statusText}`,
+    );
+  }
+  let rawManifest: unknown;
+  try {
+    rawManifest = await res.json();
+  } catch (error) {
+    throw new Error(
+      `Could not open project at ${rootPath}.\n` +
+        `vgai.game.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  assertProjectCompatibility(
+    rawManifest && typeof rawManifest === 'object'
+      ? (rawManifest as { manifestVersion?: unknown; engine?: { version?: unknown } })
+      : {},
+    compatibility,
+  );
+  let manifest: ReturnType<typeof loadGameManifest>;
+  try {
+    manifest = loadGameManifest(rawManifest);
+  } catch (error) {
+    throw new Error(
+      `Could not open project at ${rootPath}.\n` +
+        `vgai.game.json does not match the current project format:\n${describeManifestError(error)}`,
+    );
   }
-  const config = (await res.json()) as ProjectConfig;
+  const config: ProjectConfig = {
+    manifestVersion: manifest.manifestVersion,
+    name: manifest.name,
+    version: manifest.version,
+    engine: manifest.engine,
+    appId: manifest.appId,
+    editorPort: manifest.editorPort,
+    resolution: manifest.resolution,
+    authoring: manifest.authoring
+      ? { hierarchy: parseHierarchyProjection(manifest.authoring.hierarchy) }
+      : undefined,
+    defaultScene: manifest.roots.find((root) => root.scene !== undefined)?.scene ?? null,
+  };
   _activeProject = { rootPath, config };
   _notify();
   return _activeProject;
@@ -114,8 +191,10 @@ export function getProjectPathFromURL(): string | null {
  * Used in production where __VGAI_PROJECT_PATH__ isn't available at build time.
  */
 export async function detectServerProject(): Promise<ActiveProject | null> {
+  const compatibility = await requireEditorCompatibility();
   const info = await getCurrentServerProject();
   if (!info) return null;
+  assertProjectCompatibility(info.config, compatibility);
   _activeProject = { rootPath: info.path, config: info.config as ProjectConfig };
   _notify();
   return _activeProject;
@@ -157,6 +236,7 @@ export async function detectProject(): Promise<ActiveProject | null> {
     const backend = getStorageBackend();
     await seedIfEmpty(backend);
     const config = await readProjectManifest(backend);
+    assertProjectCompatibility(config, BUNDLED_EDITOR_COMPATIBILITY);
     _activeProject = { rootPath: restored?.status === 'granted' ? 'fsa' : 'browser', config };
     _notify();
     return _activeProject;

package/src/project-operations.ts

@@ -0,0 +1,112 @@
+import { connectOperationFileEvents } from './asset-events';
+import { getEditorMode } from './editor-mode';
+import { onProjectChange } from './project-manager';
+
+export interface ProjectOperationCatalogEntry {
+  name: string;
+  summary: string;
+  description: string;
+  sourcePath: string;
+  inputSchema: unknown;
+  resultSchema: unknown;
+  errors: Array<{ code: string; summary: string; dataSchema?: unknown }>;
+  requires: Record<string, boolean | undefined>;
+  host: 'node' | 'editor-browser' | 'runtime-page';
+  mutates: boolean;
+  supportsDryRun: boolean;
+  longRunning: boolean;
+  permission: { risk: 'read' | 'write' | 'destructive'; summary: string };
+}
+
+export interface ProjectOperationCatalog {
+  operations: ProjectOperationCatalogEntry[];
+  loadErrors: Array<{ sourcePath: string; message: string }>;
+}
+
+export type ProjectOperationOutcome =
+  | { ok: true; data: unknown }
+  | { ok: false; error: { code: string; message: string; data?: unknown; issues?: unknown[] } };
+
+const EMPTY_CATALOG: ProjectOperationCatalog = { operations: [], loadErrors: [] };
+let catalog = EMPTY_CATALOG;
+let version = 0;
+const listeners = new Set<() => void>();
+
+function publish(next: ProjectOperationCatalog): void {
+  catalog = next;
+  version++;
+  for (const listener of listeners) listener();
+}
+
+export function getProjectOperations(): ProjectOperationCatalog {
+  return catalog;
+}
+
+export function projectOperationsVersion(): number {
+  return version;
+}
+
+export function subscribeProjectOperations(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export async function refreshProjectOperations(): Promise<ProjectOperationCatalog> {
+  if (getEditorMode() === 'browser') {
+    publish(EMPTY_CATALOG);
+    return EMPTY_CATALOG;
+  }
+  try {
+    const response = await fetch('/__editor/project-operations');
+    if (!response.ok) throw new Error(`catalog request failed (${response.status})`);
+    const next = (await response.json()) as ProjectOperationCatalog;
+    publish(next);
+    return next;
+  } catch (error) {
+    const next = {
+      operations: [],
+      loadErrors: [
+        {
+          sourcePath: 'src/operations',
+          message: error instanceof Error ? error.message : String(error),
+        },
+      ],
+    };
+    publish(next);
+    return next;
+  }
+}
+
+export async function runProjectOperation(
+  name: string,
+  input: unknown,
+  options: { confirm?: boolean } = {},
+): Promise<ProjectOperationOutcome> {
+  const response = await fetch('/__editor/project-operations/run', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name, input, confirm: options.confirm === true }),
+  });
+  const outcome = (await response.json()) as ProjectOperationOutcome;
+  if (!outcome || typeof outcome !== 'object' || typeof outcome.ok !== 'boolean') {
+    throw new Error(`Operation request returned an invalid response (${response.status}).`);
+  }
+  return outcome;
+}
+
+/** Editor-init lifecycle for Node-side project operation discovery. */
+export function startProjectOperationDiscovery(): () => void {
+  void refreshProjectOperations();
+  const stopProjectWatch = onProjectChange(() => void refreshProjectOperations());
+  const stopFileWatch = connectOperationFileEvents(() => void refreshProjectOperations());
+  return () => {
+    stopProjectWatch();
+    stopFileWatch();
+  };
+}
+
+export function __resetProjectOperationsForTest(): void {
+  catalog = EMPTY_CATALOG;
+  version = 0;
+  listeners.clear();
+}

package/src/project-story-discovery.ts

@@ -0,0 +1,25 @@
+/**
+ * Project Storybook discovery lifecycle. Story navigation is a project
+ * capability, not a side effect of mounting a particular React world or
+ * opening a Story document, so the editor starts discovery once at init.
+ */
+
+import { connectStoryFileEvents } from './asset-events';
+import { getCurrentProject, onProjectChange } from './project-manager';
+import { refreshProjectStories } from './stories/story-registry';
+
+function refresh(): void {
+  void refreshProjectStories(getCurrentProject());
+}
+
+/** Discover immediately, then re-discover on project switches and CSF file
+ * add/remove events. In-flight refreshes are allowed to settle. */
+export function startProjectStoryDiscovery(): () => void {
+  refresh();
+  const stopProjectWatch = onProjectChange(refresh);
+  const stopStoryFileWatch = connectStoryFileEvents(refresh);
+  return () => {
+    stopProjectWatch();
+    stopStoryFileWatch();
+  };
+}

package/src/project-tool-discovery.ts

@@ -0,0 +1,43 @@
+/**
+ * Project-tool discovery LIFECYCLE (W0, docs/EDITOR-WORKSPACE-SHELL-TODO.md
+ * §7.2/§9 W0 — "project tool discovery must move out of `BottomPanel` and
+ * into project/editor initialization").
+ *
+ * Until W0, `BottomPanel.tsx` anchored discovery in its own mount effects:
+ * the dock was both the DISCOVERER and one consumer of project tools, so
+ * inspector-placement tools only loaded because the bottom dock happened to
+ * be mounted. This module owns that lifecycle instead; the editor shell
+ * starts it once at editor initialization (`EditorContext.tsx`'s
+ * `EditorProvider`), and the placement hosts (center tool documents,
+ * workspace-utility registrations — `components/tool-documents.tsx`,
+ * tool-loader.ts's `getGlobalTools`/`subscribeGlobalTools`) are plain
+ * consumers of the already-discovered store — proven by
+ * `test/project-tool-discovery.test.ts`, which runs discovery with no
+ * component module imported at all.
+ *
+ * The pass itself is unchanged (`refreshProjectTools`, tool-loader.ts):
+ * discover on start, re-discover when the open project changes, and
+ * re-discover on server-watched `src/tools/` add/unlink events (W6a,
+ * docs/DATA-TOOLS-DESIGN.md §7). Edit-HMR stays where it was — tool-loader's
+ * own module-level `vgai:script-update` listener.
+ */
+
+import { connectToolFileEvents } from './asset-events';
+import { onProjectChange } from './project-manager';
+import { refreshProjectTools } from './tool-loader';
+
+/**
+ * Start the project-tool discovery lifecycle: one immediate discovery pass,
+ * plus re-discovery on project change and on tool-file add/unlink events.
+ * Returns a stop function that disconnects both subscriptions (the pass in
+ * flight is left to finish — `refreshProjectTools` never throws).
+ */
+export function startProjectToolDiscovery(): () => void {
+  void refreshProjectTools();
+  const stopProjectWatch = onProjectChange(() => void refreshProjectTools());
+  const stopToolFileWatch = connectToolFileEvents(() => void refreshProjectTools());
+  return () => {
+    stopProjectWatch();
+    stopToolFileWatch();
+  };
+}

package/src/scene-serializer.ts

@@ -10,7 +10,6 @@
  */
 
 import type { SceneEntity, SceneEnvironment, SceneFile } from '@engine/scene/scene-types';
-import type { UIRoot } from '@engine/scene/schema';
 import { getUserData } from '@engine/scene/user-data';
 import type * as THREE from 'three';
 
@@ -18,8 +17,6 @@ export interface SceneMetadata {
   version: number;
   name: string;
   environment?: SceneEnvironment;
-  /** Scene-graph UI (the `ui` field) — preserved through load/serialize (A1/C9). */
-  ui?: UIRoot[];
 }
 
 type Transform = NonNullable<SceneEntity['transform']>;
@@ -68,9 +65,6 @@ export function serializeScene(scene: THREE.Scene, meta: SceneMetadata): SceneFi
   if (meta.environment) {
     doc.environment = meta.environment;
   }
-  if (meta.ui && meta.ui.length > 0) {
-    doc.ui = meta.ui;
-  }
 
   return doc;
 }

package/src/scene-sync.ts

@@ -81,6 +81,7 @@ const prefabPreviewCache = new Map<string, PrefabFile>();
 
 /** Cache for loaded .mat.json materials. */
 const materialRefCache = new Map<string, SceneMaterial>();
+let materialRefCacheGeneration = 0;
 
 /** Cache for processed environment map textures. */
 const envTextureCache = new Map<string, THREE.Texture>();
@@ -134,6 +135,7 @@ export function clearPrefabPreviewCache(): void {
 
 /** Invalidate the material ref cache (e.g. when a .mat.json is saved). */
 export function clearMaterialRefCache(): void {
+  materialRefCacheGeneration++;
   materialRefCache.clear();
 }
 
@@ -160,11 +162,12 @@ function resolveEntityMaterial(
   // unreachable/404 file).
   const ref = entity.materialRef;
   const id = entity.id;
-  fetch(resolveUrl(ref))
+  const generation = materialRefCacheGeneration;
+  fetch(resolveUrl(ref), { cache: 'no-store' })
     .then((res) => (res.ok ? res.json() : null))
     .then((json) => (json === null ? null : parseMaterialFile(json, ref)))
     .then((file) => {
-      if (!file) return;
+      if (!file || generation !== materialRefCacheGeneration) return;
       materialRefCache.set(ref, file.material);
       // Rebuild the entity's preview object with the loaded material
       if (id) {
@@ -384,6 +387,7 @@ export function updateEntityPreview(
 
   const existing = objectMap.get(entity.id);
   if (!existing) return;
+  const skeletonVisible = Boolean(getUserData(existing, 'skeletonVisible'));
 
   // Unregister old particle systems (only on the entity itself, not child entities)
   unregisterParticles(existing, batchedRenderer ?? null);
@@ -416,6 +420,7 @@ export function updateEntityPreview(
     visualEntity = resolveEntityMaterial(entity, objectMap, scene);
   }
   const newObj = createEntityObject(visualEntity);
+  setUserData(newObj, 'skeletonVisible', skeletonVisible);
   // Restore the original (unresolved) entity as the source of truth.
   // This preserves prefab ref, materialRef, and any instance-level overrides.
   setUserData(newObj, 'entity', JSON.parse(JSON.stringify(entity)) as SceneEntity);

package/src/script-loader.ts

@@ -72,8 +72,7 @@ function extractProjectScripts(
   if (!adapter && !setup) {
     throw new Error(
       `Project script at ${scriptEntry} exports neither \`adapter\` nor \`setup\` — every ` +
-        'first-party entry module exports at least one (see ' +
-        'packages/editor/template/src/scripts/main.ts).',
+        'explicit first-party entry module exports at least one.',
     );
   }
 
@@ -109,7 +108,8 @@ export function setLoadedComponents(components: Record<string, GameComponentClas
 /**
  * Load project scripts from the given project path.
  *
- * The project's entry point is `src/scripts/main.ts`, which must export
+ * A legacy or explicitly declared project entry (defaulting to
+ * `src/scripts/main.ts` for compatibility) must export
  * EITHER (or both — the EDITOR prefers `setup`, which alone threads
  * `editorPreview` + the firstParty HMR brand, see
  * `resolveDefaultThreeAdapter`; standalone prefers `adapter`,

package/src/skeleton-helper.ts

@@ -0,0 +1,57 @@
+import { getUserData, setUserData } from '@engine/scene/user-data';
+import * as THREE from 'three';
+import { EDITOR_LAYER } from './editor-layers';
+
+const SKELETON_HELPER_TYPE = 'skeletons';
+const SKELETON_PARENT_COLOR = new THREE.Color(0x00e5ff);
+const SKELETON_CHILD_COLOR = new THREE.Color(0xffb000);
+
+function applyEditorSkeletonColors(helper: THREE.SkeletonHelper): void {
+  const colors = helper.geometry.getAttribute('color');
+  // SkeletonHelper emits two vertices per bone link. Three's stock pure
+  // blue/green endpoints disappear against vgai's dark viewport, especially
+  // in captures. Keep the native helper geometry, but use editor-contrast
+  // colors so the inspection affordance is actually visible.
+  for (let i = 0; i < colors.count; i += 2) {
+    colors.setXYZ(i, SKELETON_PARENT_COLOR.r, SKELETON_PARENT_COLOR.g, SKELETON_PARENT_COLOR.b);
+    if (i + 1 < colors.count) {
+      colors.setXYZ(i + 1, SKELETON_CHILD_COLOR.r, SKELETON_CHILD_COLOR.g, SKELETON_CHILD_COLOR.b);
+    }
+  }
+  colors.needsUpdate = true;
+}
+
+export function ensureSkeletonHelper(root: THREE.Object3D): THREE.SkeletonHelper | null {
+  let existing: THREE.SkeletonHelper | null = null;
+  let hasSkinnedMesh = false;
+  root.traverse((object) => {
+    if (getUserData(object, 'editorHelperType') === SKELETON_HELPER_TYPE) {
+      existing = object as THREE.SkeletonHelper;
+    }
+    if ((object as THREE.SkinnedMesh).isSkinnedMesh) hasSkinnedMesh = true;
+  });
+  if (existing || !hasSkinnedMesh) return existing;
+
+  const helper = new THREE.SkeletonHelper(root);
+  if (helper.bones.length === 0) {
+    helper.dispose();
+    return null;
+  }
+  applyEditorSkeletonColors(helper);
+
+  // SkeletonHelper normally expects to be a scene-root sibling. Keeping it
+  // under the entity makes lifecycle cleanup automatic, so use entity-local
+  // coordinates instead of applying the entity world transform twice.
+  helper.matrix = new THREE.Matrix4();
+  helper.matrixAutoUpdate = false;
+  helper.name = 'EditorSkeletonHelper';
+  helper.renderOrder = 999;
+  helper.visible = Boolean(getUserData(root, 'skeletonVisible'));
+  setUserData(helper, 'editorHelper', true);
+  setUserData(helper, 'editorHelperType', SKELETON_HELPER_TYPE);
+  setUserData(helper, 'skeletonEnabled', helper.visible);
+  helper.traverse((child) => child.layers.set(EDITOR_LAYER));
+  root.add(helper);
+  root.updateMatrixWorld(true);
+  return helper;
+}

package/src/storage/seed.ts

@@ -9,12 +9,15 @@
  * require routing the engine's asset pipeline through the backend.
  */
 
+import { loadGameManifest } from '@engine/manifest/load';
 import { parseSceneFile } from '@engine/scene/parse';
+import { BUNDLED_ENGINE_VERSION } from '../build-identity';
 import type { StorageBackend } from './types';
 
 export const STARTER_SCENE_PATH = 'scenes/default.vscn.json';
 const STARTER_INPUTMAP_PATH = 'inputmaps/default.inputmap.json';
-const PROJECT_MANIFEST_PATH = 'project.json';
+const PROJECT_MANIFEST_PATH = 'vgai.game.json';
+const STARTER_UI_PATH = 'src/ui/game.tsx';
 
 /** Minimal, asset-free scene: a camera, a light, a ground plane, and a box. */
 const STARTER_SCENE = {
@@ -64,10 +67,47 @@ const STARTER_INPUTMAP = {
 };
 
 const PROJECT_MANIFEST = {
+  manifestVersion: 2 as const,
   name: 'Browser Project',
-  defaultScene: STARTER_SCENE_PATH,
+  version: '0.1.0',
+  engine: { version: BUNDLED_ENGINE_VERSION },
+  roots: [
+    { id: 'world', adapter: 'threejs', scene: STARTER_SCENE_PATH },
+    { id: 'ui', adapter: 'react', entry: STARTER_UI_PATH, zOrder: 100 },
+  ],
 };
 
+const STARTER_UI = `export default function GameUI() {
+  return <div style={{ position: 'absolute', left: 24, top: 20, color: 'white' }}>Browser Project</div>;
+}\n`;
+
+async function refreshSeededManifestIdentity(backend: StorageBackend): Promise<void> {
+  if (!(await backend.exists(PROJECT_MANIFEST_PATH))) {
+    await backend.write(PROJECT_MANIFEST_PATH, JSON.stringify(PROJECT_MANIFEST, null, 2));
+    return;
+  }
+  try {
+    const current = JSON.parse(await backend.read(PROJECT_MANIFEST_PATH)) as Record<
+      string,
+      unknown
+    >;
+    const engine = current['engine'];
+    if (
+      current['name'] === PROJECT_MANIFEST.name &&
+      engine &&
+      typeof engine === 'object' &&
+      (engine as Record<string, unknown>)['version'] !== BUNDLED_ENGINE_VERSION
+    ) {
+      await backend.write(
+        PROJECT_MANIFEST_PATH,
+        JSON.stringify({ ...current, engine: { version: BUNDLED_ENGINE_VERSION } }, null, 2),
+      );
+    }
+  } catch {
+    // Manifest parsing reports its own actionable error when the project opens.
+  }
+}
+
 /**
  * Seed the Starter project into `backend` if it has not been seeded yet.
  * Idempotent — returns immediately once a VALID default scene exists.
@@ -79,6 +119,7 @@ const PROJECT_MANIFEST = {
  * bare scene on every visit.
  */
 export async function seedIfEmpty(backend: StorageBackend): Promise<void> {
+  await refreshSeededManifestIdentity(backend);
   if (await backend.exists(STARTER_SCENE_PATH)) {
     // Validate the existing scene; only re-seed the scene file if it's broken.
     try {
@@ -91,16 +132,35 @@ export async function seedIfEmpty(backend: StorageBackend): Promise<void> {
   }
   await backend.write(STARTER_SCENE_PATH, JSON.stringify(STARTER_SCENE, null, 2));
   await backend.write(STARTER_INPUTMAP_PATH, JSON.stringify(STARTER_INPUTMAP, null, 2));
-  await backend.write(PROJECT_MANIFEST_PATH, JSON.stringify(PROJECT_MANIFEST, null, 2));
+  await backend.write(STARTER_UI_PATH, STARTER_UI);
 }
 
 /** Read the project manifest from a backend, or a default if absent. */
-export async function readProjectManifest(
-  backend: StorageBackend,
-): Promise<{ name: string; defaultScene: string }> {
+export async function readProjectManifest(backend: StorageBackend): Promise<{
+  manifestVersion: 2;
+  name: string;
+  version: string;
+  engine: { version: string };
+  defaultScene: string;
+}> {
   try {
-    return JSON.parse(await backend.read(PROJECT_MANIFEST_PATH));
+    const manifest = loadGameManifest(JSON.parse(await backend.read(PROJECT_MANIFEST_PATH)));
+    return {
+      manifestVersion: manifest.manifestVersion,
+      name: manifest.name,
+      version: manifest.version,
+      engine: manifest.engine,
+      defaultScene:
+        manifest.roots.find((candidate) => candidate.scene !== undefined)?.scene ??
+        STARTER_SCENE_PATH,
+    };
   } catch {
-    return { ...PROJECT_MANIFEST };
+    return {
+      manifestVersion: PROJECT_MANIFEST.manifestVersion,
+      name: PROJECT_MANIFEST.name,
+      version: PROJECT_MANIFEST.version,
+      engine: PROJECT_MANIFEST.engine,
+      defaultScene: STARTER_SCENE_PATH,
+    };
   }
 }