lecodes-cli 0.19.0 → 0.19.2

package/dist/index.js

@@ -389,7 +389,7 @@ design/comments/
   if (!existsSync2(file))
     writeFileSync3(file, DEFAULT_IGNORE_FILE);
 }, DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
-# (.lecodes/manifest.json). Regenerate with \`lecodes types\` / re-attach with \`lecodes link\`.
+# (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
 .lecodes/
 
 # Render / preview outputs and test failure frames
@@ -171654,10 +171654,7 @@ var init_detectEntry = __esm(() => {
 });
 
 // ../sdk/src/compile/shaderTargets.ts
-var externalSamplerReg, PLATFORM_BUILD, LOCAL_PLATFORM_BUILD, ALL_PLATFORM_BUILD, LOCAL_ONLY_PLATFORMS, TARGET_MATRIX_GENERATION = 1, matcPlatformsFor = (text) => {
-  externalSamplerReg.lastIndex = 0;
-  return externalSamplerReg.test(text) ? ["opengl", "metal", "webgl", "desktop"] : ["opengl", "metal", "desktop"];
-}, matcArgs = (platform, outPath, inPath) => {
+var externalSamplerReg, PLATFORM_BUILD, LOCAL_PLATFORM_BUILD, ALL_PLATFORM_BUILD, LOCAL_ONLY_PLATFORMS, TARGET_MATRIX_GENERATION = 1, MATC_PLATFORMS, matcArgs = (platform, outPath, inPath) => {
   const build = ALL_PLATFORM_BUILD[platform];
   return ["-p", build.profile, "--no-essl1", "-a", build.api, "-o", outPath, inPath];
 };
@@ -171666,7 +171663,6 @@ var init_shaderTargets = __esm(() => {
   PLATFORM_BUILD = {
     opengl: { profile: "mobile", api: "opengl", replaceExternal: false },
     metal: { profile: "mobile", api: "metal", replaceExternal: false },
-    webgl: { profile: "mobile", api: "opengl", replaceExternal: true },
     desktop: { profile: "desktop", api: "opengl", replaceExternal: true }
   };
   LOCAL_PLATFORM_BUILD = {
@@ -171674,6 +171670,7 @@ var init_shaderTargets = __esm(() => {
   };
   ALL_PLATFORM_BUILD = { ...PLATFORM_BUILD, ...LOCAL_PLATFORM_BUILD };
   LOCAL_ONLY_PLATFORMS = ["desktop-vulkan"];
+  MATC_PLATFORMS = ["opengl", "metal", "desktop"];
 });
 
 // ../sdk/src/compile/liteMaterial.ts
@@ -172189,8 +172186,6 @@ var compileProject = async (opts) => {
         const name = shaders[0].src.split(/[\\/]/).pop() ?? "";
         const [prefix, suffix = ".filamat"] = name.split("_opengl");
         files[e.path] = `export default ("id:" + _creatorUtils.fetchLocal(${JSON.stringify(prefix + "_")} + _creator.backend + ${JSON.stringify(suffix)}))`;
-      } else if (shaders.length > 2) {
-        files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.subBackend ?? _creator.backend}")}\``;
       } else if (shaders.length > 0) {
         files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.backend}")}\``;
       } else {
@@ -173137,7 +173132,6 @@ __export(exports_compile, {
   parseSfnt: () => parseSfnt,
   parseJsonish: () => parseJsonish,
   offsetSourceMap: () => offsetSourceMap,
-  matcPlatformsFor: () => matcPlatformsFor,
   matcArgs: () => matcArgs,
   loadSceneHarness: () => loadSceneHarness,
   isServerPath: () => isServerPath,
@@ -173168,6 +173162,7 @@ __export(exports_compile, {
   SCENE_HARNESS_DIR: () => SCENE_HARNESS_DIR,
   SCENE_ENTRY_PATH: () => SCENE_ENTRY_PATH,
   PLATFORM_BUILD: () => PLATFORM_BUILD,
+  MATC_PLATFORMS: () => MATC_PLATFORMS,
   LOCAL_PLATFORM_BUILD: () => LOCAL_PLATFORM_BUILD,
   LOCAL_ONLY_PLATFORMS: () => LOCAL_ONLY_PLATFORMS,
   ICON_ID: () => ICON_ID,
@@ -173198,7 +173193,13 @@ var init_compile = __esm(() => {
 import { existsSync as existsSync7 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname5, join as join9 } from "node:path";
-var vendoredInject, resolveChiselBin2 = () => {
+var resolveSdkInject = () => {
+  try {
+    return createRequire3(import.meta.url).resolve("lecodes-sdk/inject");
+  } catch {}
+  const vendored = join9(distRoot, "runtime", "sdk", "inject.ts");
+  return existsSync7(vendored) ? vendored : null;
+}, sdkInject, resolveChiselBin2 = () => {
   if (process.env.LECODES_CHISEL_BIN)
     return process.env.LECODES_CHISEL_BIN;
   try {
@@ -173230,9 +173231,9 @@ var vendoredInject, resolveChiselBin2 = () => {
 var init_projectCompile = __esm(() => {
   init_distRoot();
   init_compile();
-  vendoredInject = join9(distRoot, "runtime", "sdk", "inject.ts");
-  if (existsSync7(vendoredInject))
-    process.env.LECODES_SDK_INJECT = vendoredInject;
+  sdkInject = resolveSdkInject();
+  if (sdkInject)
+    process.env.LECODES_SDK_INJECT = sdkInject;
   chiselBin = resolveChiselBin2();
   if (chiselBin)
     process.env.LECODES_CHISEL_BIN = chiselBin;
@@ -214125,6 +214126,7 @@ var init_esm30 = __esm(() => {
 // src/types.ts
 import { dirname as dirname13, join as join22, relative as relative3, sep } from "node:path";
 import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync10, readFileSync as readFileSync18, rmSync as rmSync8, statSync as statSync8, writeFileSync as writeFileSync17 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
 var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   if (!existsSync21(dir))
     return [];
@@ -214174,8 +214176,16 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
     bundle[path2] = readFileSync18(join22(typesDir, path2), "utf8");
   return bundle;
 }, materializeTypes = async (root, apiUrl) => writeTypeBundle(root, await getTypes(apiUrl)), readLocalTypeBundle = () => {
+  const fromPackage = (() => {
+    try {
+      return createRequire4(import.meta.url).resolve("lecodes-sdk/types.json");
+    } catch {
+      return null;
+    }
+  })();
   const candidates = [
     join22(distRoot, "runtime", "sdk-types.json"),
+    ...fromPackage ? [fromPackage] : [],
     join22(distRoot, "..", "sdk", "dist", "types.json")
   ];
   for (const path2 of candidates) {
@@ -214358,7 +214368,7 @@ var init_browserAuth = __esm(() => {
   init_util();
 });
 
-// ../lecodes-design/src/core/concept.ts
+// ../../../lecodes-tools/packages/lecodes-design/src/core/concept.ts
 var SPEC_TEMPLATE = `# Concept
 
 The narrative half of this design. \`meta.json\` + the canvas hold the *visual/flow* half (screens,
@@ -214394,7 +214404,7 @@ Behaviour that isn't visible in a single screen — validation, permissions, not
 cases — and the decisions you've made and why, so they aren't re-litigated later.
 `;
 
-// ../lecodes-design/src/templates.ts
+// ../../../lecodes-tools/packages/lecodes-design/src/templates.ts
 var SPEC_MD, META_JSON = `{
   "screens": {
     "home": { "pos": [0, 0], "desc": "Example screen — replace me", "role": "list" }
@@ -216529,26 +216539,26 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.19.0",
+  version: "0.19.2",
   dependencies: {
     "@letary/chisel": "^0.10.0",
-    jimp: "^1.6.1"
+    jimp: "^1.6.1",
+    "lecodes-sdk": "workspace:*"
   },
   devDependencies: {
-    "lecodes-design": "workspace:*",
+    "lecodes-design": "link:lecodes-design",
     "lecodes-renderer": "workspace:*",
     "qrcode-terminal": "^0.12.0",
-    "lecodes-3d-editor": "workspace:*",
+    "lecodes-3d-editor": "link:lecodes-3d-editor",
     "lecodes-assets": "workspace:*",
-    "creator-nav": "workspace:*",
-    sdk: "workspace:*",
-    "viewer-lite": "workspace:*"
+    "lecodes-creator-nav": "workspace:*",
+    "lecodes-viewer-lite": "workspace:*"
   },
   peerDependencies: {
-    "lecodes-design": "^0.8.1",
-    "lecodes-renderer": "^0.8.9",
-    "lecodes-3d-editor": "^0.6.0",
-    "lecodes-assets": "^0.1.0"
+    "lecodes-design": "^0.9.0",
+    "lecodes-renderer": "^0.19.2",
+    "lecodes-3d-editor": "^0.7.0",
+    "lecodes-assets": "^0.2.1"
   },
   bin: {
     lecodes: "dist/index.js"
@@ -216559,6 +216569,7 @@ var package_default = {
   },
   files: [
     "dist",
+    "src",
     "runtime",
     "README.md"
   ],
@@ -216725,7 +216736,7 @@ init_fonts();
 init_compile();
 import { execFile } from "node:child_process";
 import { createHash as createHash4, randomBytes } from "node:crypto";
-import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename as basename3, join as join13 } from "node:path";
 
@@ -216918,17 +216929,14 @@ var matcIdentity = (exe) => {
   return `${stat.size}:${Math.trunc(stat.mtimeMs)}`;
 };
 var shaderHash = (text, matcId) => createHash4("sha256").update(`${TARGET_MATRIX_GENERATION}\x00${matcId}\x00${text}`).digest("hex").slice(0, 16);
-var artifactFamily = (text) => {
-  const matcPlatforms = [...matcPlatformsFor(text), ...LOCAL_ONLY_PLATFORMS];
-  return [...matcPlatforms, ...matcPlatforms.includes("webgl") ? [] : ["webgl"], "webgl-lite"];
-};
+var artifactFamily = () => [...MATC_PLATFORMS, ...LOCAL_ONLY_PLATFORMS, "webgl-lite"];
 var shaderIsCompiled = (root, text, matcId) => {
   const hash = shaderHash(text, matcId);
-  return artifactFamily(text).every((p) => existsSync11(join13(shadersCacheDir(root), `${hash}_${p}.filamat`)));
+  return artifactFamily().every((p) => existsSync11(join13(shadersCacheDir(root), `${hash}_${p}.filamat`)));
 };
 var shaderCompiledPlatforms = (root, text, matcId) => {
   const hash = shaderHash(text, matcId);
-  return artifactFamily(text).filter((p) => existsSync11(join13(shadersCacheDir(root), `${hash}_${p}.filamat`)));
+  return artifactFamily().filter((p) => existsSync11(join13(shadersCacheDir(root), `${hash}_${p}.filamat`)));
 };
 var localShaderArtifact = (root, text, platform) => {
   const matcExe = resolveMatcExeCached();
@@ -216973,15 +216981,12 @@ var applyLocalShaders = async (entries, opts) => {
   for (const entry of shaderEntries) {
     const text = readFileSync11(entry.absPath, "utf8");
     const hash = shaderHash(text, matcId);
-    const family = artifactFamily(text);
+    const family = artifactFamily();
     const artifact = (platform) => `${hash}_${platform}.filamat`;
     const has = (platform) => existsSync11(join13(cacheDir, artifact(platform)));
     const wanted = opts.platforms ? family.filter((p) => opts.platforms.includes(p)) : family;
-    if (wanted.includes("webgl") && !matcPlatformsFor(text).includes("webgl") && !wanted.includes("opengl")) {
-      wanted.push("opengl");
-    }
     const missing = wanted.filter((p) => !has(p));
-    const matcMissing = missing.filter((p) => p !== "webgl-lite" && !(p === "webgl" && !matcPlatformsFor(text).includes("webgl")));
+    const matcMissing = missing.filter((p) => p !== "webgl-lite");
     if (matcMissing.length > 0) {
       const tempName = `lecodes-matc-${randomBytes(6).toString("hex")}.mat`;
       const tempFile = join13(tmpdir(), tempName);
@@ -217001,9 +217006,6 @@ ${cleanMatcOutput(stderr, tempName, basename3(entry.path))}`);
         rmSync2(tempFile, { force: true });
       }
     }
-    if (missing.includes("webgl") && !matcPlatformsFor(text).includes("webgl")) {
-      copyFileSync(join13(cacheDir, artifact("opengl")), join13(cacheDir, artifact("webgl")));
-    }
     if (missing.includes("webgl-lite")) {
       writeFileSync7(join13(cacheDir, artifact("webgl-lite")), JSON.stringify(buildLiteMaterialArtifact(text)));
     }
@@ -217018,7 +217020,7 @@ ${cleanMatcOutput(stderr, tempName, basename3(entry.path))}`);
         artifacts.push({ name: artifact(platform), absPath: join13(cacheDir, artifact(platform)) });
       }
     } else {
-      const order = ["opengl", "metal", "desktop", "webgl", "webgl-lite"];
+      const order = ["opengl", "metal", "desktop", "webgl-lite"];
       entry.shaders = order.map((platform) => ({ platform, src: `${opts.srcPrefix}/${artifact(platform)}` }));
     }
   }
@@ -218630,6 +218632,12 @@ Sync links the smallest SDK artifact covering the engines the compiled bundle ac
 engine, sync switches automatically on the next run; set \`android.variant\` in \`../app.json\`
 to force one (needs lecodes-android-sdk >= 1.3.0; older releases ship only the full AAR).
 
+Physics, navigation meshes and multiplayer ship in \`lecodes-sdk\` (full) ONLY —
+\`lecodes-sdk-3d\` is 3D rendering without the game stack. Auto-selection reads which RENDERING
+engines the bundle uses and cannot see those, so a project using \`Physics\`,
+\`CharacterController\`, \`NavMesh\` or networking must set \`android.variant: "full"\` in
+\`../app.json\` — otherwise those aspects silently do nothing on device.
+
 ## App-local native code
 
 Drop Kotlin files into \`app/src/main/java/\` and register them in \`MainActivity\` after the
@@ -219753,7 +219761,7 @@ import { basename as basename7, dirname as dirname11, join as join20, resolve as
 
 // src/desktopRenderer.ts
 import { execFileSync as execFileSync3, spawn as spawn2, spawnSync as spawnSync4 } from "node:child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync2, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { copyFileSync, existsSync as existsSync17, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync2, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "node:os";
 import { join as join18, resolve as resolve5 } from "node:path";
 init_util();
@@ -220083,7 +220091,7 @@ var stageBundle = (js, resources) => {
   writeFileSync13(join18(runDir, "app.js"), js);
   for (const r2 of resources) {
     if (r2.absPath && existsSync17(r2.absPath) && statSync4(r2.absPath).isFile()) {
-      copyFileSync2(r2.absPath, join18(runDir, r2.name));
+      copyFileSync(r2.absPath, join18(runDir, r2.name));
     }
   }
   return runDir;
@@ -220126,7 +220134,16 @@ var runDesktopApp = async (js, resources, opts = {}) => {
       });
     });
   } finally {
-    rmSync4(runDir, { recursive: true, force: true });
+    for (let attempt = 0;; attempt++) {
+      try {
+        rmSync4(runDir, { recursive: true, force: true });
+        break;
+      } catch {
+        if (attempt >= 5)
+          break;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+      }
+    }
   }
 };
 var runDesktopDev = async (url, opts = {}) => {
@@ -220204,7 +220221,16 @@ ${tail}` : "";
       });
     });
   } finally {
-    rmSync4(runDir, { recursive: true, force: true });
+    for (let attempt = 0;; attempt++) {
+      try {
+        rmSync4(runDir, { recursive: true, force: true });
+        break;
+      } catch {
+        if (attempt >= 5)
+          break;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+      }
+    }
   }
 };
 
@@ -220214,7 +220240,7 @@ init_util();
 // src/commands/appDesktopMac.ts
 init_util();
 import { execFileSync as execFileSync4, spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
-import { cpSync as cpSync2, existsSync as existsSync18, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync5, writeFileSync as writeFileSync14 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync18, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync5, symlinkSync, writeFileSync as writeFileSync14 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { basename as basename6, join as join19, resolve as resolve6 } from "node:path";
 var mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
@@ -220336,11 +220362,12 @@ var signApp = async (app, signing, hostApp, tmp) => {
     throw new CliError(`The signature doesn't verify:
 ${(verify.stdout + verify.stderr).trim()}`);
 };
-var notarizeApp = (app, profile, tmp) => {
-  const zip = join19(tmp, `${basename6(app, ".app")}.zip`);
-  execFileSync4("ditto", ["-c", "-k", "--keepParent", app, zip]);
-  note(`Notarizing with profile "${profile}" — this waits on Apple (usually 1–5 minutes)…`);
-  const r2 = spawnSync5("xcrun", ["notarytool", "submit", zip, "--keychain-profile", profile, "--wait"], { encoding: "utf8" });
+var notarize = (target, profile, tmp, what) => {
+  const submission = target.endsWith(".app") ? join19(tmp, `${basename6(target, ".app")}.zip`) : target;
+  if (submission !== target)
+    execFileSync4("ditto", ["-c", "-k", "--keepParent", target, submission]);
+  note(`Notarizing the ${what} with profile "${profile}" — this waits on Apple (usually 1–5 minutes)…`);
+  const r2 = spawnSync5("xcrun", ["notarytool", "submit", submission, "--keychain-profile", profile, "--wait"], { encoding: "utf8" });
   const out = (r2.stdout + `
 ` + r2.stderr).trim();
   const id = /id: ([0-9a-f-]{36})/.exec(out)?.[1];
@@ -220349,11 +220376,44 @@ var notarizeApp = (app, profile, tmp) => {
 ${out}
 ` + (id ? `  Details: xcrun notarytool log ${id} --keychain-profile ${profile}` : ""));
   }
-  const staple = spawnSync5("xcrun", ["stapler", "staple", app], { encoding: "utf8" });
+  const staple = spawnSync5("xcrun", ["stapler", "staple", target], { encoding: "utf8" });
   if (staple.status !== 0)
     throw new CliError(`Stapling failed:
 ${(staple.stdout + staple.stderr).trim()}`);
-  success("Notarized + stapled.");
+  success(`Notarized + stapled (${what}).`);
+};
+var buildDmg = async (app, out, appName, signing, tmp) => {
+  const dmg = join19(out, `${appName}.dmg`);
+  rmSync5(dmg, { force: true });
+  const stage = join19(tmp, "dmg");
+  rmSync5(stage, { recursive: true, force: true });
+  mkdirSync12(stage, { recursive: true });
+  note("Building the disk image…");
+  execFileSync4("cp", ["-R", app, join19(stage, basename6(app))]);
+  symlinkSync("/Applications", join19(stage, "Applications"));
+  const r2 = spawnSync5("hdiutil", [
+    "create",
+    "-volname",
+    appName,
+    "-srcfolder",
+    stage,
+    "-fs",
+    "HFS+",
+    "-format",
+    "UDZO",
+    "-ov",
+    dmg
+  ], { encoding: "utf8" });
+  rmSync5(stage, { recursive: true, force: true });
+  if (r2.status !== 0)
+    throw new CliError(`hdiutil failed:
+${(r2.stdout + r2.stderr).trim()}`);
+  if (signing.identity !== "-") {
+    await codesignRetrying(["--force", "--timestamp", "--sign", signing.identity, dmg]);
+    if (signing.notaryProfile)
+      notarize(dmg, signing.notaryProfile, tmp, "disk image");
+  }
+  success(`DMG: ${dmg} (${mb(statSync5(dmg).size)})`);
 };
 var gatekeeperVerdict = (app) => {
   const r2 = spawnSync5("spctl", ["-a", "-t", "exec", "-vv", app], { encoding: "utf8" });
@@ -220487,7 +220547,7 @@ var buildMacApp = async (input) => {
     }, developerIdInKeychain);
     await signApp(app, signing, hostApp, tmp);
     if (signing.notaryProfile) {
-      notarizeApp(app, signing.notaryProfile, tmp);
+      notarize(app, signing.notaryProfile, tmp, "app");
     } else if (signing.identity !== "-") {
       warn("Signed with Developer ID but NOT notarized — Gatekeeper refuses a downloaded copy on every other Mac.");
       warn("  Set desktop.macos.notarize.profile in app.json (a `xcrun notarytool store-credentials` profile) or pass --notarize <profile>.");
@@ -220499,6 +220559,8 @@ var buildMacApp = async (input) => {
     }
     writeFileSync14(join19(out, "README.txt"), readmeText(appName, !!signing.notaryProfile, signing.identity !== "-"));
     success(`App: ${app}  (${mb(dirSize(app))})`);
+    if (flagBool(args, "dmg"))
+      await buildDmg(app, out, appName, signing, tmp);
     if (flagBool(args, "probe"))
       await probeMacApp(app, out, args);
     if (flagBool(args, "zip")) {
@@ -220506,8 +220568,8 @@ var buildMacApp = async (input) => {
       rmSync5(zip, { force: true });
       execFileSync4("ditto", ["-c", "-k", "--keepParent", app, zip]);
       success(`Zip: ${zip} (${mb(statSync5(zip).size)})`);
-    } else {
-      note("Tip: --zip packs the .app for sending (ditto, structure-preserving).");
+    } else if (!flagBool(args, "dmg")) {
+      note("Tip: --zip packs the .app for sending; --dmg wraps it in a drag-to-Applications image.");
     }
   } finally {
     rmSync5(tmp, { recursive: true, force: true });
@@ -220608,6 +220670,8 @@ var buildDesktop = async (args) => {
   }
   if (mac)
     return buildMacApp({ root, config, name, slug, out, js, shipped, hostExe: exe, args });
+  if (flagBool(args, "dmg"))
+    warn("--dmg is a macOS format — ignored on this platform.");
   const version = process.env.LECODES_DESKTOP_EXE ? "local build" : selectedDesktopVersion();
   rmSync6(out, { recursive: true, force: true });
   mkdirSync13(out, { recursive: true });
@@ -221660,7 +221724,7 @@ channel for game state that has no UI.
 ## SDK documentation
 
 \`.lecodes/types/\` is the exact API surface (signatures only; generated and gitignored — run
-\`lecodes types\` if it's missing, never commit \`.lecodes/\`). For semantics and examples,
+\`lecodes update\` if it's missing, never commit \`.lecodes/\`). For semantics and examples,
 fetch the docs — they are served as raw markdown for AI tools:
 
 - https://le.codes/llms.txt — the docs map; fetch it first to find the right page
@@ -222777,9 +222841,9 @@ lecodes app open             # open it in Xcode, build & run
 - \`CLAUDE.md\` — guidance for AI assistants (the headless feedback loop + testability conventions)
 - \`assets/\` — images/fonts the app references (created on demand)
 - \`tsconfig.json\` + \`.lecodes/types/\` — generated IDE types (rewritten by the CLI; don't edit).
-  They come from the SDK bundled in the CLI; \`lecodes types\` refreshes them from the platform.
+  They come from the SDK bundled in the CLI; \`lecodes update\` refreshes them from the platform.
 - \`.lecodes/\` is gitignored — per-checkout state (those types + \`manifest.json\`, this machine's
-  sync cursor once linked). After a fresh git clone: \`lecodes types\`, then
+  sync cursor once linked). After a fresh git clone: \`lecodes update\`, then
   \`lecodes link --project <uuid>\` to re-attach.
 - \`.lecodesignore\` — files a future \`lecodes push\` would skip
 
@@ -223093,8 +223157,8 @@ var link = async (args) => {
 
 // src/commands/lightmap.ts
 init_manifest();
-import { existsSync as existsSync28, mkdirSync as mkdirSync21, mkdtempSync as mkdtempSync4, rmSync as rmSync9, statSync as statSync10, unlinkSync, writeFileSync as writeFileSync22 } from "node:fs";
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync28, mkdirSync as mkdirSync21, mkdtempSync as mkdtempSync4, readFileSync as readFileSync25, renameSync as renameSync3, rmSync as rmSync9, statSync as statSync10, unlinkSync, writeFileSync as writeFileSync22 } from "node:fs";
+import { spawn as spawn6, spawnSync as spawnSync6 } from "node:child_process";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join30, relative as relative4, resolve as resolve13 } from "node:path";
 init_util();
@@ -223136,14 +223200,26 @@ var requireToktx = () => {
   }
   return toktx;
 };
-var encodeKtx2 = (toktx, png2, ktx2) => {
+var encodeKtx2 = (toktx, png2, ktx2) => new Promise((resolve14, reject) => {
   const args = ["--t2", "--encode", "uastc", "--uastc_quality", "2", "--zcmp", "18", "--genmipmap", "--assign_oetf", "srgb", ktx2, png2];
-  const p2 = spawnSync6(toktx, args, { encoding: "utf8" });
-  if (p2.status !== 0) {
-    throw new CliError(`toktx failed (${p2.status ?? p2.error?.message ?? "?"}) while encoding ${ktx2}:
-${(p2.stderr || p2.stdout || "").trim()}`);
-  }
-};
+  const p2 = spawn6(toktx, args, { stdio: ["ignore", "pipe", "pipe"] });
+  let out = "";
+  p2.stdout.on("data", (d) => {
+    out += String(d);
+  });
+  p2.stderr.on("data", (d) => {
+    out += String(d);
+  });
+  p2.on("error", (e2) => reject(new CliError(`toktx failed (${e2.message}) while encoding ${ktx2}`)));
+  p2.on("close", (status2) => {
+    if (status2 === 0)
+      resolve14();
+    else
+      reject(new CliError(`toktx failed (${status2 ?? "?"}) while encoding ${ktx2}:
+${out.trim()}`));
+  });
+});
+var pageFile = (stem, page, light, ext2 = ".ktx2") => `${stem}${light ? "-light" : ""}${page > 0 ? `_${page}` : ""}${ext2}`;
 var bake = async (args) => {
   let root;
   try {
@@ -223153,6 +223229,9 @@ var bake = async (args) => {
   }
   const toktx = requireToktx();
   const outDir = resolve13(root, flagStr(args, "out") ?? "assets/lightmap");
+  const stem = flagStr(args, "name") ?? "lightmap";
+  if (!/^[A-Za-z0-9_-]+$/.test(stem))
+    throw new CliError(`--name wants a plain file stem (letters, digits, - and _), got "${stem}".`);
   const entryFlag = flagStr(args, "entry");
   const entryFile = entryFlag ?? "main.ts";
   if (!existsSync28(resolve13(root, entryFile))) {
@@ -223162,11 +223241,19 @@ var bake = async (args) => {
     outDir: outDir.replace(/\\/g, "/"),
     size: num(args, "size", 4096, 256, 16384),
     texel: num(args, "texel", 0.02, 0.001, 2),
+    pages: num(args, "pages", 4, 1, 16),
     sunRays: num(args, "sun-rays", 32, 1, 1024),
     aoRays: num(args, "ao-rays", 64, 1, 4096),
     aoDistance: num(args, "ao-distance", 2, 0.01, 1000),
     bias: num(args, "bias", 0.02, 0.0001, 1),
     sunAngle: num(args, "sun-angle", 0.5, 0.01, 30),
+    lightRays: num(args, "light-rays", 16, 1, 256),
+    lightRadius: num(args, "light-radius", 0.1, 0.001, 5),
+    bounce: num(args, "bounce", 0, 0, 1),
+    bounceDistance: num(args, "bounce-distance", 8, 0.5, 100),
+    bounceRays: num(args, "bounce-rays", 1, 1, 32),
+    coplanarSkip: num(args, "coplanar-skip", 0.05, 0, 1),
+    denoise: num(args, "denoise", 2, 0, 4),
     volumeCell: flagBool(args, "no-volume") ? 0 : num(args, "cell", 0.5, 0.05, 20)
   };
   const frames = num(args, "frames", 900, 30, 1e5);
@@ -223180,7 +223267,7 @@ var bake = async (args) => {
 import ${JSON.stringify(importPath)}
 `;
   mkdirSync21(outDir, { recursive: true });
-  ensurePlaceholders(outDir);
+  ensurePlaceholders(outDir, stem);
   const desktopRenderer = resolveDesktopRenderer(root, args);
   const { js, resources } = await buildBundle(args, undefined, {
     localAssets: true,
@@ -223190,10 +223277,10 @@ import ${JSON.stringify(importPath)}
   });
   const scratch = mkdtempSync4(join30(tmpdir4(), "lecodes-lightmap-"));
   const outPng = join30(scratch, "frame.png");
-  note(`Baking ${cfg.size}² at ${(cfg.texel * 100).toFixed(1)} cm texels (${cfg.sunRays} sun + ${cfg.aoRays} AO rays)${cfg.volumeCell ? ` + a ${cfg.volumeCell} m light volume` : ""} → ${relative4(root, outDir) || "."}…`);
+  note(`Baking up to ${cfg.pages} × ${cfg.size}² at ${(cfg.texel * 100).toFixed(1)} cm texels (${cfg.sunRays} sun + ${cfg.aoRays} AO + ${cfg.lightRays} light rays)${cfg.volumeCell ? ` + a ${cfg.volumeCell} m light volume` : ""} → ${relative4(root, outDir) || "."}/${stem}.*…`);
   let output = "";
   try {
-    const timeoutMs = Number(flagStr(args, "timeout")) || 600000;
+    const timeoutMs = Number(flagStr(args, "timeout")) || 24 * 3600 * 1000;
     const res = await runDesktopRender(js, resources, {
       renderer: desktopRenderer,
       width,
@@ -223211,28 +223298,76 @@ import ${JSON.stringify(importPath)}
       throw e2;
     output = msg;
   } finally {
-    rmSync9(scratch, { recursive: true, force: true });
+    try {
+      rmSync9(scratch, { recursive: true, force: true });
+    } catch {}
   }
   const lines = output.split(/\r?\n/).filter((l2) => l2.startsWith("[lightmap]"));
   for (const l2 of lines) {
     const text = l2.slice("[lightmap]".length).trim();
     if (text === "done")
       continue;
-    logErr(text.startsWith("error") ? c.red(`✗ ${text}`) : c.dim(`  ${text}`));
+    logErr(text.startsWith("error") ? c.red(`✗ ${text}`) : text.startsWith("warning") ? c.yellow(`  ${text}`) : c.dim(`  ${text}`));
   }
   if (/\[lightmap\] done/.test(output)) {
-    const png2 = join30(outDir, "lightmap.png");
-    const ktx2 = join30(outDir, "lightmap.ktx2");
-    if (!existsSync28(png2))
-      throw new CliError(`The host reported a bake but ${png2} is missing.`);
+    const bakePath = join30(outDir, "lightmap.bake");
+    if (!existsSync28(bakePath))
+      throw new CliError(`The host reported a bake but ${bakePath} is missing.`);
+    const data = JSON.parse(readFileSync25(bakePath, "utf8"));
+    const pages = Math.max(1, data.pages ?? 1);
+    const hasLight = !!data.lightTextures?.length;
     const t0 = Date.now();
-    encodeKtx2(toktx, png2, ktx2);
-    const pngKb = Math.round(statSync10(png2).size / 1024), ktxKb = Math.round(statSync10(ktx2).size / 1024);
-    unlinkSync(png2);
-    logErr(c.dim(`  encoded lightmap.ktx2 (UASTC + mips, ${ktxKb} KB from a ${pngKb} KB raster) in ${((Date.now() - t0) / 1000).toFixed(1)} s`));
-    const hasVolume = cfg.volumeCell > 0 && existsSync28(join30(outDir, "lightmap.volume"));
-    logErr(c.green(`✓ baked → ${relative4(root, outDir) || "."}/lightmap.ktx2 + lightmap.bake${hasVolume ? " + lightmap.volume" : ""}`));
-    logErr(c.dim(`  apply it with Lightmap.load(scene, { data: asset('<rel>/${relative4(root, join30(outDir, "lightmap.bake")).replace(/\\/g, "/")}'), texture: asset('<rel>/${relative4(root, ktx2).replace(/\\/g, "/")}')${hasVolume ? `, volume: asset('<rel>/${relative4(root, join30(outDir, "lightmap.volume")).replace(/\\/g, "/")}')` : ""} })  — asset() paths are relative to the calling file`));
+    let pngKb = 0, ktxKb = 0;
+    const encodePage = async (page, light) => {
+      const png2 = join30(outDir, pageFile("lightmap", page, light, ".png"));
+      const ktx2 = join30(outDir, pageFile(stem, page, light));
+      if (!existsSync28(png2))
+        throw new CliError(`The host reported a bake but ${png2} is missing.`);
+      await encodeKtx2(toktx, png2, ktx2);
+      pngKb += statSync10(png2).size / 1024;
+      ktxKb += statSync10(ktx2).size / 1024;
+      unlinkSync(png2);
+    };
+    const encodes = [];
+    for (let p2 = 0;p2 < pages; p2++) {
+      encodes.push(encodePage(p2, false));
+      if (hasLight)
+        encodes.push(encodePage(p2, true));
+    }
+    await Promise.all(encodes);
+    for (let p2 = pages;p2 < 16; p2++) {
+      for (const light of [false, true]) {
+        const stale = join30(outDir, pageFile(stem, p2, light));
+        if (existsSync28(stale) && statSync10(stale).size !== PLACEHOLDER_KTX2.length)
+          writeFileSync22(stale, PLACEHOLDER_KTX2);
+      }
+    }
+    if (!hasLight) {
+      const light = join30(outDir, pageFile(stem, 0, true));
+      if (existsSync28(light) && statSync10(light).size !== PLACEHOLDER_KTX2.length)
+        writeFileSync22(light, PLACEHOLDER_KTX2);
+    }
+    data.texture = pageFile(stem, 0, false);
+    data.textures = Array.from({ length: pages }, (_, p2) => pageFile(stem, p2, false));
+    if (hasLight)
+      data.lightTextures = Array.from({ length: pages }, (_, p2) => pageFile(stem, p2, true));
+    if (data.volume)
+      data.volume.file = `${stem}.volume`;
+    writeFileSync22(join30(outDir, `${stem}.bake`), JSON.stringify(data, null, 1) + `
+`);
+    if (stem !== "lightmap")
+      unlinkSync(bakePath);
+    const volumeSrc = join30(outDir, "lightmap.volume");
+    const hasVolume = cfg.volumeCell > 0 && existsSync28(volumeSrc);
+    if (hasVolume && stem !== "lightmap") {
+      rmSync9(join30(outDir, `${stem}.volume`), { force: true });
+      renameSync3(volumeSrc, join30(outDir, `${stem}.volume`));
+    }
+    logErr(c.dim(`  encoded ${pages} page(s)${hasLight ? " + the light atlas" : ""} (UASTC + mips, ${Math.round(ktxKb)} KB from ${Math.round(pngKb)} KB of rasters) in ${((Date.now() - t0) / 1000).toFixed(1)} s`));
+    logErr(c.green(`✓ baked → ${relative4(root, outDir) || "."}/${stem}.bake + ${data.textures.join(", ")}${hasLight ? ` + ${data.lightTextures.join(", ")}` : ""}${hasVolume ? ` + ${stem}.volume` : ""}`));
+    const rel = (f3) => relative4(root, join30(outDir, f3)).replace(/\\/g, "/");
+    const assets = (files) => files.length === 1 ? `asset('<rel>/${rel(files[0])}')` : `[${files.map((f3) => `asset('<rel>/${rel(f3)}')`).join(", ")}]`;
+    logErr(c.dim(`  scene file: env.lightmap: { data: asset('<rel>/${rel(`${stem}.bake`)}'), texture: ${assets(data.textures)}${hasLight ? `, light: ${assets(data.lightTextures)}` : ""}${hasVolume ? `, volume: asset('<rel>/${rel(`${stem}.volume`)}')` : ""} }  — asset() paths are relative to the scene file`));
     return;
   }
   if (lines.some((l2) => /no bake module/.test(l2))) {
@@ -223259,28 +223394,32 @@ var placeholderVolume = () => {
   b[37] = 255;
   return b;
 };
-var ensurePlaceholders = (outDir) => {
-  const bake2 = join30(outDir, "lightmap.bake");
-  const ktx2 = join30(outDir, "lightmap.ktx2");
-  const volume = join30(outDir, "lightmap.volume");
-  if (!existsSync28(bake2))
-    writeFileSync22(bake2, JSON.stringify({ version: 1, placeholder: true, size: 1, texel: 0, instances: [] }) + `
+var ensurePlaceholders = (outDir, stem) => {
+  const missing = (f3) => !existsSync28(f3) || statSync10(f3).size === 0;
+  const bake2 = join30(outDir, `${stem}.bake`);
+  const ktx2 = join30(outDir, pageFile(stem, 0, false));
+  const light = join30(outDir, pageFile(stem, 0, true));
+  const volume = join30(outDir, `${stem}.volume`);
+  if (missing(bake2))
+    writeFileSync22(bake2, JSON.stringify({ version: 2, placeholder: true, size: 1, texel: 0, pages: 1, instances: [] }) + `
 `);
-  if (!existsSync28(ktx2))
+  if (missing(ktx2))
     writeFileSync22(ktx2, PLACEHOLDER_KTX2);
-  if (!existsSync28(volume))
+  if (missing(light))
+    writeFileSync22(light, PLACEHOLDER_KTX2);
+  if (missing(volume))
     writeFileSync22(volume, placeholderVolume());
 };
 var lightmap = async (args) => {
   const sub = args._[0];
   if (sub === "bake")
     return bake({ ...args, _: args._.slice(1) });
-  throw new CliError("Usage: lecodes lightmap bake [--out assets/lightmap] [--size 4096] [--texel 0.02] [--sun-rays 32] [--ao-rays 64] [--ao-distance 2] [--bias 0.02] [--sun-angle 0.5] [--cell 0.5 | --no-volume] [--frames 900] [--entry main.ts] [--logs]   (needs KTX-Software's toktx)");
+  throw new CliError("Usage: lecodes lightmap bake [--out assets/lightmap] [--name lightmap] [--size 4096] [--pages 4] [--texel 0.02] [--sun-rays 32] [--ao-rays 64] [--ao-distance 2] [--bias 0.02] [--sun-angle 0.5] [--light-rays 16] [--light-radius 0.1] [--bounce 0..1] [--denoise 2] [--cell 0.5 | --no-volume] [--frames 900] [--timeout <ms>] [--entry main.ts] [--logs]   (needs KTX-Software's toktx)");
 };
 
 // src/commands/navmesh.ts
 init_manifest();
-import { existsSync as existsSync29, mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync5, readdirSync as readdirSync14, readFileSync as readFileSync25, rmSync as rmSync10, statSync as statSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync23 } from "node:fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync5, readdirSync as readdirSync14, readFileSync as readFileSync26, rmSync as rmSync10, statSync as statSync11, unlinkSync as unlinkSync2, writeFileSync as writeFileSync23 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename16, join as join31, relative as relative5, resolve as resolve14 } from "node:path";
 init_util();
@@ -223299,8 +223438,8 @@ var createCreatorNav = (() => {
     var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
     var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer";
     if (ENVIRONMENT_IS_NODE) {
-      const { createRequire: createRequire4 } = await import("module");
-      var require2 = createRequire4(import.meta.url);
+      const { createRequire: createRequire5 } = await import("module");
+      var require2 = createRequire5(import.meta.url);
     }
     var arguments_ = [];
     var thisProgram = "./this.program";
@@ -224093,7 +224232,7 @@ var guessName = (root) => {
       if (!f3.endsWith(".scene.ts"))
         continue;
       try {
-        if (/\bnavmesh\s*:/.test(readFileSync25(join31(dir, f3), "utf8")))
+        if (/\bnavmesh\s*:/.test(readFileSync26(join31(dir, f3), "utf8")))
           return f3.slice(0, -".scene.ts".length);
       } catch {}
     }
@@ -224221,7 +224360,7 @@ import ${JSON.stringify(importPath)}
   const geoPath = join31(outDir, `${name}.navgeo`);
   if (!existsSync29(geoPath))
     throw new CliError(`The host reported a dump but ${geoPath} is missing.`);
-  const geo = readNgeo(new Uint8Array(readFileSync25(geoPath)));
+  const geo = readNgeo(new Uint8Array(readFileSync26(geoPath)));
   const params = {
     agentRadius: num2(args, "radius", config.agent.radius, 0.05, 10),
     agentHeight: num2(args, "height", config.agent.height, 0.1, 20),
@@ -224307,7 +224446,7 @@ var login = async (args) => {
 
 // src/commands/shaders.ts
 init_manifest();
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync27 } from "node:fs";
 init_util();
 init_compile();
 var collectShaders = () => {
@@ -224339,7 +224478,7 @@ var status2 = async () => {
       if (matcId === null)
         state = c.dim("unknown (matc not downloaded)");
       else {
-        const text = readFileSync26(shader.absPath, "utf8");
+        const text = readFileSync27(shader.absPath, "utf8");
         if (shaderIsCompiled(root, text, matcId))
           state = "compiled";
         else {
@@ -224348,7 +224487,7 @@ var status2 = async () => {
         }
       }
       log(`  ${shader.path.padEnd(width)}  ${state}`);
-      const schema = parseShaderSchema(readFileSync26(shader.absPath, "utf8"));
+      const schema = parseShaderSchema(readFileSync27(shader.absPath, "utf8"));
       for (const p2 of schema.params) {
         const range = p2.min !== undefined ? ` [${p2.min}..${p2.max}]` : "";
         const def = p2.default !== null && p2.default !== undefined ? ` = ${JSON.stringify(p2.default)}` : "";
@@ -224391,7 +224530,7 @@ var compile3 = async (args) => {
   }
   const matcExe = await resolveMatcExe();
   const matcId = matcIdentity(matcExe);
-  const wasCompiled = new Map(shaders.map((s2) => [s2.path, shaderIsCompiled(root, readFileSync26(s2.absPath, "utf8"), matcId)]));
+  const wasCompiled = new Map(shaders.map((s2) => [s2.path, shaderIsCompiled(root, readFileSync27(s2.absPath, "utf8"), matcId)]));
   const errors2 = [];
   for (const shader of shaders) {
     try {
@@ -224425,7 +224564,7 @@ var shaders = async (args) => {
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync23, readFileSync as readFileSync28, writeFileSync as writeFileSync24 } from "node:fs";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync29, writeFileSync as writeFileSync24 } from "node:fs";
 import { dirname as dirname15, resolve as resolve17 } from "node:path";
 
 // src/compile/headlessBundle.ts
@@ -224510,7 +224649,7 @@ var compileHeadlessBundle = async (args, opts = {}) => {
 // src/compile/screenEntry.ts
 init_designMeta();
 init_util();
-import { existsSync as existsSync30, readFileSync as readFileSync27, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync28, statSync as statSync12 } from "node:fs";
 import { isAbsolute, join as join32, relative as relative6, resolve as resolve15 } from "node:path";
 var SCREEN_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
 var SCREEN_ENTRY_PATH = "/.screen-entry.ts";
@@ -224545,7 +224684,7 @@ var resolveScreenTarget = (root, file, opts = {}) => {
     throw new CliError(`"${file}" is outside the project (${root}) — a screen renders as part of its project, so its ` + `imports and asset() files resolve from the same tree.`);
   }
   const key = toKey(rel);
-  if (!/^\s*export\s+default\b/m.test(readFileSync27(abs, "utf8"))) {
+  if (!/^\s*export\s+default\b/m.test(readFileSync28(abs, "utf8"))) {
     throw new CliError(`${key.slice(1)} has no default export. A screen file ends with ` + `\`export default UIScreen([...])\` — or \`export default (state) => UIScreen([...])\` for screen states.`);
   }
   const invoke = opts.state !== undefined ? `screen(${JSON.stringify(opts.state)})` : "screen()";
@@ -224852,7 +224991,7 @@ var evaluateDesktopRun = (plan, output) => {
     if (!error && st.expectLog !== undefined) {
       const seen = consoleLines.slice(0, cutoff);
       if (!seen.some((l2) => l2.includes(st.expectLog))) {
-        const tail = seen.filter((l2) => l2.startsWith("[DEBUG]") || l2.startsWith("[INFO]") || l2.startsWith("[WARN]") || l2.startsWith("[ERROR]")).slice(-3);
+        const tail = seen.filter((l2) => l2.startsWith("[DEBUG]") || l2.startsWith("[INFO]") || l2.startsWith("[WARN]") || l2.startsWith("[ERROR]")).slice(-8);
         error = `expected a console line containing "${st.expectLog}" — ${tail.length === 0 ? "the app logged nothing" : `last lines: ${tail.map((l2) => `"${l2}"`).join(", ")}`}`;
       }
     }
@@ -224906,7 +225045,7 @@ var resolveFixtures = (value, baseDir) => {
   if (typeof value === "string") {
     const abs = resolve17(baseDir, value);
     try {
-      map = JSON.parse(readFileSync28(abs, "utf8"));
+      map = JSON.parse(readFileSync29(abs, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read fixtures "${value}": ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -224919,7 +225058,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path2) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync28(resolve17(path2), "utf8"));
+    raw = JSON.parse(readFileSync29(resolve17(path2), "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read scenario "${path2}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -225133,6 +225272,26 @@ var render = async (args) => {
       session.dispose();
     }
   }
+  const mapFlag = flagStr(args, "map") ?? (flagBool(args, "map") ? "map.png" : undefined);
+  if (mapFlag !== undefined) {
+    note(`Rendering map…`);
+    const title = root.split(/[\\/]/).pop();
+    const { png: png2, data, warnings: mapWarnings } = await renderer.renderToMap(js, {
+      ...timing,
+      maxPx: Number(flagStr(args, "max-px")) || undefined,
+      title,
+      labelAll: flagBool(args, "label-all")
+    });
+    for (const w of [...warnings, ...mapWarnings])
+      warnErr(w);
+    const pngPath = mapFlag.endsWith(".png") ? mapFlag : mapFlag + ".png";
+    mkdirSync23(dirname15(resolve17(pngPath)), { recursive: true });
+    writeFileSync24(resolve17(pngPath), png2);
+    const jsonPath = pngPath.slice(0, -4) + ".json";
+    writeFileSync24(resolve17(jsonPath), JSON.stringify(data, null, 2));
+    note(`Wrote ${pngPath} + ${jsonPath}`);
+    return done((cb) => cb());
+  }
   const pngFlag = flagStr(args, "png") ?? (flagBool(args, "png") ? "screenshot.png" : undefined);
   if (pngFlag !== undefined) {
     note(screen2 ? `Rendering ${screen2.label} (PNG)…` : "Rendering PNG…");
@@ -225180,7 +225339,7 @@ init_api();
 init_config();
 init_manifest();
 init_util();
-import { appendFileSync as appendFileSync2, existsSync as existsSync31, readFileSync as readFileSync29, writeFileSync as writeFileSync25 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync31, readFileSync as readFileSync30, writeFileSync as writeFileSync25 } from "node:fs";
 import { join as join33 } from "node:path";
 var ENV_VAR = "LECODES_PUSH_KEY";
 var context = () => {
@@ -225327,7 +225486,7 @@ var writeEnv = (root, key) => {
   const touched = [];
   const envPath = join33(root, ".env");
   const line = `${ENV_VAR}=${key}`;
-  const existing = existsSync31(envPath) ? readFileSync29(envPath, "utf8") : "";
+  const existing = existsSync31(envPath) ? readFileSync30(envPath, "utf8") : "";
   if (new RegExp(`^${ENV_VAR}=`, "m").test(existing)) {
     writeFileSync25(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
   } else {
@@ -225339,7 +225498,7 @@ var writeEnv = (root, key) => {
   }
   touched.push(".env");
   const ignorePath = join33(root, ".gitignore");
-  const ignore = existsSync31(ignorePath) ? readFileSync29(ignorePath, "utf8") : "";
+  const ignore = existsSync31(ignorePath) ? readFileSync30(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l2) => l2.trim() === ".env")) {
     const separator = !ignore || ignore.endsWith(`
@@ -225525,7 +225684,7 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/scene.ts
 init_manifest();
-import { existsSync as existsSync34, readFileSync as readFileSync31, readdirSync as readdirSync15, statSync as statSync13, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync32, readdirSync as readdirSync15, statSync as statSync13, writeFileSync as writeFileSync28 } from "node:fs";
 import { basename as basename17, dirname as dirname17, join as join36, resolve as resolve18 } from "node:path";
 
 // src/compile/sceneCompile.ts
@@ -225535,7 +225694,7 @@ init_distRoot();
 init_util();
 init_projectCompile();
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync33, mkdirSync as mkdirSync25, readFileSync as readFileSync30, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync25, readFileSync as readFileSync31, writeFileSync as writeFileSync27 } from "node:fs";
 import { join as join35 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
@@ -225546,7 +225705,7 @@ var resolveHarness = (loadSceneHarness2) => {
   } catch {
     const vendored = join35(distRoot, "runtime", "scene-harness.json");
     if (existsSync33(vendored))
-      return JSON.parse(readFileSync30(vendored, "utf8"));
+      return JSON.parse(readFileSync31(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
 };
@@ -225558,16 +225717,16 @@ var compileSceneEditor = async (opts) => {
   for (const file of scan2.files) {
     const path2 = "./" + rel(file.path);
     if (TEXT_EXT.test(path2)) {
-      entries.push({ path: path2, type: "text", text: readFileSync30(file.absPath, "utf8") });
+      entries.push({ path: path2, type: "text", text: readFileSync31(file.absPath, "utf8") });
     } else if (/\.mat$/i.test(path2)) {
-      entries.push({ path: path2, type: "shader", text: readFileSync30(file.absPath, "utf8"), absPath: file.absPath });
+      entries.push({ path: path2, type: "shader", text: readFileSync31(file.absPath, "utf8"), absPath: file.absPath });
     } else {
       entries.push({ path: path2, type: "resource", fileSrc: "/project/" + rel(file.path) });
     }
   }
   const shaderEntries = entries.filter((e2) => e2.type === "shader");
   if (shaderEntries.length > 0) {
-    const { warnings } = await applyLocalShaders(shaderEntries, { root, srcPrefix: "/project/.lecodes/shaders", platforms: ["webgl", "webgl-lite"] });
+    const { warnings } = await applyLocalShaders(shaderEntries, { root, srcPrefix: "/project/.lecodes/shaders", platforms: ["opengl", "webgl-lite"] });
     for (const w of warnings)
       warnErr(w);
     const { buildLiteMaterialArtifact: buildLiteMaterialArtifact2 } = await Promise.resolve().then(() => (init_compile(), exports_compile));
@@ -225581,7 +225740,7 @@ var compileSceneEditor = async (opts) => {
       if (!existsSync33(join35(dir, liteName)))
         writeFileSync27(join35(dir, liteName), JSON.stringify(buildLiteMaterialArtifact2(e2.text ?? "")));
       const src = `/project/.lecodes/shaders/${hash}_opengl.filamat`;
-      e2.shaders = ["opengl", "webgl", "webgl-lite"].map((platform) => ({ platform, src }));
+      e2.shaders = ["opengl", "webgl-lite"].map((platform) => ({ platform, src }));
     }
   }
   const scene = scenePath.startsWith("./") ? scenePath : "./" + rel(scenePath);
@@ -225621,6 +225780,13 @@ var findAppRoot = (start) => {
     dir = parent;
   }
 };
+var projectRootOf = (dir) => {
+  try {
+    return findProjectRoot(dir);
+  } catch {
+    return findAppRoot(dir) ?? dir;
+  }
+};
 var getContext2 = (args) => {
   let root;
   let manifest;
@@ -225651,7 +225817,7 @@ var writeMcpConfig2 = (root, port) => {
   let config = {};
   if (existsSync34(path2)) {
     try {
-      config = JSON.parse(readFileSync31(path2, "utf8"));
+      config = JSON.parse(readFileSync32(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -225715,13 +225881,170 @@ var scene = async (args) => {
     openBrowser(server2.url);
 };
 
+// src/commands/thumbs.ts
+import { createRequire as createRequire5 } from "node:module";
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { existsSync as existsSync35, mkdtempSync as mkdtempSync6, readdirSync as readdirSync16, rmSync as rmSync12, statSync as statSync14 } from "node:fs";
+import { tmpdir as tmpdir6 } from "node:os";
+import { extname, join as join37, relative as relative7, resolve as resolve19 } from "node:path";
+init_util();
+var DEFAULT_SIZE = 256;
+var IMAGE_EXT = /\.(png|jpe?g|webp|bmp|gif|tiff?|ktx2)$/i;
+var RENDERED_EXT = /\.(glb|gltf|material\.ts|scene\.ts)$/i;
+var findKtx = () => {
+  const exe = process.platform === "win32" ? "ktx.exe" : "ktx";
+  const candidates = [
+    process.env.LECODES_KTX,
+    process.env.KTX_CLI,
+    process.env.KTX_TOKTX?.replace(/toktx(\.exe)?$/i, exe),
+    process.platform === "win32" ? join37(process.env.LOCALAPPDATA ?? "", "Programs", "KTX-Software", "bin", exe) : null,
+    process.platform === "win32" ? join37(process.env.ProgramFiles ?? "", "KTX-Software", "bin", exe) : null,
+    "/usr/local/bin/ktx",
+    "/opt/homebrew/bin/ktx"
+  ].filter((p2) => !!p2);
+  for (const path2 of candidates) {
+    if (existsSync35(path2))
+      return path2;
+  }
+  try {
+    execFileSync7(exe, ["--version"], { stdio: "ignore" });
+    return exe;
+  } catch {
+    return null;
+  }
+};
+var sharpResizer = () => {
+  try {
+    const req = createRequire5(import.meta.url);
+    const sharp = createRequire5(req.resolve("lecodes-assets/cli"))("sharp");
+    return async (file, size) => sharp(file).resize({ width: size, height: size, fit: "inside", withoutEnlargement: true }).png().toBuffer();
+  } catch {
+    return null;
+  }
+};
+var jimpResizer = () => async (file, size) => {
+  const { Jimp: Jimp2 } = await Promise.resolve().then(() => (init_esm30(), exports_esm2));
+  const img = await Jimp2.read(file);
+  if (Math.max(img.width, img.height) > size)
+    img.scaleToFit({ w: size, h: size });
+  return await img.getBuffer("image/png");
+};
+var ktxToPng = (ktx, file, out) => {
+  const run2 = (args) => execFileSync7(ktx, args, { stdio: ["ignore", "ignore", "pipe"], encoding: "utf8" });
+  try {
+    run2(["extract", "--transcode", "rgba8", "--level", "0", file, out]);
+  } catch (e2) {
+    run2(["extract", "--level", "0", file, out]);
+    if (!existsSync35(out))
+      throw e2;
+  }
+};
+var collect = (dir) => {
+  const out = [];
+  for (const name of readdirSync16(dir)) {
+    if (name === "node_modules" || name.startsWith("."))
+      continue;
+    const full = join37(dir, name);
+    if (statSync14(full).isDirectory())
+      out.push(...collect(full));
+    else if (IMAGE_EXT.test(name))
+      out.push(full);
+  }
+  return out;
+};
+var thumbs = async (args) => {
+  const root = projectRootOf(process.cwd());
+  let sceneServer;
+  try {
+    sceneServer = await import("lecodes-3d-editor/server");
+  } catch {
+    throw new CliError("The scene editor isn't installed (it owns the preview cache). Run:  npm install -g lecodes-3d-editor");
+  }
+  const size = Number(flagStr(args, "size")) || DEFAULT_SIZE;
+  const force = flagBool(args, "force");
+  let files = [];
+  const rendered = [];
+  if (args._.length > 0) {
+    for (const arg of args._) {
+      const abs = resolve19(process.cwd(), arg);
+      if (!existsSync35(abs))
+        throw new CliError(`No such file or folder: ${arg}`);
+      if (statSync14(abs).isDirectory())
+        files.push(...collect(abs));
+      else if (IMAGE_EXT.test(abs))
+        files.push(abs);
+      else if (RENDERED_EXT.test(abs))
+        rendered.push(arg);
+      else
+        throw new CliError(`Not a previewable asset: ${arg}`);
+    }
+  } else {
+    files = collect(root);
+  }
+  files = [...new Set(files)];
+  if (files.length === 0 && rendered.length === 0) {
+    log("No images to thumbnail.");
+    return;
+  }
+  const ktx = files.some((f3) => f3.toLowerCase().endsWith(".ktx2")) ? findKtx() : null;
+  const sharp = sharpResizer();
+  const resize = sharp ?? jimpResizer();
+  const tmp = mkdtempSync6(join37(tmpdir6(), "lecodes-thumbs-"));
+  let made = 0, fresh = 0;
+  const skipped = [];
+  try {
+    for (const [i2, file] of files.entries()) {
+      const asset = "./" + toKey(relative7(root, file));
+      progress(i2, files.length, asset);
+      const hash = sceneServer.hashAsset(root, asset);
+      if (!hash)
+        continue;
+      if (!force && sceneServer.previewIsCurrent(root, asset, hash)) {
+        fresh++;
+        continue;
+      }
+      const ext2 = extname(file).toLowerCase();
+      if (ext2 === ".webp" && !sharp) {
+        skipped.push(`${asset} (webp needs sharp — npm install -g lecodes-assets)`);
+        continue;
+      }
+      try {
+        let source = file;
+        if (ext2 === ".ktx2") {
+          if (!ktx) {
+            skipped.push(`${asset} (KTX2 needs KTX-Software's \`ktx\` — set LECODES_KTX or put it on PATH)`);
+            continue;
+          }
+          source = join37(tmp, `${i2}.png`);
+          ktxToPng(ktx, file, source);
+        }
+        sceneServer.writePreviewFile(root, asset, await resize(source, size));
+        made++;
+      } catch (e2) {
+        skipped.push(`${asset} (${(e2?.message ?? String(e2)).split(`
+`)[0]})`);
+      }
+    }
+  } finally {
+    endProgress();
+    rmSync12(tmp, { recursive: true, force: true });
+  }
+  log(`${c.bold(String(made))} generated · ${fresh} already current${skipped.length > 0 ? ` · ${skipped.length} skipped` : ""}`);
+  for (const s2 of skipped)
+    warnErr(s2);
+  if (rendered.length > 0) {
+    warnErr(`Models, materials and prefabs are RENDERED, not decoded — the scene editor does those: ${rendered.join(", ")}`);
+  }
+  note(`Cache: ${join37(root, ".lecodes", "preview")}  (re-runs skip everything unchanged)`);
+};
+
 // src/commands/assets.ts
 init_util();
 
 // src/cmgenTool.ts
-import { existsSync as existsSync35, readdirSync as readdirSync16 } from "node:fs";
+import { existsSync as existsSync36, readdirSync as readdirSync17 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join37, resolve as resolve19 } from "node:path";
+import { join as join38, resolve as resolve20 } from "node:path";
 init_util();
 var exeName2 = () => process.platform === "win32" ? "cmgen.exe" : "cmgen";
 var platformKey3 = () => {
@@ -225731,10 +226054,10 @@ var platformKey3 = () => {
     return "linux-x64";
   throw new CliError(process.platform === "darwin" ? "cmgen isn't published for macOS yet — build filament's host tools locally and set LECODES_CMGEN." : `cmgen isn't published for ${process.platform}.`);
 };
-var cacheRoot3 = () => join37(homedir8(), ".lecodes", "cmgen");
+var cacheRoot3 = () => join38(homedir8(), ".lecodes", "cmgen");
 var findCmgenIn = (dir) => {
-  for (const entry of readdirSync16(dir, { withFileTypes: true })) {
-    const p2 = join37(dir, entry.name);
+  for (const entry of readdirSync17(dir, { withFileTypes: true })) {
+    const p2 = join38(dir, entry.name);
     if (entry.isFile() && entry.name === exeName2())
       return p2;
     if (entry.isDirectory()) {
@@ -225747,7 +226070,7 @@ var findCmgenIn = (dir) => {
 };
 var installedCmgenVersions = () => {
   try {
-    return readdirSync16(cacheRoot3(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("cmgen-")).map((e2) => e2.name.slice("cmgen-".length)).filter((v) => findCmgenIn(join37(cacheRoot3(), `cmgen-${v}`)) !== null).sort(semverNewer);
+    return readdirSync17(cacheRoot3(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("cmgen-")).map((e2) => e2.name.slice("cmgen-".length)).filter((v) => findCmgenIn(join38(cacheRoot3(), `cmgen-${v}`)) !== null).sort(semverNewer);
   } catch {
     return [];
   }
@@ -225769,19 +226092,19 @@ var downloadCmgen = async (version, versions, dest) => {
 var resolveCmgenExeCached = () => {
   const override = process.env.LECODES_CMGEN;
   if (override) {
-    if (!existsSync35(override))
+    if (!existsSync36(override))
       throw new CliError(`LECODES_CMGEN points at "${override}" which doesn't exist.`);
-    return resolve19(override);
+    return resolve20(override);
   }
   const cached = installedCmgenVersions()[0];
-  return cached ? findCmgenIn(join37(cacheRoot3(), `cmgen-${cached}`)) : null;
+  return cached ? findCmgenIn(join38(cacheRoot3(), `cmgen-${cached}`)) : null;
 };
 var resolveCmgenExe = async () => {
   const cached = resolveCmgenExeCached();
   if (cached)
     return cached;
   const { latest, versions } = await fetchCmgenManifest();
-  const dir = join37(cacheRoot3(), `cmgen-${latest}`);
+  const dir = join38(cacheRoot3(), `cmgen-${latest}`);
   await downloadCmgen(latest, versions, dir);
   const exe = findCmgenIn(dir);
   if (!exe)
@@ -225839,8 +226162,8 @@ var status3 = async (_args) => {
 };
 
 // src/commands/test.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync26, readFileSync as readFileSync32, readdirSync as readdirSync17 } from "node:fs";
-import { dirname as dirname18, resolve as resolve20 } from "node:path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync26, readFileSync as readFileSync33, readdirSync as readdirSync18 } from "node:fs";
+import { dirname as dirname18, resolve as resolve21 } from "node:path";
 init_manifest();
 init_util();
 var deriveDesignFlows = (meta, entryScreen) => {
@@ -225903,7 +226226,7 @@ var slug3 = (s2) => s2.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").
 var readFlowFile = (abs, displayName) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync32(abs, "utf8"));
+    raw = JSON.parse(readFileSync33(abs, "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read "${displayName}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -225958,40 +226281,40 @@ var test = async (args) => {
   if (!Number.isFinite(nativeFixedDt) || nativeFixedDt < 0 || nativeFixedDt > 1000)
     throw new CliError(`--fixed-dt wants a number of ms (0 = wall clock, max 1000), got "${fixedDtFlag}".`);
   const projectViewport = desktopDefaultViewport(root);
-  const testsDir = resolve20(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve20(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve21(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve21(root, flagStr(args, "design-dir") ?? "design", "meta.json");
   const asJson = flagBool(args, "json");
   const out = asJson ? logErr : log;
   const cases = [];
   if (args._.length > 0) {
     for (const given of args._) {
-      const candidates = [resolve20(given), resolve20(testsDir, given), resolve20(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p2) => existsSync36(p2));
+      const candidates = [resolve21(given), resolve21(testsDir, given), resolve21(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p2) => existsSync37(p2));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync36(testsDir)) {
-    for (const f3 of readdirSync17(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve20(testsDir, f3), f3));
+  } else if (existsSync37(testsDir)) {
+    for (const f3 of readdirSync18(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve21(testsDir, f3), f3));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve20(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync36(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve21(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync37(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
   const flowsOnly = flagBool(args, "flows");
   const wantFlows = !flagBool(args, "no-flows") && args._.length === 0;
   if (flowsOnly)
     cases.length = 0;
   let skipped = [];
   let entryScreen = null;
-  if (desktop2 && wantFlows && existsSync36(designMetaPath)) {
+  if (desktop2 && wantFlows && existsSync37(designMetaPath)) {
     note("Design-derived flows skipped with --desktop (they tap by name; run `lecodes test` headless for them).");
   }
-  if (!desktop2 && (wantFlows || flowsOnly) && existsSync36(designMetaPath)) {
+  if (!desktop2 && (wantFlows || flowsOnly) && existsSync37(designMetaPath)) {
     let meta;
     try {
-      meta = JSON.parse(readFileSync32(designMetaPath, "utf8"));
+      meta = JSON.parse(readFileSync33(designMetaPath, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read ${designMetaPath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -226023,16 +226346,16 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve20(root, flagStr(args, "artifacts") ?? resolve20(testsDir, ".artifacts"));
+  const artifactsRoot = resolve21(root, flagStr(args, "artifacts") ?? resolve21(testsDir, ".artifacts"));
   const results = [];
   const runNativeCase = async (kase) => {
-    const caseDir = resolve20(artifactsRoot, slug3(kase.name));
+    const caseDir = resolve21(artifactsRoot, slug3(kase.name));
     const plan = translateScenario(kase.steps, { outDir: caseDir, headroomFrames: nativeFrames });
     for (const st of plan.steps)
       if (st.screenshot)
         mkdirSync26(dirname18(st.screenshot), { recursive: true });
     mkdirSync26(caseDir, { recursive: true });
-    const finalPng = resolve20(caseDir, "final.png");
+    const finalPng = resolve21(caseDir, "final.png");
     const { output } = await runDesktopRender(native.js, native.resources, {
       renderer: desktopRenderer,
       width: Number(flagStr(args, "width")) || kase.width || projectViewport?.width || 390,
@@ -226084,14 +226407,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve20(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve21(artifactsRoot, slug3(kase.name)));
         const outcome = await renderer.runScenario(session, steps, io);
         result = {
           name: kase.name,
           kind: kase.kind,
           ok: outcome.ok,
           steps: outcome.steps.map((s2) => ({ desc: s2.desc, ok: s2.ok, error: s2.error })),
-          artifacts: outcome.failureArtifacts.map((p2) => resolve20(artifactsRoot, slug3(kase.name), p2))
+          artifacts: outcome.failureArtifacts.map((p2) => resolve21(artifactsRoot, slug3(kase.name), p2))
         };
       } finally {
         session.dispose();
@@ -226153,17 +226476,54 @@ var test = async (args) => {
   process.exit(failed > 0 ? 1 : 0);
 };
 
+// src/commands/update.ts
+import { spawnSync as spawnSync7 } from "node:child_process";
+import { existsSync as existsSync39, readdirSync as readdirSync19 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname20, join as join40, resolve as resolve23 } from "node:path";
+init_util();
+
+// src/peers.ts
+import { existsSync as existsSync38, readFileSync as readFileSync34 } from "node:fs";
+import { createRequire as createRequire6 } from "node:module";
+import { dirname as dirname19, join as join39 } from "node:path";
+var OPTIONAL_PEERS = [
+  ["lecodes-renderer", "lecodes-renderer/headless"],
+  ["lecodes-design", "lecodes-design/server"],
+  ["lecodes-3d-editor", "lecodes-3d-editor/server"],
+  ["lecodes-assets", "lecodes-assets/cli"]
+];
+var peerVersion = (name, probe) => {
+  try {
+    const require2 = createRequire6(import.meta.url);
+    let dir = dirname19(require2.resolve(probe));
+    for (let depth = 0;depth < 16; depth++) {
+      const manifest = join39(dir, "package.json");
+      if (existsSync38(manifest)) {
+        const parsed = JSON.parse(readFileSync34(manifest, "utf8"));
+        if (parsed.name === name)
+          return parsed.version ?? "unknown";
+      }
+      const parent = dirname19(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  return null;
+};
+
 // src/commands/types.ts
 init_api();
 init_config();
 init_manifest();
 init_types4();
 init_util();
-import { resolve as resolve21 } from "node:path";
+import { resolve as resolve22 } from "node:path";
 var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
 var types4 = async (args) => {
   const dirArg = args._[0];
-  const root = dirArg ? resolve21(dirArg) : (() => {
+  const root = dirArg ? resolve22(dirArg) : (() => {
     try {
       return findProjectRoot(process.cwd());
     } catch {
@@ -226198,9 +226558,9 @@ var types4 = async (args) => {
   const same = bundleHash(onDisk) === bundleHash(bundle);
   if (checkOnly) {
     if (Object.keys(onDisk).length === 0)
-      throw new CliError(`No types in ${LECODES_DIR}/types/ — run \`lecodes types\`.`);
+      throw new CliError(`No types in ${LECODES_DIR}/types/ — run \`lecodes update\`.`);
     if (!same)
-      throw new CliError(`Types are out of date (${label(onDisk)} on disk) — run \`lecodes types\`.`);
+      throw new CliError(`Types are out of date (${label(onDisk)} on disk) — run \`lecodes update\`.`);
     success(`Types are up to date (${label(onDisk)}).`);
     return;
   }
@@ -226221,24 +226581,161 @@ var types4 = async (args) => {
     note("Reload the TypeScript server in your editor to pick them up.");
 };
 
+// src/commands/update.ts
+var findProjectDir = (start) => {
+  const home = resolve23(homedir9());
+  let dir = resolve23(start);
+  while (true) {
+    if (dir !== home && (existsSync39(join40(dir, "app.json")) || existsSync39(join40(dir, ".lecodes", "manifest.json")) || existsSync39(join40(dir, ".lecodes", "types"))))
+      return dir;
+    const parent = dirname20(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+};
+var NPM = "https://registry.npmjs.org";
+var npmLatest = async (name) => {
+  try {
+    const res = await fetch(`${NPM}/${name}/latest`, { signal: AbortSignal.timeout(4000) });
+    if (!res.ok)
+      return null;
+    const json = await res.json();
+    return json.version ?? null;
+  } catch {
+    return null;
+  }
+};
+var semverNewer2 = (a2, b) => {
+  const pa = a2.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
+  for (let i2 = 0;i2 < 3; i2++) {
+    const d = (pa[i2] ?? 0) - (pb[i2] ?? 0);
+    if (d)
+      return d;
+  }
+  return 0;
+};
+var FROM_SOURCE = /[\\/]src[\\/]commands[\\/]/.test(import.meta.url);
+var STANDALONE = existsSync39(join40(dirname20(process.execPath), "runtime")) && existsSync39(join40(dirname20(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel"));
+var update = async (args) => {
+  const steps = [];
+  const heading = (name, what) => log(`
+${c.bold(name)}  ${c.dim(what)}`);
+  const run2 = async (name, what, fn) => {
+    heading(name, what);
+    try {
+      const r2 = await fn();
+      const [outcome, detail] = Array.isArray(r2) ? r2 : [r2, undefined];
+      steps.push({ name, outcome, detail });
+      if (outcome === "skipped" && detail)
+        note(`skipped — ${detail}`);
+    } catch (e2) {
+      const msg = e2 instanceof CliError ? e2.message : e2 instanceof Error ? e2.message : String(e2);
+      log(c.red("✗ ") + msg);
+      steps.push({ name, outcome: "failed", detail: msg });
+    }
+  };
+  const root = findProjectDir(process.cwd());
+  await run2("desktop", "LeCodes Desktop host (desktop run / render --desktop)", async () => {
+    if (process.env.LECODES_DESKTOP_EXE)
+      return ["skipped", `LECODES_DESKTOP_EXE=${process.env.LECODES_DESKTOP_EXE} (a local build; \`lecodes desktop update\` refreshes the cache anyway)`];
+    await updateDesktop();
+    return "ok";
+  });
+  await run2("matc", "Filament material compiler for local shader compiles", async () => {
+    if (process.env.LECODES_MATC)
+      return ["skipped", `LECODES_MATC=${process.env.LECODES_MATC} (a local matc)`];
+    await updateMatc();
+    return "ok";
+  });
+  await run2("shaders", "recompile the project's .mat shaders with the current matc", async () => {
+    if (!root)
+      return ["skipped", "not inside a project"];
+    await shaders({ _: ["compile"], flags: {} });
+    return "ok";
+  });
+  await run2("types", flagBool(args, "local") ? "IDE types from the SDK bundled in this CLI" : "IDE types from the server", async () => {
+    if (!root)
+      return ["skipped", "not inside a project"];
+    await types4({ _: [], flags: flagBool(args, "local") ? { local: true } : {} });
+    return "ok";
+  });
+  await run2("shells", "ios/ + android/ pins → newest SDK release + plugin tags, then re-sync", async () => {
+    if (!root)
+      return ["skipped", "not inside a project"];
+    if (flagBool(args, "no-shells"))
+      return ["skipped", "--no-shells"];
+    const present = ["ios", "android"].filter((d) => existsSync39(join40(root, d)) && readdirSync19(join40(root, d)).length > 0);
+    if (present.length === 0)
+      return ["skipped", "no ios/ or android/ shell in this project (`lecodes app init ios|android`)"];
+    await app({ _: ["update"], flags: {} });
+    return "ok";
+  });
+  await run2("cli", "lecodes-cli + its optional peers (global npm installs)", async () => {
+    if (flagBool(args, "no-cli"))
+      return ["skipped", "--no-cli"];
+    if (FROM_SOURCE)
+      return ["skipped", "running from the repo checkout — the CLI and its peers are the repo's own"];
+    const rows = [];
+    for (const [name, probe] of OPTIONAL_PEERS) {
+      const installed = peerVersion(name, probe);
+      rows.push({ name, installed, latest: installed ? await npmLatest(name) : null });
+    }
+    rows.push({ name: "lecodes-cli", installed: package_default.version, latest: await npmLatest("lecodes-cli") });
+    if (rows.every((r3) => r3.latest === null))
+      return ["skipped", "npm unreachable"];
+    const behind = rows.filter((r3) => r3.installed && r3.latest && semverNewer2(r3.latest, r3.installed) > 0);
+    for (const r3 of rows) {
+      const state = !r3.installed ? c.dim("not installed (optional — npm install -g " + r3.name + ")") : !r3.latest ? c.dim("(npm: unknown)") : behind.includes(r3) ? c.yellow("→ " + r3.latest) : c.dim("(up to date)");
+      log("  " + r3.name.padEnd(18) + " " + (r3.installed ?? "").padEnd(8) + " " + state);
+    }
+    if (behind.length === 0)
+      return "ok";
+    const specs = behind.map((r3) => r3.name + "@latest");
+    if (flagBool(args, "check"))
+      return ["updated", behind.length + " behind — run: npm install -g " + specs.join(" ")];
+    if (STANDALONE && behind.some((r3) => r3.name === "lecodes-cli")) {
+      note("this is the standalone build — the CLI updates by re-installing the release archive, not through npm; peers still go through npm");
+    }
+    const toInstall = STANDALONE ? specs.filter((s2) => !s2.startsWith("lecodes-cli@")) : specs;
+    if (toInstall.length === 0)
+      return ["skipped", "only the standalone CLI itself is behind — download the release"];
+    log("  " + c.dim("$") + " npm install -g " + toInstall.join(" "));
+    const r2 = spawnSync7("npm", ["install", "-g", ...toInstall], { stdio: "inherit", shell: true });
+    if (r2.status !== 0)
+      throw new CliError("npm install -g exited with " + (r2.status ?? "a signal"));
+    const names3 = toInstall.map((s2) => s2.replace("@latest", "")).join(", ");
+    const cliToo = toInstall.some((s2) => s2.startsWith("lecodes-cli@"));
+    return ["updated", names3 + " → latest" + (cliToo ? " (the new CLI runs from your next command)" : "")];
+  });
+  log(`
+${c.bold("Summary")}`);
+  const width = Math.max(...steps.map((s2) => s2.name.length));
+  for (const s2 of steps) {
+    const mark = s2.outcome === "failed" ? c.red("✗") : s2.outcome === "skipped" ? c.dim("–") : c.green("✓");
+    log(`  ${mark} ${s2.name.padEnd(width)}  ${s2.outcome === "failed" ? c.red(s2.detail ?? "failed") : s2.outcome === "skipped" ? c.dim(s2.detail ?? "skipped") : s2.detail ?? s2.outcome}`);
+  }
+  if (steps.some((s2) => s2.outcome === "failed"))
+    process.exitCode = 1;
+};
+
 // src/index.ts
-import { existsSync as existsSync39, readFileSync as readFileSync35, realpathSync as realpathSync2 } from "node:fs";
-import { createRequire as createRequire4 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname21, join as join40 } from "node:path";
+import { existsSync as existsSync42, realpathSync as realpathSync2 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname23, join as join43 } from "node:path";
 
 // src/commands/install.ts
 init_util();
-import { execFileSync as execFileSync7 } from "node:child_process";
-import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync5, existsSync as existsSync37, mkdirSync as mkdirSync27, readFileSync as readFileSync33, realpathSync, rmSync as rmSync12, symlinkSync } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { basename as basename18, delimiter, dirname as dirname19, join as join38, resolve as resolve22, sep as sep2 } from "node:path";
+import { execFileSync as execFileSync8 } from "node:child_process";
+import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync5, existsSync as existsSync40, mkdirSync as mkdirSync27, readFileSync as readFileSync35, realpathSync, rmSync as rmSync13, symlinkSync as symlinkSync2 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { basename as basename18, delimiter, dirname as dirname21, join as join41, resolve as resolve24, sep as sep2 } from "node:path";
 var isWin = process.platform === "win32";
-var HOME = homedir9();
+var HOME = homedir10();
 var safeRealpath = (p2) => {
   try {
     return realpathSync(p2);
   } catch {
-    return resolve22(p2);
+    return resolve24(p2);
   }
 };
 var onPath = (dir) => {
@@ -226254,13 +226751,13 @@ var onPath = (dir) => {
   });
 };
 var install = async (args) => {
-  const bundle = dirname19(process.execPath);
+  const bundle = dirname21(process.execPath);
   const exeName3 = basename18(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync37(join38(bundle, "runtime")) || !existsSync37(join38(bundle, chiselName))) {
+  if (!existsSync40(join41(bundle, "runtime")) || !existsSync40(join41(bundle, chiselName))) {
     throw new CliError("`lecodes install` only works from the packaged release build (the archive containing lecodes + " + "chisel + runtime/). You appear to be running from source or an npm install — install globally " + "with your package manager there instead.");
   }
-  const companions = [exeName3, chiselName, "runtime", "README.txt"].filter((f3) => existsSync37(join38(bundle, f3)));
+  const companions = [exeName3, chiselName, "runtime", "README.txt"].filter((f3) => existsSync40(join41(bundle, f3)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
@@ -226270,9 +226767,9 @@ var copyBundle = (bundle, target, companions) => {
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f3 of companions) {
-    const dest = join38(target, f3);
-    rmSync12(dest, { recursive: true, force: true });
-    cpSync5(join38(bundle, f3), dest, { recursive: true });
+    const dest = join41(target, f3);
+    rmSync13(dest, { recursive: true, force: true });
+    cpSync5(join41(bundle, f3), dest, { recursive: true });
   }
 };
 var permError = (e2, dir, system) => {
@@ -226284,41 +226781,41 @@ var permError = (e2, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  const libDir = resolve22(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join38(HOME, ".local", "lib", "lecodes-cli")));
-  const binDir = resolve22(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join38(HOME, ".local", "bin")));
-  const link2 = join38(binDir, "lecodes");
+  const libDir = resolve24(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join41(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve24(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join41(HOME, ".local", "bin")));
+  const link2 = join41(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync2(join38(libDir, "lecodes"), 493);
-    chmodSync2(join38(libDir, "chisel"), 493);
+    chmodSync2(join41(libDir, "lecodes"), 493);
+    chmodSync2(join41(libDir, "chisel"), 493);
   } catch (e2) {
     throw permError(e2, libDir, system);
   }
   try {
     mkdirSync27(binDir, { recursive: true });
-    rmSync12(link2, { force: true });
-    symlinkSync(join38(libDir, "lecodes"), link2);
+    rmSync13(link2, { force: true });
+    symlinkSync2(join41(libDir, "lecodes"), link2);
   } catch (e2) {
     throw permError(e2, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link2 + " → " + join38(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join41(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
   const shell = basename18(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join38(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join41(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join38(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join38(HOME, ".profile"), name: "~/.profile" };
+    return { file: join41(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join41(HOME, ".profile"), name: "~/.profile" };
 };
 var PATH_MARKER = "# Added by `lecodes install`";
 var appendPathToShellRc = (binDir) => {
   const { file, name } = shellRc();
   const line = `export PATH="${binDir}:$PATH"`;
   try {
-    const existing = existsSync37(file) ? readFileSync33(file, "utf8") : "";
+    const existing = existsSync40(file) ? readFileSync35(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -226356,7 +226853,7 @@ var finishPathUnix = (args, binDir) => {
   log(`  • or install system-wide (no PATH edit): ${c.bold("sudo lecodes install --system")}`);
 };
 var installWindows = (args, bundle, companions) => {
-  const target = resolve22(flagStr(args, "dir") ?? join38(process.env.LOCALAPPDATA ?? join38(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve24(flagStr(args, "dir") ?? join41(process.env.LOCALAPPDATA ?? join41(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e2) {
@@ -226384,7 +226881,7 @@ var installWindows = (args, bundle, companions) => {
 var addToUserPathWindows = (dir) => {
   const script = "$d = $env:LECODES_INSTALL_DIR;" + "$p = [Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p = '' };" + "$parts = @($p.Split(';') | Where-Object { $_ -ne '' });" + "if ($parts -notcontains $d) { [Environment]::SetEnvironmentVariable('Path', (@($parts + $d) -join ';'), 'User') }";
   try {
-    execFileSync7("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
+    execFileSync8("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
     return true;
   } catch {
     return false;
@@ -226395,9 +226892,9 @@ var addToUserPathWindows = (dir) => {
 init_util();
 
 // src/projectEnv.ts
-import { existsSync as existsSync38, readFileSync as readFileSync34 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { dirname as dirname20, join as join39, resolve as resolve23 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync36 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { dirname as dirname22, join as join42, resolve as resolve25 } from "node:path";
 var KEY_RE = /^(LECODES|CREATOR)_[A-Z0-9_]+$/;
 var parseDotEnv = (text) => {
   const out = {};
@@ -226432,19 +226929,19 @@ var applyDotEnv = (parsed, dir, env) => {
       continue;
     let value = raw;
     if (value.startsWith("./") || value.startsWith("../"))
-      value = resolve23(dir, value);
+      value = resolve25(dir, value);
     else if (value === "~" || value.startsWith("~/"))
-      value = join39(homedir10(), value.slice(1));
+      value = join42(homedir11(), value.slice(1));
     out[key] = value;
   }
   return out;
 };
 var findEnvRoot = (start) => {
-  let dir = resolve23(start);
+  let dir = resolve25(start);
   while (true) {
-    if (existsSync38(join39(dir, "app.json")) || existsSync38(join39(dir, ".lecodes")))
+    if (existsSync41(join42(dir, "app.json")) || existsSync41(join42(dir, ".lecodes")))
       return dir;
-    const parent = dirname20(dir);
+    const parent = dirname22(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -226455,10 +226952,10 @@ var loadProjectEnv = (cwd = process.cwd()) => {
     const root = findEnvRoot(cwd);
     if (!root)
       return [];
-    const file = join39(root, ".env");
-    if (!existsSync38(file))
+    const file = join42(root, ".env");
+    if (!existsSync41(file))
       return [];
-    const added = applyDotEnv(parseDotEnv(readFileSync34(file, "utf8")), root, process.env);
+    const added = applyDotEnv(parseDotEnv(readFileSync36(file, "utf8")), root, process.env);
     for (const [k, v] of Object.entries(added))
       process.env[k] = v;
     return Object.keys(added);
@@ -226468,12 +226965,12 @@ var loadProjectEnv = (cwd = process.cwd()) => {
 };
 
 // src/index.ts
-var STANDALONE = (() => {
-  const dir = dirname21(process.execPath);
+var STANDALONE2 = (() => {
+  const dir = dirname23(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync39(join40(dir, "runtime")) && existsSync39(join40(dir, chisel));
+  return existsSync42(join43(dir, "runtime")) && existsSync42(join43(dir, chisel));
 })();
-var INSTALLED = STANDALONE && (() => {
+var INSTALLED = STANDALONE2 && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
   const self2 = (() => {
     try {
@@ -226486,14 +226983,14 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join40(d, exe);
-      return existsSync39(cand) && realpathSync2(cand) === self2;
+      const cand = join43(d, exe);
+      return existsSync42(cand) && realpathSync2(cand) === self2;
     } catch {
       return false;
     }
   });
 })();
-var INSTALL_HELP = STANDALONE && !INSTALLED ? `
+var INSTALL_HELP = STANDALONE2 && !INSTALLED ? `
   install                       Install this standalone build so 'lecodes' is on your PATH
                                   (copies the bundle to a library folder + a symlink/PATH entry).
                                   --modify-path   also add it to PATH (edits your shell rc / user PATH)
@@ -226580,6 +227077,11 @@ ${c.bold("Commands:")}
                                   -o, --out <file>   write JSON to a file instead of stdout
                                   --png [file]       rasterize a PNG (default screenshot.png;
                                                        needs @napi-rs/canvas)
+                                  --map [file]       draw the 3D scene's annotated top-down map
+                                                       (grid + XZ footprints + named markers) as
+                                                       <file>.png + <file>.json world-space data
+                                                       (default map.png; --label-all, --max-px N;
+                                                       also a { "map": "f.png" } script step)
                                   --script <file>    drive the app through a step list (tap/type/
                                                        scroll/wait/expect/screenshot/json steps;
                                                        games: frames/drag/hold/key/keyDown/keyUp,
@@ -226643,13 +227145,22 @@ ${c.bold("Commands:")}
                                                        render --desktop
                                   (+ the render timing flags: --width/--height, --settle,
                                    --device, --safe-area, --wait-network, --logs, --entry)
-  types [dir]                   Refresh the IDE types (.lecodes/types/ + tsconfig.json) — by
-                                  default from the server, so a project scaffolded offline picks
-                                  up the SDK the platform actually runs
-                                  --local            use the SDK bundled in this CLI instead
-                                  --check            report drift only, don't write (non-zero exit)
-                                  --api <url>        server to fetch from (default: the logged-in
-                                                       one, else https://le.codes)
+  update                        Move everything a project depends on to its newest published
+                                  state, in dependency order: the desktop host ('desktop
+                                  update'), matc ('shaders update'), the project's shader
+                                  compiles, the IDE types (.lecodes/types/ + tsconfig.json,
+                                  from the server — the former 'lecodes types'), the
+                                  ios/android shell pins ('app update'), then the GLOBAL npm
+                                  installs: every installed optional peer (lecodes-renderer,
+                                  lecodes-design, lecodes-3d-editor, lecodes-assets) and this
+                                  CLI that is behind npm's latest gets 'npm install -g'.
+                                  Pinned tools are skipped, not overridden: LECODES_DESKTOP_EXE
+                                  / LECODES_MATC mean a local build. Keeps going when a step
+                                  fails; the summary says which.
+                                  --local            types from the SDK bundled in this CLI
+                                  --no-shells        leave ios/android pins alone (no re-sync)
+                                  --check            npm step: report what's behind, install nothing
+                                  --no-cli           skip the npm step (offline)
   design [serve]                LeCodes Design — a live canvas of screens for AI-driven prototyping
                                   (needs the optional 'lecodes-design' package; works inside a
                                    cloned project or standalone in any folder)
@@ -226706,6 +227217,8 @@ ${c.bold("Commands:")}
                                           --probe        headless-render the staged folder to PNG
                                                          (macOS: a brief windowed run + snapshot)
                                           --zip          also pack the result for sending
+                                          --dmg          macOS: also build a drag-to-Applications
+                                                         disk image (signed + notarized too)
                                           --sign <identity|adhoc>   macOS codesign identity
                                           --notarize <profile> / --no-notarize   macOS
                                           --zip          <out>.zip, UTF-8/forward-slash entries
@@ -226743,6 +227256,13 @@ ${c.bold("Commands:")}
                                   --port <n>         editor-server port (default 4488)
                                   --no-open          don't open the browser
                                   --no-mcp           don't register the MCP server in .mcp.json
+  thumbs [path…]                Asset thumbnails for the scene editor, WITHOUT a browser: decodes
+                                  the project's images (KTX2 too, via KTX-Software's ktx tool) into the
+                                  editor's preview cache. Incremental — the cached name carries the
+                                  asset's content hash, so unchanged files are skipped. Models,
+                                  materials and prefabs are rendered by the editor, not here
+                                  --force            redo even the up-to-date ones
+                                  --size <px>        longest edge (default 256)
   assets convert <model.fbx|.glb> [--clips a.fbx b.fbx …] [-o out.glb] [--drop-model-clips]
                                   [--fix] [--ktx2|--ktx2-hq]
                                 FBX → LeCodes-ready GLB: meters/Y-up, textures embedded, clips from
@@ -226841,35 +227361,10 @@ Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKE
 A .env next to app.json is read at startup for LECODES_* / CREATOR_* keys (the shell's own
 environment wins; ./ paths resolve against the project; the file is never pushed) — e.g.
 LECODES_DESKTOP_EXE, LECODES_MATC, LECODES_NOTARY_PROFILE, LECODES_MACOS_SIGN_ID, LECODES_TOKEN.`;
-var commands = { init: init2, login, create, clone: clone3, link, status: status3, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn, desktop, shaders, assets, lightmap, navmesh };
-if (STANDALONE)
+var commands = { init: init2, login, create, clone: clone3, link, status: status3, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, design, scene, thumbs, dev, app, pn, desktop, shaders, assets, lightmap, navmesh, update };
+if (STANDALONE2)
   commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
-var OPTIONAL_PEERS = [
-  ["lecodes-renderer", "lecodes-renderer/headless"],
-  ["lecodes-design", "lecodes-design/server"],
-  ["lecodes-3d-editor", "lecodes-3d-editor/server"],
-  ["lecodes-assets", "lecodes-assets/cli"]
-];
-var peerVersion = (name, probe) => {
-  try {
-    const require2 = createRequire4(import.meta.url);
-    let dir = dirname21(require2.resolve(probe));
-    for (let depth = 0;depth < 16; depth++) {
-      const manifest = join40(dir, "package.json");
-      if (existsSync39(manifest)) {
-        const parsed = JSON.parse(readFileSync35(manifest, "utf8"));
-        if (parsed.name === name)
-          return parsed.version ?? "unknown";
-      }
-      const parent = dirname21(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
-  } catch {}
-  return null;
-};
 var printVersion = () => {
   const rows = [["lecodes-cli", readVersion()]];
   for (const [name, probe] of OPTIONAL_PEERS) {