@volter/cyclotron 0.5.211 → 0.5.213

package/dist-node/create.js

@@ -5,11 +5,11 @@ var __export = (target, all) => {
 };
 
 // node/create.ts
-import { spawn } from "node:child_process";
-import { constants, existsSync, symlinkSync } from "node:fs";
-import { mkdir, writeFile, copyFile, readFile, readdir } from "node:fs/promises";
-import { resolve, join, dirname, relative } from "node:path";
-import { fileURLToPath } from "node:url";
+import { spawn as spawn2 } from "node:child_process";
+import { constants, existsSync as existsSync2, symlinkSync } from "node:fs";
+import { appendFile, mkdir, writeFile, copyFile, readFile, readdir, rm } from "node:fs/promises";
+import { resolve as resolve2, join as join2, dirname as dirname2, relative as relative2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -13780,99 +13780,61 @@ function date4(params) {
 config(en_default());
 
 // ../project/src/manifest/schema.ts
-var GAME_MANIFEST_VERSION = 2;
-var REMOVED_SURFACE_SPELLING = {
-  threejs: "three",
-  pixijs: "canvas",
-  react: "dom"
-};
-var REMOVED_BARE_ADAPTER_SPELLING = {
-  threejs: "three",
-  pixijs: "canvas",
-  react: "dom"
-};
-function removedSpellingMessage(bad, where) {
-  const canonical = where === "adapter" ? REMOVED_BARE_ADAPTER_SPELLING[bad] : REMOVED_SURFACE_SPELLING[bad];
-  return `Game manifest: \`${where}\`: "${bad}" \u2014 that spelling was REMOVED (ARCHITECTURE-CORE \xA7Vocabulary). The surface vocabulary is 'three' | 'canvas' | 'dom' \u2014 what the HOST HANDS the root, never which library it uses.
-Fix: change \`${where}\` to "${canonical}".`;
-}
-function rejectRemovedRootAdapterSpelling(value, ctx) {
-  if (typeof value === "string" && REMOVED_BARE_ADAPTER_SPELLING[value]) {
-    ctx.addIssue({ code: "custom", message: removedSpellingMessage(value, "adapter") });
-    return external_exports.NEVER;
-  }
-  if (value && typeof value === "object" && "surface" in value) {
-    const surface = value.surface;
-    if (typeof surface === "string" && REMOVED_SURFACE_SPELLING[surface]) {
-      ctx.addIssue({
-        code: "custom",
-        message: removedSpellingMessage(surface, "adapter.surface")
-      });
-      return external_exports.NEVER;
-    }
-  }
-  return value;
-}
-var RootAdapterSchema = external_exports.preprocess(
-  rejectRemovedRootAdapterSpelling,
-  external_exports.union([
-    external_exports.enum(["three", "canvas", "dom"]),
-    external_exports.object({
-      module: external_exports.string().describe("Game-folder-relative path to a custom adapter module (trust boundary)"),
-      surface: external_exports.enum(["three", "canvas", "dom"]).describe("Native surface exposed by this custom adapter contract")
-    }).strict(),
-    external_exports.object({
-      surface: external_exports.enum(["three", "canvas", "dom"]).describe("Native surface captured from the unmodified game"),
-      ingest: external_exports.object({
-        contractShim: external_exports.string().optional().describe(
-          "Project-relative path to a HOST-ADDED ES module that declares this game's `window.volterGame` contract (adapter/ingest/game-contract.ts) WITHOUT editing a vendored byte \u2014 the pristine-copy door. The host imports it immediately BEFORE the game's own entry module, in the editor's realm. TIMING CONTRACT, which a shim author must obey: because it runs before the game`s entry, it MUST assign `window.volterGame` SYNCHRONOUSLY at top level. Anything that needs the game`s own modules must be LAZY: a dynamic `import()` INSIDE each verb/provider closure, resolved at call time. Importing a game module eagerly from the shim would evaluate it ahead of the game`s own entry and reorder its module side effects. Every such `import()` MUST take a STRING LITERAL, never a variable/table lookup. A variable specifier is not statically analyzable, so the dev server leaves it alone and it resolves at runtime against the shim`s own `/@fs/` url \u2014 while the game`s entry has had ITS relative imports rewritten to whatever url the server considers canonical for those files. Module identity is per-url, so the shim silently binds a SECOND, freshly-evaluated copy of the whole game and every provider reports a game that never started. Measured on a vendored three game: 285 world segments through the game`s own graph, 0 through the shim`s, and no error anywhere."
-        ),
-        dataWriter: external_exports.string().optional().describe(
-          "Project-relative path to a HOST-ADDED ES module that writes this game's own DATA file back \u2014 the sibling of a source write for a game whose authorable truth is not source. A level-based game places its enemies, pickups and objectives in binary records inside a level file, reaching no source literal, so an authored move of one is an edit to that file and nothing else can write it. The module declares two exports and the host knows nothing else about it: `dataFile` (a project-relative string \u2014 the ONE file this writer edits) and `planDataEdit(bytes, {record, property, baseline, next})`, which returns `{changed: true, bytes}` or `{changed: false, reason}` and may be async. It is loaded in the editor realm beside the game, so it may `import()` the game's own modules to resolve what only a running game knows (a level writer asks the game`s own spatial lookup which cell a moved object landed in, and refuses \"outside the level\" rather than writing data the game would read back wrong). It NEVER fabricates: a record it cannot address, or a property it does not model, is a named refusal. An object is anchored to a record by carrying `userData.volterRecordIndex` \u2014 the game declares that identity itself (a recorded patch or a shim); the host never infers one."
-        ),
-        assets: external_exports.record(external_exports.string(), external_exports.string()).optional().describe(
-          "Path-substring -> served-URL rewrites for this ingested game (IngestGame.assets today)"
-        ),
-        moduleAliases: external_exports.record(external_exports.string(), external_exports.string()).optional().describe(
-          "The game's OWN bundler path aliases, restated as a mounting fact so its source resolves unedited. A game built with its own Vite/webpack config routinely imports itself through an alias (`~/lib/config`, `@/store/x`); the editor boots Vite from the ENGINE's config and never reads a game's own, so without this every such import is an unresolvable specifier and the mount dies at transform time. Key = the specifier PREFIX exactly as the game writes it (\"~/\"); value = the repo-root-relative directory it means (\"/vendor/games/<id>/src/\"). SELF-SCOPING: the host honors an entry only for importers inside the vendored game folder the value points into, so one game's alias can never capture another module's import. Rewriting the game's own imports instead would be a large non-seam-shaped diff against unmodified source \u2014 this declares the fact rather than editing it away."
-        ),
-        domStubs: external_exports.array(external_exports.string()).optional().describe(
-          "DOM API stub ids this ingested game requires to run headlessly/in-realm"
-        ),
-        captureTimeoutMs: external_exports.number().optional().describe(
-          "How long the host waits for this game's first captured frame before the mount FAILS by name. A game that needs a long boot (streamed world assets, a menu the player must clear) raises it; the default is 10s."
-        )
-      }).strict().describe(
-        "Ingest adapter configuration for an unmodified game (a repo-vendored game or your own external folder)"
+var PROJECT_MANIFEST_VERSION = 2;
+var RootAdapterSchema = external_exports.union([
+  external_exports.enum(["stage", "canvas", "dom"]),
+  external_exports.object({
+    module: external_exports.string().describe("Project-folder-relative path to a custom adapter module (trust boundary)"),
+    surface: external_exports.enum(["stage", "canvas", "dom"]).describe("Native surface exposed by this custom adapter contract")
+  }).strict(),
+  external_exports.object({
+    surface: external_exports.enum(["stage", "canvas", "dom"]).describe("Native surface captured from the unmodified project"),
+    ingest: external_exports.object({
+      dataWriter: external_exports.string().optional().describe(
+        "Project-relative path to a HOST-ADDED ES module that writes this project's own DATA file back \u2014 the sibling of a source write for a project whose authorable truth is not source. A level-based project places its enemies, pickups and objectives in binary records inside a level file, reaching no source literal, so an authored move of one is an edit to that file and nothing else can write it. The module declares two exports and the host knows nothing else about it: `dataFile` (a project-relative string \u2014 the ONE file this writer edits) and `planDataEdit(bytes, {record, property, baseline, next})`, which returns `{changed: true, bytes}` or `{changed: false, reason}` and may be async. It is loaded in the editor realm beside the project, so it may `import()` the project's own modules to resolve what only a running project knows (a level writer asks the project`s own spatial lookup which cell a moved object landed in, and refuses \"outside the level\" rather than writing data the project would read back wrong). It NEVER fabricates: a record it cannot address, or a property it does not model, is a named refusal. An object is anchored to a record by carrying `userData.volterRecordIndex` \u2014 the project declares that identity itself (a recorded patch or a shim); the host never infers one."
+      ),
+      assets: external_exports.record(external_exports.string(), external_exports.string()).optional().describe(
+        "Path-substring -> served-URL rewrites for this ingested project"
+      ),
+      moduleAliases: external_exports.record(external_exports.string(), external_exports.string()).optional().describe(
+        "The project's OWN bundler path aliases, restated as a mounting fact so its source resolves unedited. A project built with its own Vite/webpack config routinely imports itself through an alias (`~/lib/config`, `@/store/x`); the editor boots Vite from the ENGINE's config and never reads a project's own, so without this every such import is an unresolvable specifier and the mount dies at transform time. Key = the specifier PREFIX exactly as the project writes it (\"~/\"); value = the repo-root-relative directory it means (\"/vendor/<id>/src/\"). SELF-SCOPING: the host honors an entry only for importers inside the vendored folder the value points into, so one project's alias can never capture another module's import. Rewriting the project's own imports instead would be a large non-seam-shaped diff against unmodified source \u2014 this declares the fact rather than editing it away."
+      ),
+      domStubs: external_exports.array(external_exports.string()).optional().describe(
+        "DOM API stub ids this ingested project requires to run headlessly/in-realm"
+      ),
+      captureTimeoutMs: external_exports.number().optional().describe(
+        "How long the host waits for this project's first captured frame before the mount FAILS by name. A project that needs a long boot (streamed world assets, a menu the player must clear) raises it; the default is 10s."
       )
-    }).strict()
-  ])
-).describe(
-  "Root adapter identity: built-in 'three'/'canvas'/'dom' (what the host hands the root \u2014 'canvas' covers Pixi/Phaser/Babylon/raw WebGL, 'dom' covers React/Vue/plain HTML), a custom { module, surface } adapter, or an { ingest, surface } adapter for an unmodified game."
+    }).strict().describe(
+      "Ingest adapter configuration for an unmodified project (a repo-vendored one or your own external folder)"
+    )
+  }).strict()
+]).describe(
+  "Root adapter identity: built-in 'stage'/'canvas'/'dom' (what the host hands the root \u2014 'canvas' covers any canvas library or raw WebGL, 'dom' covers React/Vue/plain HTML), a custom { module, surface } adapter, or an { ingest, surface } adapter for an unmodified project."
 );
 var AdapterRootSchema = external_exports.object({
   id: external_exports.string().describe(
-    "Unique id for this root within the manifest (enforced-unique, D-V6 \u2014 GameManifestSchema.roots rejects duplicates)"
+    "Unique id for this root within the manifest (enforced-unique, D-V6 \u2014 ProjectManifestSchema.roots rejects duplicates)"
   ),
   description: external_exports.string().optional().describe(
-    "Optional one-line description of this root's game/content (e.g. an ingested game's blurb \u2014 the manifest-native replacement for a registry entry's description field)"
+    "Optional one-line description of this root's content"
   ),
   adapter: RootAdapterSchema.describe(
     "This root's adapter and sole rendering/lifecycle discriminator"
   ),
   entry: external_exports.string().optional().describe(
-    "Module exporting a world root \u2014 a TSX/R3F component or a setup()/adapter (three), or a React component (dom). Required for every built-in adapter root."
+    "Module exporting a world root \u2014 a TSX component, which the built-in stage dialect renders, or a setup()/adapter (stage), or a React component (dom). Required for every built-in adapter root."
   ),
   styles: external_exports.array(external_exports.string()).optional().describe(
-    "Project-root-relative CSS files this root's mount needs \u2014 the PAGE-level stylesheet a game written to own a browser tab keeps its layout in (an ingested game is the standing case: its own entry imported the sheet, the host shim that replaces that entry cannot, because `html`/`body`/`*` rules would restyle the editor). Declared here, the editor serves each file rewritten to apply ONLY inside the container it mounts the root's DOM in (`@scope`; packages/editor/server/scoped-game-css.ts), so the HUD is styled on the UI board's story cards and on the game surface without the editor seeing a single one of those rules. The files themselves are never modified."
+    "Project-root-relative CSS files this root's mount needs \u2014 the PAGE-level stylesheet a project written to own a browser tab keeps its layout in (an ingested project is the standing case: its own entry imported the sheet, the host shim that replaces that entry cannot, because `html`/`body`/`*` rules would restyle the editor). Declared here, the editor serves each file rewritten to apply ONLY inside the container it mounts the root's DOM in (`@scope`; packages/sdk/src/scoped-project-css.ts), so the HUD is styled on the UI board's story cards and on the play surface without the editor seeing a single one of those rules. The files themselves are never modified."
   ),
   world: external_exports.object({
-    entry: external_exports.string().describe("Project-relative path to the game's OWN module exporting that component"),
+    entry: external_exports.string().describe("Project-relative path to the project's OWN module exporting that component"),
     export: external_exports.string().optional().describe(
       "Named export to read from that module; omit when the module default-exports it"
     )
   }).strict().optional().describe(
-    "The component this root's WORLD is, in the game's own source. Two readers, and they mount different things: the EDITOR mounts THIS component alone as the root's design-time document, while `entry` above stays what PLAY mounts (the whole game \u2014 its own composition, its own HUD, its own loop). It sits on the ROOT rather than inside any one adapter because the split it names is not about ingest: a game whose runtime entry is a SHELL over the thing an author actually edits has this shape whether the source is vendored or first-party. Two shipped cases, one field: an ingested game whose `entry` mounts game+HUD+loop while the named export is the world alone; and a translated Unity/Godot port, whose `entry` is a scene HOST that mounts the scene the built player starts on (`EditorBuildSettings` index 0 \u2014 routinely a menu with no 3D content at all) while the named export opens the scene an author edits. That is Unity's own split: build settings say where the PLAYER starts; the Scene view opens a scene, and Unity keeps that fact somewhere else entirely. A game whose world is not a separate component omits this and keeps mounting through `entry` in both modes."
+    "The component this root's WORLD is, in the project's own source. Two readers, and they mount different things: the EDITOR mounts THIS component alone as the root's design-time document, while `entry` above stays what PLAY mounts (the whole project \u2014 its own composition, its own HUD, its own loop). It sits on the ROOT rather than inside any one adapter because the split it names is not about ingest: a project whose runtime entry is a SHELL over the thing an author actually edits has this shape whether the source is vendored or first-party. A project whose world is not a separate component omits this and keeps mounting through `entry` in both modes."
   ),
   zOrder: external_exports.number().int().default(0).describe("Canvas stacking order; ties broken by array order"),
   pausable: external_exports.boolean().default(true).describe("Whether play-mode pause/step applies to this root"),
@@ -13883,41 +13845,39 @@ var AdapterRootSchema = external_exports.object({
 function rootMedium(root) {
   return typeof root.adapter === "string" ? root.adapter : root.adapter.surface;
 }
-var LearnKindSchema = external_exports.enum(["starter", "feature", "sample-game", "lesson-companion"]).describe(
-  "Content kind in the FTUE taxonomy (\xA73): starter (minimal per-genre starting point), feature (demonstrates a subsystem), sample-game (complete game as an architectural reference), lesson-companion (exists to back a Learn-site lesson)"
+var LearnKindSchema = external_exports.enum(["starter", "feature", "sample-project", "lesson-companion"]).describe(
+  "Content kind: starter (minimal per-genre starting point), feature (demonstrates a subsystem), sample-project (a complete project as an architectural reference), lesson-companion (exists to back a Learn-site lesson)"
 );
 var LearnDifficultySchema = external_exports.enum(["beginner", "intermediate", "advanced"]).describe("Learner-facing difficulty rating");
 var LearnMetadataSchema = external_exports.object({
   kind: LearnKindSchema,
-  title: external_exports.string().min(1).describe("Learner-facing display title (gallery card headline)"),
-  summary: external_exports.string().min(1).describe("One-sentence learner-facing summary (gallery card body)"),
+  title: external_exports.string().min(1).describe("Learner-facing display title"),
+  summary: external_exports.string().min(1).describe("One-sentence learner-facing summary"),
   difficulty: LearnDifficultySchema,
-  features: external_exports.array(external_exports.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "features tags must be kebab-case")).describe("Short kebab-case feature tags used as gallery/catalog filter facets"),
+  features: external_exports.array(external_exports.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "features tags must be kebab-case")).describe("Short kebab-case tags describing project features"),
   thumbnail: external_exports.string().optional().describe(
-    "Optional thumbnail image reference, PROJECT-relative (canonical path: learn/thumbnail.png \u2014 the \xA73 schema path). Generated per FT-11 by the deterministic render tooling (scripts/generate-learn-thumbnails.ts), never hand-made"
+    "Optional thumbnail image reference, PROJECT-relative (canonical path: learn/thumbnail.png)"
   ),
   preview: external_exports.string().optional().describe(
-    "Optional short preview video/loop reference, PROJECT-relative (canonical path: learn/preview.mp4; generated per FT-11)"
+    "Optional short preview video/loop reference, PROJECT-relative (canonical path: learn/preview.mp4)"
   ),
   lesson: external_exports.string().optional().describe(
     "Optional Learn-site lesson URL that teaches this project 1:1 (e.g. https://example.com/manual/physics/joints/)"
   )
 }).strict().describe(
-  "Learner-facing metadata (FT-5) \u2014 powers the example gallery, New Project wizard, and Learn-site catalog. Registries are generated from this block; there is no parallel hand-edited catalog."
+  "Learner-facing metadata carried by example project manifests."
 );
-var ConfigurationEnvelopeSchema = external_exports.object({
-  id: external_exports.string().min(1).describe("Configuration id, unique in the manifest"),
-  kind: external_exports.string().min(1).describe("A registered run kind")
-}).passthrough();
-var GameManifestSchema = external_exports.object({
+var ProjectManifestSchema = external_exports.object({
   $schema: external_exports.string().optional().describe("Optional JSON Schema URI for editor autocomplete and validation"),
-  manifestVersion: external_exports.literal(GAME_MANIFEST_VERSION).describe("Manifest file format version (v2 clean roots)"),
-  name: external_exports.string().describe("Game display name"),
+  manifestVersion: external_exports.number().int().describe(
+    `The manifest format version the project was written with (this editor writes ${PROJECT_MANIFEST_VERSION}); a manifest is read by its shape, never refused for its number`
+  ),
+  name: external_exports.string().describe("Project display name"),
   appId: external_exports.string().optional().describe("Stable reverse-domain application id used by packaged targets"),
-  version: external_exports.string().describe("The game's own version (used for orphan detection)"),
+  version: external_exports.string().describe("The project's own version"),
   engine: external_exports.object({
     version: external_exports.string().describe(
-      "Exact @volter/project semver this game was scaffolded/last upgraded against \u2014 an identity pin, not a range"
+      "Exact @volter/project semver this project was scaffolded/last upgraded against \u2014 an identity pin, not a range"
     )
   }).strict().describe("Engine version pin"),
   roots: external_exports.array(AdapterRootSchema).superRefine((roots, ctx) => {
@@ -13928,7 +13888,7 @@ var GameManifestSchema = external_exports.object({
       const idsText = duplicates.map((id) => `"${id}"`).join(", ");
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
-        message: duplicates.length === 1 ? `Game manifest: duplicate root id ${idsText} \u2014 root ids must be unique across the manifest (enforced-unique).` : `Game manifest: duplicate root ids: ${idsText} \u2014 root ids must be unique across the manifest (enforced-unique).`
+        message: duplicates.length === 1 ? `Project manifest: duplicate root id ${idsText} \u2014 root ids must be unique across the manifest (enforced-unique).` : `Project manifest: duplicate root ids: ${idsText} \u2014 root ids must be unique across the manifest (enforced-unique).`
       });
     }
     const idsByMedium = /* @__PURE__ */ new Map();
@@ -13942,11 +13902,11 @@ var GameManifestSchema = external_exports.object({
       if (ids.length < 2) continue;
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
-        message: `Game manifest: a project has at most one ${medium} world root \u2014 ${ids.map((id) => `"${id}"`).join(", ")} all occupy the ${medium} surface. Keep one and remove the rest, or move a root to a different medium (three / canvas / dom); only one root per medium is ever mounted, so a second one's content would never appear.`
+        message: `Project manifest: a project has at most one ${medium} world root \u2014 ${ids.map((id) => `"${id}"`).join(", ")} all occupy the ${medium} surface. Keep one and remove the rest, or move a root to a different medium (stage / canvas / dom); only one root per medium is ever mounted, so a second one's content would never appear.`
       });
     }
   }).describe(
-    "The project's explicit adapter-root composition \u2014 ZERO OR MORE roots, and no implicit root: a project with no roots mounts nothing (a library of models, a folder of documents) and the editor derives its chrome from what IS declared. Root ids are unique, and a project declares at most ONE world root per medium \u2014 one `three`, one `dom`, one canvas-surface root (first-party canvas, canvas ingest and canvas module are the same medium)."
+    "The project's explicit adapter-root composition \u2014 ZERO OR MORE roots, and no implicit root: a project with no roots mounts nothing (a library of models, a folder of documents) and the editor derives its chrome from what IS declared. Root ids are unique, and a project declares at most ONE world root per medium \u2014 one `stage`, one `dom`, one canvas-surface root (first-party canvas, canvas ingest and canvas module are the same medium)."
   ),
   authoring: external_exports.object({
     hierarchy: external_exports.object({
@@ -13960,62 +13920,14 @@ var GameManifestSchema = external_exports.object({
       ).optional().describe("Optional editor-only hierarchy groups")
     }).strict().optional().describe("Editor projection for native adapter roots")
   }).strict().optional().describe("Editor-only authoring metadata; never runtime ownership"),
-  configurations: external_exports.array(ConfigurationEnvelopeSchema).optional().describe(
-    "The project's run configurations \u2014 its ENTRYPOINTS beyond the host mount (`play`): each an id and a registered kind (`process`, `compound`, and whatever a capability registers) with that kind's own fields. The editor's transport and a harness start the same declaration."
-  ),
   resolution: external_exports.object({
     width: external_exports.number().describe("Canvas width in pixels"),
     height: external_exports.number().describe("Canvas height in pixels")
   }).strict().optional().describe("Canvas resolution"),
-  rendering: external_exports.object({
-    antialias: external_exports.boolean().describe(
-      "Whether every three root is built with a multisampled drawing buffer. This is the ONE render property a world cannot declare for itself (adapter/renderer-config.ts): a WebGL context fixes its sample count at CREATION from this boolean, long before a world mounts, so it belongs to the PROJECT. The runtime reader is mount-manifest.ts, which threads it into createHostRenderer for each three root. WebGL exposes no sample COUNT \u2014 the implementation picks one (4x on every desktop browser measured), so a source engine that authored 8x/16x gets multisampling but not its exact count."
-    )
-  }).strict().optional().describe(
-    "Construction-time renderer properties, which no world can declare after the fact. Everything a world CAN declare (tone mapping, output colour space, clear colour, shadow filter) lives on the world's own renderer config instead."
-  ),
-  debug: external_exports.object({
-    allowInProduction: external_exports.boolean().describe(
-      "Allow the ?volter-debug=1 introspection bridge and debug-command invocation in production builds. Default false: the bridge only installs in dev builds. The runtime reader is the debug-bridge installer (D18)."
-    )
-  }).strict().optional().describe(
-    "Debug-bridge production gating (D18) \u2014 governs whether ?volter-debug=1 installs window.__volter outside dev builds."
-  ),
-  determinism: external_exports.object({
-    seededRandom: external_exports.boolean().describe(
-      "Declares that ALL gameplay RNG in this project flows through ctx.random (the named-stream seeded PRNG) rather than raw Math.random/Date.now/performance.now. Three runtime enforcers key off this flag: the boot-time seeding reader (mount-manifest.ts seeds ctx.random from defaultSeed/?volter-seed=/explicit config, in that precedence, only when true), the gameplay-rng-ban burn-down scan (test/gameplay-rng-ban.test.ts \u2014 lints this project's src/ for raw RNG/wall-clock calls), and the dev-mode Math.random phase trap (runtime/gameplay-rng-trap.ts \u2014 warns once per call site during a gameplay frame, never throws). Default false: an undeclared project gets no determinism contract at all (that IS the opt-out \u2014 no dead field)."
-    ),
-    defaultSeed: external_exports.number().int().optional().describe(
-      "The seed ctx.random boots from when seededRandom is true, unless overridden by ?volter-seed=<int> (the query param always wins over this manifest default) or an even higher-precedence explicit config value a host passes directly. Optional \u2014 omit to fall back to the runtime's own fixed default seed."
-    )
-  }).strict().optional().describe(
-    "Seeded-RNG determinism contract (D15) \u2014 governs whether ctx.random is boot-seeded from a reproducible seed and whether the gameplay-rng-ban scan / dev-mode Math.random phase trap are active for this project."
-  ),
-  budget: external_exports.object({
-    frameCpuMsP95: external_exports.number().positive().optional().describe(
-      "Maximum allowed p95 of per-frame CPU time (ms) across the measured frames of a `volter perf` seeded headless run. CPU-side only: headless runs rasterize under SwiftShader, so this is main-thread frame cost, NOT real GPU frame time. Machine-dependent \u2014 prefer the baseline-diff tolerance band for regression gating and use this as a coarse absolute ceiling."
-    ),
-    physicsMsP95: external_exports.number().positive().optional().describe(
-      "Maximum allowed p95 of the profiler's `physics` phase time (ms) per fixed-step frame in a `volter perf` run. Same CPU-timing caveats as frameCpuMsP95."
-    ),
-    maxEntities: external_exports.number().int().nonnegative().optional().describe(
-      "Maximum allowed entity-tagged scene-graph nodes (nodes carrying userData.entityId) summed across the game's three/canvas worlds at the end of a `volter perf` run. Exact and deterministic under a seed \u2014 no tolerance band."
-    ),
-    maxDrawCalls: external_exports.number().int().positive().optional().describe(
-      "Maximum allowed renderer draw calls in any measured frame of a `volter perf` run (the profiler's per-frame render.drawCalls, from renderer.info). Exact and deterministic under a seed."
-    ),
-    maxTriangles: external_exports.number().int().positive().optional().describe(
-      "Maximum allowed rendered triangles in any measured frame of a `volter perf` run (the profiler's per-frame render.triangles, from renderer.info). Exact and deterministic under a seed."
-    )
-  }).strict().refine((budget) => Object.values(budget).some((value) => value !== void 0), {
-    message: "Game manifest: `budget` must set at least one metric (frameCpuMsP95, physicsMsP95, maxEntities, maxDrawCalls, maxTriangles) \u2014 an empty budget block gates nothing (the no-dead-fields policy)."
-  }).optional().describe(
-    "Performance budget (W3d, F11 perf regression gates) asserted by `volter perf --assert-budget`: a seeded, fixed-step headless run samples the engine profiler and fails (nonzero exit) when any metric here is exceeded. Only headlessly-measurable metrics are budgetable; real GPU frame time is not (SwiftShader)."
-  ),
   learn: LearnMetadataSchema.optional().describe(
-    "Optional learner-facing metadata (FT-5) \u2014 set on shipped example projects so the gallery/wizard/Learn-catalog registries can be generated from the manifest itself"
+    "Optional learner-facing metadata for example projects."
   )
-}).strict().describe("Game manifest (volter.project.json) \u2014 the complete v2 project configuration");
+}).strict().describe("Project manifest (volter.project.json) \u2014 the complete v2 project configuration");
 
 // ../project/src/manifest/filename.ts
 var MANIFEST_FILENAME = "volter.project.json";
@@ -14023,14 +13935,16 @@ var MANIFEST_FILENAME = "volter.project.json";
 // package.json
 var package_default = {
   name: "@volter/cyclotron",
+  publisher: "volter",
   author: "Volter AI, Inc.",
-  version: "0.5.211",
+  version: "0.5.213",
   publishConfig: {
     access: "public"
   },
   type: "module",
   engines: {
-    node: ">=24"
+    node: ">=26.8.1",
+    vscode: "*"
   },
   license: "AGPL-3.0-only AND GPL-3.0-or-later AND MIT",
   description: "A free, open-source game editor by videogame.ai using Blender 5.2 compiled to WebAssembly, Code-OSS, three.js, TypeScript and React.",
@@ -14065,80 +13979,180 @@ var package_default = {
     "BUNDLED_NOTICES"
   ],
   scripts: {
-    build: "vite build --config vite.config.ts",
+    build: "npm run build --prefix ../play && vite build --config vite.config.ts",
     "build:node": "node scripts/build-node.mjs",
     typecheck: "tsc -p tsconfig.node.json",
-    test: "npm run build:node && node --test test/first-run.test.mjs"
+    test: "npm run build:node && node --test test/first-run.test.mjs test/cli-args.test.mjs test/play-lost-answer.test.mjs"
   },
-  volter: {
-    product: {
-      entry: "./src/index.ts",
-      displayName: "Volter Cyclotron",
-      install: "npx @volter/cyclotron create my-game",
-      colorTheme: "dark",
-      upgrade: true,
-      adapterRequired: true,
-      workbench: {
-        "darwin-arm64": {
-          release: "cyclotron-4782d9a281ef-ec1e0e845c3a-darwin-arm64",
-          tarballSha256: "2a57c0cbc8baa64114d727fe9be00e849f5b8257a8416b50189017f247982c55"
-        },
-        "linux-x64": {
-          release: "cyclotron-4782d9a281ef-5b6840f8c154-linux-x64",
-          tarballSha256: "5fe9b6965453ad47a140f6ca939fbbc56a5b7ab9b2aec4b125d7d31f5adea5f9"
-        },
-        "win32-x64": {
-          release: "cyclotron-4782d9a281ef-5b6840f8c154-win32-x64",
-          tarballSha256: "c623156000dff25c6dbb4d88992b4a3d4d5a7aeb42a1882f1b9e20c8f496df04"
+  contributes: {
+    volter: {
+      looks: [
+        "./src/styles/maya.style.ts",
+        "./src/styles/substance.style.ts"
+      ],
+      product: {
+        entry: "./src/index.ts",
+        composes: [
+          "@volter/editor-blender",
+          "@volter/editor-threejs",
+          "@volter/play",
+          "@volter/chat"
+        ],
+        displayName: "Volter Cyclotron",
+        install: "npx @volter/cyclotron create my-game",
+        colorTheme: "dark",
+        upgrade: true,
+        adapterRequired: true,
+        workbench: {
+          "darwin-arm64": {
+            release: "cyclotron-624490512f0c-0ba7394f05b2-darwin-arm64",
+            tarballSha256: "4b752c3abd5595e2e4f7ae4d750b78d2f3c1a0da98140a8ee04c89893689a836"
+          },
+          "linux-x64": {
+            release: "cyclotron-624490512f0c-0ba7394f05b2-linux-x64",
+            tarballSha256: "6028c6d71df09bbb67ee90b936fc80fdc429d5ef0b1c78db07a6c39d9a4b2e1c"
+          },
+          "win32-x64": {
+            release: "cyclotron-624490512f0c-0ba7394f05b2-win32-x64",
+            tarballSha256: "57e8fa6dbc439de5fba7da35fa17c710644d465842bd967c8ba7f1e73fcbee2f"
+          }
         }
       }
     }
   },
   dependencies: {
-    "@volter/editor-core": "0.5.211",
-    "@volter/editor-blender": "0.1.150",
-    "@volter/editor-threejs": "0.5.211",
-    "@volter/blender-engine": "0.1.148",
-    "@volter/project": "0.5.211",
-    "@volter/sdk": "0.5.211",
-    "@volter/live": "0.5.211",
+    "@volter/editor-core": "0.5.213",
+    "@volter/editor-blender": "0.1.152",
+    "@volter/editor-threejs": "0.5.213",
+    "@volter/chat": "0.5.213",
+    "@volter/blender-engine": "0.1.150",
+    "@volter/project": "0.5.213",
+    "@volter/sdk": "0.5.213",
+    "@volter/live": "0.5.213",
+    "@volter/play": "0.5.213",
+    three: "^0.186.1",
     "@modelcontextprotocol/sdk": "1.32.1",
     typescript: "5.9.3",
     undici: "7.29.1"
   },
+  devDependencies: {
+    esbuild: "0.25.12"
+  },
   bin: {
     cyclotron: "./dist-node/cli.js"
   }
 };
 
-// node/create.ts
+// node/identity.ts
+var COMMAND = Object.keys(package_default.bin)[0];
+var DISPLAY_NAME = package_default.contributes.volter.product.displayName;
+
+// node/std.ts
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { workbenchProductId } from "@volter/live/product-locator";
 var productRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+function checkoutRoot() {
+  for (let dir = productRoot; dirname(dir) !== dir; dir = dirname(dir))
+    if (existsSync(join(dir, "packages", workbenchProductId(package_default.name), "package.json"))) return dir;
+  return null;
+}
+function pinnedStd(verb) {
+  const root = checkoutRoot();
+  if (root === null)
+    throw new Error(`${verb} makes a volter-ai/std game with the std a Cyclotron checkout pins (external/std); this Cyclotron is installed from npm and carries no std yet. Run ${verb} from a checkout of volter-ai/editor.`);
+  const std = join(root, "external", "std");
+  const devTools = join(std, "packages", "std-dev");
+  if (!existsSync(join(devTools, "package.json")))
+    throw new Error(`${verb}: the pinned std is not checked out at ${std}: run \`git submodule update --init external/std\` in ${root}.`);
+  if (!existsSync(join(devTools, "dist", "cli.js")) || !existsSync(join(devTools, "template", "std.json")))
+    throw new Error(`${verb}: the pinned std at ${std} is not built: run \`pnpm install\` and \`pnpm build\` there (Node 24 and pnpm 12.15 or newer).`);
+  return join(devTools, "bin", "std.js");
+}
+function run(program, args, cwd, what) {
+  return new Promise((done, fail) => {
+    const windows = process.platform === "win32" && program !== process.execPath;
+    const child = windows ? spawn([program, ...args].map((arg) => JSON.stringify(arg)).join(" "), { cwd, stdio: "inherit", windowsHide: true, shell: true }) : spawn(program, args, { cwd, stdio: "inherit", windowsHide: true });
+    child.once("error", (error48) => fail(new Error(`${what} could not start: ${error48.message}`)));
+    child.once("exit", (code) => code === 0 ? done() : fail(new Error(`${what} ended with code ${String(code)}.`)));
+  });
+}
+function stdNew(std, folder, name) {
+  return run(process.execPath, [std, "new", folder, "--name", name], dirname(folder), "std new");
+}
+function pnpmInstall(project) {
+  console.log("Installing the game's dependencies with pnpm\u2026");
+  return run("pnpm", ["install", "--config.confirmModulesPurge=false"], project, "pnpm install");
+}
+function checkoutLinks(names) {
+  const root = checkoutRoot();
+  if (root === null) throw new Error("checkoutLinks: Cyclotron is not running from a checkout.");
+  const folders = /* @__PURE__ */ new Map();
+  for (const folder of readdirSync(join(root, "packages"))) {
+    const manifest = join(root, "packages", folder, "package.json");
+    if (!existsSync(manifest)) continue;
+    const { name } = JSON.parse(readFileSync(manifest, "utf8"));
+    if (typeof name === "string") folders.set(name, join(root, "packages", folder));
+  }
+  return Object.fromEntries(names.map((name) => {
+    const folder = folders.get(name);
+    if (folder === void 0) throw new Error(`The checkout at ${root} has no package ${name}.`);
+    return [name, `link:${folder.split("\\").join("/")}`];
+  }));
+}
+
+// node/create.ts
+var productRoot2 = resolve2(dirname2(fileURLToPath2(import.meta.url)), "..");
 var UPGRADING = {
   packageName: package_default.name,
-  command: Object.keys(package_default.bin)[0],
-  dir: productRoot,
-  replaces: [{
-    packageName: "@volter/model-editor",
-    command: "volter-model-editor",
-    names: [["Volter Model Editor", "Volter Cyclotron"], ["Model Editor", "Cyclotron"]]
-  }]
-};
-var PLAY_SCAFFOLD = {
-  uiRoot: { id: "ui", adapter: "dom", entry: "src/ui/game.tsx", zOrder: 1 },
+  command: COMMAND,
+  dir: productRoot2
+};
+var PLAY_PACKAGES = (kit) => ({
+  "@volter/play": kit,
+  "@volter/editor-ui": kit,
+  "@volter/editor-react": kit,
+  "@volter/editor-movie": kit
+});
+var EXAMPLES = {
+  "canyon-comet": {
+    name: "Canyon Comet",
+    description: "A three-lap kart race through a desert canyon: a std game, its race the room's, its HUD React, with win and lose bots.",
+    roots: [{ id: "ui", adapter: "dom", entry: "client/hud/race-hud.tsx", zOrder: 1 }],
+    resolution: { width: 1672, height: 941 },
+    // (i18next: the HUD's words are keys in locales/, read with t())
+    dependencies: { i18next: "~26.7.2" },
+    /** The goal the game's `play` scripts name in place of the starter's. */
+    goal: "win",
+    /** std's starter files the example has no use for: its main level, its walking characters and its chat. */
+    removes: ["levels/MainLevel.tsx", "client/characters.tsx", "client/chat.tsx"]
+  }
+};
+var isExample = (id) => Object.hasOwn(EXAMPLES, id);
+var FILM = {
+  graphicsRoot: { id: "graphics", adapter: "dom", entry: "src/graphics/title.tsx", zOrder: 1 },
   resolution: { width: 1280, height: 720 },
-  dependencies: { react: "~19.2.4", "react-dom": "~19.2.4", three: "^0.180.0" },
-  /** The kit packages Play and the DOM root need, at the kit version this product was released against. */
-  devDependencies: (kit) => ({ "@volter/play": kit, "@volter/editor-ui": kit, "@volter/editor-react": kit }),
-  /** The adapter line that lets the UI board discover `src/ui` stories. */
-  regionIncludes: "  regionIncludes: { ui: { include: ['src/ui/**/*.tsx'] } },\n"
-};
-var PLAYABLE = {
-  ...PLAY_SCAFFOLD,
-  resolution: { width: 1672, height: 941 },
-  defaultDocument: "model:src/models/canyon.blend",
-  /** The folder under `starter/` that is copied onto the new project. */
-  example: "playable"
-};
+  dependencies: { react: "~19.2.4", "react-dom": "~19.2.4" },
+  devDependencies: (kit) => ({ "@volter/editor-film": kit }),
+  regionIncludes: "  regionIncludes: { graphics: { include: ['src/graphics/**/*.tsx'] } },\n",
+  /** The film's documents beside its models (`@volter/editor-film`'s finder), the script open first. */
+  defaultDocument: "film:script.fountain",
+  finder: ", { finder: 'filmFiles', include: ['script.fountain', 'shots.json', 'cut.json'] }",
+  example: "film",
+  skills: "film-skills"
+};
+async function copyStarterTree(folder, to) {
+  const from = join2(productRoot2, "starter", folder);
+  for (const entry of await readdir(from, { recursive: true, withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    const source = join2(entry.parentPath, entry.name);
+    const target = join2(to, relative2(from, source));
+    await mkdir(dirname2(target), { recursive: true });
+    await copyFile(source, target, constants.COPYFILE_EXCL);
+  }
+}
 var PROJECT_TSCONFIG = JSON.stringify({
   compilerOptions: {
     target: "ES2022",
@@ -14154,26 +14168,36 @@ var PROJECT_TSCONFIG = JSON.stringify({
   include: ["src/**/*.ts", "src/**/*.tsx"]
 }, null, 2) + "\n";
 async function productVersions() {
-  const product = JSON.parse(await readFile(join(productRoot, "package.json"), "utf8"));
+  const product = JSON.parse(await readFile(join2(productRoot2, "package.json"), "utf8"));
   return { product, kit: product.dependencies["@volter/project"] };
 }
 var declaration = {
-  product: "@volter/cyclotron",
+  product: package_default.name,
   templates: [
     { id: "models", name: "Models", description: "Blender modeling with a starter cube." },
-    { id: "playable", name: "Playable", description: "Canyon Comet: a three-lap kart race with a model play script and React HUD." }
+    { id: "game", name: "Game", description: "A volter-ai/std game (three.js, React Three Fiber, Rapier and Colyseus), made by std new from the std this checkout pins." },
+    { id: "film", name: "Film", description: "A short film as files: story, script, shots, takes, boards, music, graphics and the cut, each checked by npm run check." }
   ],
+  examples: Object.entries(EXAMPLES).map(([id, example]) => ({ id, name: example.name, description: example.description })),
   async create(request) {
+    if (request.example !== void 0 && request.template !== void 0) throw new Error("create makes a project from a template or an example, not both.");
+    if (request.example !== void 0 && !isExample(request.example))
+      throw new Error(`Unknown Cyclotron example ${JSON.stringify(request.example)}: ${Object.keys(EXAMPLES).join(", ")}.`);
+    if (request.template === "game" || request.example !== void 0) {
+      const result2 = await writeGame(request);
+      await pnpmInstall(result2.targetDir);
+      return result2;
+    }
     const result = await writeProject(request);
     const checkout = checkoutNodeModules();
     if (checkout) {
-      symlinkSync(checkout, join(result.targetDir, "node_modules"), "junction");
+      symlinkSync(checkout, join2(result.targetDir, "node_modules"), "junction");
       return result;
     }
     console.log("Installing project dependencies\u2026");
     await new Promise((done, fail) => {
       const windows = process.platform === "win32";
-      const child = windows ? spawn("npm install", { windowsHide: true, cwd: result.targetDir, stdio: "inherit", shell: true }) : spawn("npm", ["install"], { windowsHide: true, cwd: result.targetDir, stdio: "inherit" });
+      const child = windows ? spawn2("npm install --no-audit --no-fund", { windowsHide: true, cwd: result.targetDir, stdio: "inherit", shell: true }) : spawn2("npm", ["install", "--no-audit", "--no-fund"], { windowsHide: true, cwd: result.targetDir, stdio: "inherit" });
       child.once("error", fail);
       child.once("exit", (code) => code === 0 ? done() : fail(new Error(`Dependency installation failed (${code}); project source remains at ${result.targetDir}.`)));
     });
@@ -14181,122 +14205,170 @@ var declaration = {
   }
 };
 function checkoutNodeModules() {
-  for (let dir = productRoot; dirname(dir) !== dir; dir = dirname(dir)) {
-    if (existsSync(join(dir, "packages", "cyclotron", "package.json"))) {
-      const nodeModules = join(dir, "node_modules");
-      return existsSync(join(nodeModules, "@volter", "project", "package.json")) ? nodeModules : null;
-    }
-  }
-  return null;
+  const root = checkoutRoot();
+  if (root === null) return null;
+  const nodeModules = join2(root, "node_modules");
+  return existsSync2(join2(nodeModules, "@volter", "project", "package.json")) ? nodeModules : null;
+}
+function cyclotronPackages(product, kit) {
+  return {
+    [package_default.name]: product.version,
+    "@volter/project": kit,
+    "@volter/editor-blender": product.dependencies["@volter/editor-blender"],
+    ...PLAY_PACKAGES(kit)
+  };
+}
+async function writeCyclotronFiles(target) {
+  const write = (path, content) => writeFile(join2(target, path), content, { flag: "wx" });
+  const mcpEntry = [
+    "const { dirname, resolve } = require('node:path');",
+    "const { pathToFileURL } = require('node:url');",
+    `const manifest = require.resolve('${package_default.name}/package.json');`,
+    `const cli = resolve(dirname(manifest), require(manifest).bin['${COMMAND}']);`,
+    "process.argv.splice(1, 0, cli);",
+    "import(pathToFileURL(cli).href);"
+  ].join(" ");
+  const blenderMcp = { command: "node", args: ["--input-type=commonjs", "--eval", mcpEntry, "--", "blender-mcp"] };
+  await write(".mcp.json", JSON.stringify({ mcpServers: { blender: blenderMcp } }, null, 2) + "\n");
+  await mkdir(join2(target, ".codex"));
+  await write(".codex/config.toml", [
+    "[mcp_servers.blender]",
+    `command = ${JSON.stringify(blenderMcp.command)}`,
+    `args = [${blenderMcp.args.map((arg) => JSON.stringify(arg)).join(", ")}]`,
+    ""
+  ].join("\n"));
+  for (const file2 of ["AGENTS.md", "CLAUDE.md"])
+    await copyFile(join2(productRoot2, "starter", file2), join2(target, file2), constants.COPYFILE_EXCL);
+}
+var GAME_LEVEL = "game";
+var CYCLOTRON_IGNORES = ["node_modules", ".volter/", "logs/"];
+async function writeGame({ name, targetDir, example: exampleId }) {
+  if (!name.trim()) throw new Error("A project name is required.");
+  const target = resolve2(targetDir);
+  const example = exampleId !== void 0 && isExample(exampleId) ? EXAMPLES[exampleId] : void 0;
+  const std = pinnedStd(example === void 0 ? "create --template game" : `create --example ${exampleId}`);
+  if (existsSync2(target)) throw Object.assign(new Error(`${target} already exists: create makes a new folder.`), { code: "EEXIST" });
+  await mkdir(dirname2(target), { recursive: true });
+  await stdNew(std, target, name);
+  const from = example === void 0 ? join2(productRoot2, "starter", GAME_LEVEL) : join2(productRoot2, "examples", exampleId);
+  for (const entry of await readdir(from, { recursive: true, withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    const source = join2(entry.parentPath, entry.name);
+    await mkdir(dirname2(join2(target, relative2(from, source))), { recursive: true });
+    await copyFile(source, join2(target, relative2(from, source)));
+  }
+  for (const path of example?.removes ?? []) await rm(join2(target, path));
+  const { product, kit } = await productVersions();
+  const manifest = ProjectManifestSchema.parse({
+    manifestVersion: 2,
+    name,
+    version: "0.1.0",
+    engine: { version: product.dependencies["@volter/editor-core"] },
+    roots: example?.roots ?? [],
+    ...example === void 0 ? {} : { resolution: example.resolution }
+  });
+  await writeFile(join2(target, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + "\n", { flag: "wx" });
+  await writeCyclotronFiles(target);
+  const ignored = (await readFile(join2(target, ".gitignore"), "utf8")).split(/\r?\n/);
+  const missing = CYCLOTRON_IGNORES.filter((line) => !ignored.includes(line));
+  if (missing.length > 0) await appendFile(join2(target, ".gitignore"), `# Cyclotron's own files.
+${missing.join("\n")}
+`);
+  const pkg = JSON.parse(await readFile(join2(target, "package.json"), "utf8"));
+  pkg.scripts = { ...pkg.scripts, edit: `${COMMAND} edit .`, [COMMAND]: COMMAND };
+  if (example !== void 0) {
+    for (const [script, line] of Object.entries(pkg.scripts)) pkg.scripts[script] = line.replace(/--goal \S+/, `--goal ${example.goal}`);
+    pkg.dependencies = { ...pkg.dependencies, ...example.dependencies };
+  }
+  pkg.devDependencies = { ...pkg.devDependencies, ...checkoutLinks(Object.keys(cyclotronPackages(product, kit))) };
+  await writeFile(join2(target, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  return { targetDir: target, manifest };
 }
 async function writeProject({ name, targetDir, template }) {
-  if (template !== void 0 && !["models", "playable"].includes(template)) throw new Error("Unknown Cyclotron template.");
-  const playable = template === "playable";
+  if (template !== void 0 && !["models", "film"].includes(template)) throw new Error(`Unknown Cyclotron template ${JSON.stringify(template)}: models, game or film.`);
+  const film = template === "film";
   if (!name.trim()) throw new Error("A project name is required.");
-  const target = resolve(targetDir);
+  const target = resolve2(targetDir);
   const { product, kit } = await productVersions();
-  const manifest = GameManifestSchema.parse({
+  const manifest = ProjectManifestSchema.parse({
     manifestVersion: 2,
     name,
     version: "0.1.0",
     engine: { version: product.dependencies["@volter/editor-core"] },
-    roots: playable ? [PLAYABLE.uiRoot] : [],
-    ...playable ? { resolution: PLAYABLE.resolution } : {}
+    roots: film ? [FILM.graphicsRoot] : [],
+    ...film ? { resolution: FILM.resolution } : {}
   });
-  await mkdir(dirname(target), { recursive: true });
+  await mkdir(dirname2(target), { recursive: true });
   await mkdir(target);
-  await mkdir(join(target, "src/models"), { recursive: true });
-  const write = (path, content) => writeFile(join(target, path), content, { flag: "wx" });
+  await mkdir(join2(target, "src/models"), { recursive: true });
+  const write = (path, content) => writeFile(join2(target, path), content, { flag: "wx" });
+  for (const root of ["prefabs", "scenes", "sounds", "images", "fonts", "effects", "data", "locales/context"]) {
+    await mkdir(join2(target, root), { recursive: true });
+    await write(`${root}/.gitkeep`, "");
+  }
+  await write("locales/en.json", "{}\n");
+  await write("locales/context/keys.json", "{}\n");
+  await copyFile(join2(productRoot2, "starter", "sounds", "mix.json"), join2(target, "sounds/mix.json"));
   await write(MANIFEST_FILENAME, JSON.stringify(manifest, null, 2) + "\n");
   await write("package.json", JSON.stringify({
     name: name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "") || "models",
     private: true,
     version: "0.1.0",
     type: "module",
-    scripts: { dev: "cyclotron edit .", cyclotron: "cyclotron" },
+    scripts: { dev: `${COMMAND} edit .`, [COMMAND]: COMMAND, ...film ? { check: "volter-film check" } : {} },
     // The two install scripts the editor's tree runs, reviewed: npm 11 lists unreviewed ones in a new user's first
     // install ("not yet covered by allowScripts") and a later npm blocks them. The entries are npm's own
     // name-only form (`npm approve-scripts --no-allow-scripts-pin`).
     allowScripts: { esbuild: true, "msgpackr-extract": true },
-    ...playable ? { dependencies: PLAYABLE.dependencies } : {},
+    ...film ? { dependencies: FILM.dependencies } : {},
     devDependencies: {
-      "@volter/cyclotron": product.version,
-      "@volter/project": kit,
-      "@volter/editor-blender": product.dependencies["@volter/editor-blender"],
-      ...playable ? PLAYABLE.devDependencies(kit) : {}
+      ...cyclotronPackages(product, kit),
+      ...film ? FILM.devDependencies(kit) : {}
     }
   }, null, 2) + "\n");
   await write("tsconfig.json", PROJECT_TSCONFIG);
-  await mkdir(join(target, "editor"));
+  await mkdir(join2(target, "editor"));
   await write("editor/volter.adapter.ts", `import { defineAdapter } from '@volter/project/adapter/adapter-module';
 import { ModelLayout } from '@volter/editor-blender/layouts';
-import { blenderStyle, blenderKeymap } from '@volter/editor-blender/looks';
+import { blenderKeymap } from '@volter/editor-blender/looks';
 
 export default defineAdapter({
-${playable ? PLAYABLE.regionIncludes : ""}  editor: { Layout: ModelLayout, style: blenderStyle, keymap: blenderKeymap, inspector: 'properties' },
-  documents: { default: '${playable ? PLAYABLE.defaultDocument : "model:src/models/cube.blend"}', find: [{ finder: 'modelsFromBlendFiles', include: ['src/models/**/*.blend'] }] },
+${film ? FILM.regionIncludes : ""}  editor: { Layout: ModelLayout, keymap: blenderKeymap, inspector: 'properties' },
+  documents: { default: '${film ? FILM.defaultDocument : "model:src/models/cube.blend"}', find: [{ finder: 'modelsFromBlendFiles', include: ['src/models/**/*.blend'] }${film ? FILM.finder : ""}] },
 });
 `);
-  const mcpEntry = [
-    "const { dirname, resolve } = require('node:path');",
-    "const { pathToFileURL } = require('node:url');",
-    "const manifest = require.resolve('@volter/cyclotron/package.json');",
-    "const cli = resolve(dirname(manifest), require(manifest).bin['cyclotron']);",
-    "process.argv.splice(1, 0, cli);",
-    "import(pathToFileURL(cli).href);"
-  ].join(" ");
-  const blenderMcp = { command: "node", args: ["--input-type=commonjs", "--eval", mcpEntry, "--", "blender-mcp"] };
-  await write(".mcp.json", JSON.stringify({ mcpServers: { blender: blenderMcp } }, null, 2) + "\n");
-  await mkdir(join(target, ".codex"));
-  await write(".codex/config.toml", [
-    "[mcp_servers.blender]",
-    `command = ${JSON.stringify(blenderMcp.command)}`,
-    `args = [${blenderMcp.args.map((arg) => JSON.stringify(arg)).join(", ")}]`,
-    ""
-  ].join("\n"));
-  await write(".gitignore", "node_modules\n.volter/\nlogs/\n");
-  for (const file2 of ["AGENTS.md", "CLAUDE.md"])
-    await copyFile(join(productRoot, "starter", file2), join(target, file2));
-  if (playable) {
-    const example = join(productRoot, "starter", PLAYABLE.example);
-    for (const entry of await readdir(example, { recursive: true, withFileTypes: true })) {
-      if (!entry.isFile()) continue;
-      const from = join(entry.parentPath, entry.name);
-      const to = join(target, relative(example, from));
-      await mkdir(dirname(to), { recursive: true });
-      await copyFile(from, to, constants.COPYFILE_EXCL);
-    }
-  } else {
-    for (const file2 of ["cube.blend", "cube.py"])
-      await copyFile(join(productRoot, "starter", file2), join(target, "src/models", file2));
+  await writeCyclotronFiles(target);
+  await write(".gitignore", `${CYCLOTRON_IGNORES.join("\n")}
+`);
+  for (const file2 of ["cube.blend", "cube.py"])
+    await copyFile(join2(productRoot2, "starter", file2), join2(target, "src/models", file2));
+  if (film) {
+    await copyStarterTree(FILM.example, target);
+    await copyStarterTree(FILM.skills, join2(target, ".claude", "skills"));
   }
   return { targetDir: target, manifest };
 }
-async function refreshStarterGuidance(projectDir, log = console.log) {
-  const target = join(projectDir, "AGENTS.md");
+async function refreshStarterGuidance(projectDir) {
+  const target = join2(projectDir, "AGENTS.md");
   let current;
   try {
     current = await readFile(target, "utf8");
   } catch {
     return;
   }
-  const starter = await readFile(join(productRoot, "starter", "AGENTS.md"), "utf8");
+  const starter = await readFile(join2(productRoot2, "starter", "AGENTS.md"), "utf8");
   const normal = (text) => text.replace(/\r\n/g, "\n");
   const firstLine = (text) => normal(text).split("\n", 1)[0] ?? "";
   if (normal(current) === normal(starter) || firstLine(current) !== firstLine(starter)) return;
-  await mkdir(join(projectDir, ".volter"), { recursive: true });
-  await writeFile(join(projectDir, ".volter", "AGENTS.previous.md"), current);
+  await mkdir(join2(projectDir, ".volter"), { recursive: true });
+  await writeFile(join2(projectDir, ".volter", "AGENTS.previous.md"), current);
   await writeFile(target, starter);
-  log("AGENTS.md updated to the installed editor guidance (the previous copy is .volter/AGENTS.previous.md).");
+  console.log("AGENTS.md updated to the installed editor guidance (the previous copy is .volter/AGENTS.previous.md).");
 }
 export {
-  PLAYABLE,
-  PLAY_SCAFFOLD,
-  PROJECT_TSCONFIG,
+  PLAY_PACKAGES,
   UPGRADING,
   declaration,
-  productRoot,
-  productVersions,
   refreshStarterGuidance,
   writeProject
 };