lecodes-cli 2.4.8 → 2.4.10

package/dist/index.js

@@ -64,7 +64,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "lecodes-cli",
-    version: "2.4.8",
+    version: "2.4.10",
     dependencies: {
       "@letary/chisel": "^0.15.0",
       jimp: "^1.6.1",
@@ -89,9 +89,9 @@ var init_package = __esm(() => {
     },
     peerDependencies: {
       "lecodes-design": "^0.11.0",
-      "lecodes-headless": "^2.4.8",
+      "lecodes-headless": "^2.4.10",
       "lecodes-3d-editor": "^0.9.0",
-      "lecodes-assets": "^0.2.1",
+      "lecodes-assets": "^2.4.10",
       "heic-decode": "^2.1.0",
       "marcidb-embedded": "^0.15.0",
       sharp: "^0.35.2",
@@ -159,7 +159,7 @@ var init_package = __esm(() => {
 });
 
 // ../../sdk/src/version.ts
-var SDK_VERSION = "2.4.8";
+var SDK_VERSION = "2.4.10";
 
 // src/cli/args.ts
 var isNegativeNumber = (s) => /^-(\d|\.\d)/.test(s), isValue = (s) => !s.startsWith("-") || isNegativeNumber(s), parseArgv = (argv, booleans = new Set) => {
@@ -651,6 +651,94 @@ var init_peers = __esm(() => {
   ];
 });
 
+// src/hosts/releases.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, mkdtempSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+import { spawnSync } from "node:child_process";
+var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json", ARTIFACT_STAMP = ".lecodes-artifact.json", cachedArtifactSha = (dir) => {
+  try {
+    return JSON.parse(readFileSync3(join4(dir, ARTIFACT_STAMP), "utf8")).sha256 ?? null;
+  } catch {
+    return null;
+  }
+}, macPlatformKey = () => process.arch === "arm64" ? "macos-arm64" : "macos-x64", semverNewer = (a, b) => {
+  const pa = a.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
+  for (let i = 0;i < 3; i++)
+    if ((pb[i] ?? 0) !== (pa[i] ?? 0))
+      return (pb[i] ?? 0) - (pa[i] ?? 0);
+  return 0;
+}, newestForPlatform = (versions, key) => {
+  const carrying = versions.filter((v) => v.files[key]).sort((a, b) => semverNewer(a.version, b.version));
+  const newest = carrying[0];
+  return newest ? { version: newest.version, file: newest.files[key] } : null;
+}, fetchReleaseProduct = async (product, label) => {
+  let manifest;
+  try {
+    const res = await fetch(MANIFEST_URL);
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    manifest = await res.json();
+  } catch (e) {
+    throw new CliError(`Can't fetch the release manifest (${MANIFEST_URL}): ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const entry = manifest.products?.[product];
+  if (!entry)
+    throw new CliError(`The release manifest has no ${label} product.`);
+  return entry;
+}, downloadReleaseArchive = async (file, opts) => {
+  let bytes;
+  try {
+    const res = await fetch(file.url);
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    bytes = Buffer.from(await res.arrayBuffer());
+  } catch (e) {
+    throw new CliError(`Download failed (${file.url}): ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const sha = createHash("sha256").update(bytes).digest("hex");
+  if (sha !== file.sha256)
+    throw new CliError(`Downloaded archive is corrupt (sha256 mismatch) — try again.`);
+  mkdirSync2(opts.cacheRoot, { recursive: true });
+  const stage = mkdtempSync(join4(opts.cacheRoot, "dl-"));
+  try {
+    const archiveName = file.url.split("/").pop() ?? "archive";
+    const archive = join4(stage, archiveName);
+    writeFileSync2(archive, bytes);
+    if (opts.extract) {
+      opts.extract(archive, stage);
+    } else {
+      const winTar = join4(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+      const tarExe = process.platform === "win32" && existsSync4(winTar) ? winTar : "tar";
+      const tar = spawnSync(tarExe, ["-xf", archiveName], { cwd: stage, stdio: ["ignore", "ignore", "pipe"] });
+      if (tar.status !== 0)
+        throw new CliError(`Couldn't extract the archive: ${tar.stderr?.toString() ?? "tar failed"}`);
+    }
+    rmSync(archive);
+    const bad = opts.validate(stage);
+    if (bad)
+      throw new CliError(bad);
+    writeFileSync2(join4(stage, ARTIFACT_STAMP), JSON.stringify({ sha256: file.sha256, url: file.url }, null, 2));
+    try {
+      renameSync(stage, opts.dest);
+    } catch {
+      let destBad;
+      try {
+        destBad = opts.validate(opts.dest);
+      } catch {
+        destBad = "missing";
+      }
+      if (destBad)
+        throw new CliError(`Couldn't move the download into ${opts.dest}.`);
+    }
+  } finally {
+    rmSync(stage, { recursive: true, force: true });
+  }
+};
+var init_releases = __esm(() => {
+  init_cli();
+});
+
 // src/hosts/archives.ts
 var ARCHIVED_PEERS, BASE = "https://storage.yandexcloud.net/le-codes/releases/packages", packagesBase = () => (process.env.LECODES_PACKAGES_URL || BASE).replace(/\/$/, ""), archiveUrl = (name, version) => `${packagesBase()}/${name}/${name}-${version}.tgz`, numbers = (version) => version.split(/[.-]/).slice(0, 3).map(Number), byVersion = (a, b) => {
   const pa = numbers(a), pb = numbers(b);
@@ -699,17 +787,17 @@ var init_archives = __esm(() => {
 });
 
 // src/hosts/packageManager.ts
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { homedir as homedir2 } from "node:os";
-import { join as join4, resolve as resolve2, sep } from "node:path";
+import { join as join5, resolve as resolve2, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var onPath = (cmd) => {
   try {
-    return spawnSync(cmd, ["--version"], { stdio: "ignore", shell: process.platform === "win32" }).status === 0;
+    return spawnSync2(cmd, ["--version"], { stdio: "ignore", shell: process.platform === "win32" }).status === 0;
   } catch {
     return false;
   }
-}, bunGlobalDir = () => join4(process.env.BUN_INSTALL ? resolve2(process.env.BUN_INSTALL) : join4(homedir2(), ".bun"), "install", "global"), ownManager = (file = fileURLToPath2(import.meta.url)) => {
+}, bunGlobalDir = () => join5(process.env.BUN_INSTALL ? resolve2(process.env.BUN_INSTALL) : join5(homedir2(), ".bun"), "install", "global"), ownManager = (file = fileURLToPath2(import.meta.url)) => {
   const norm = (p) => process.platform === "win32" ? p.toLowerCase() : p;
   return norm(resolve2(file)).startsWith(norm(bunGlobalDir()) + sep) ? "bun" : "npm";
 }, pickManager = () => {
@@ -720,12 +808,16 @@ var onPath = (cmd) => {
 var init_packageManager = () => {};
 
 // src/hosts/peerInstall.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function loadPeer(name, subpath, opts) {
   const spec = subpath ? `${name}/${subpath}` : name;
+  const byHand = peerVersionGlobal(name, spec);
+  if (olderThanCli(name, byHand)) {
+    throw new CliError(`${name} ${byHand} (installed by hand) is older than this CLI (${package_default.version}) needs — update it: ${commandLine(ownManager(), installGlobalArgv(ownManager(), [await peerSpec(name)]))}`);
+  }
   try {
     return await import(spec);
   } catch (e) {
@@ -733,18 +825,22 @@ async function loadPeer(name, subpath, opts) {
       throw e;
   }
   const dir = peerDirInPrefix(name);
-  if (!existsSync4(join5(dir, "package.json"))) {
+  const installed = peerVersionPrefix(name);
+  const stale = olderThanCli(name, installed);
+  if (installed === null || stale) {
     if (opts.install === false)
       return null;
-    if (peerVersionGlobal(name, spec) !== null)
+    if (installed === null && peerVersionGlobal(name, spec) !== null)
       throw new CliError(`${name} is installed but "${spec}" can't be loaded from it — reinstall it: ${commandLine(ownManager(), installGlobalArgv(ownManager(), [await peerSpec(name)]))}`);
+    if (stale)
+      note(`${name} ${installed} in ${peersDir()} is older than this CLI (${package_default.version}) — installing the one it needs`);
     await installPeers(companions(name), opts.for);
   }
   return await import(pathToFileURL(resolveEntry(dir, subpath)).href);
 }
 var CANVAS_RANGE_FALLBACK = "^0.1.65", readJson = (path) => {
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return null;
   }
@@ -753,7 +849,7 @@ var CANVAS_RANGE_FALLBACK = "^0.1.65", readJson = (path) => {
   if (archive)
     return archive;
   if (name === "@napi-rs/canvas") {
-    const renderer = readJson(join5(peerDirInPrefix("lecodes-headless"), "package.json"));
+    const renderer = readJson(join6(peerDirInPrefix("lecodes-headless"), "package.json"));
     const range = renderer?.peerDependencies?.["@napi-rs/canvas"] ?? renderer?.optionalDependencies?.["@napi-rs/canvas"] ?? CANVAS_RANGE_FALLBACK;
     return `@napi-rs/canvas@${range}`;
   }
@@ -761,10 +857,10 @@ var CANVAS_RANGE_FALLBACK = "^0.1.65", readJson = (path) => {
   return range ? `${name}@${range}` : `${name}@latest`;
 }, companions = (name) => name === "lecodes-headless" ? ["lecodes-headless", "@napi-rs/canvas"] : name === "sharp" ? ["sharp", "heic-decode"] : [name], manualCommand = (dir, specs) => commandLine(ownManager(), installIntoArgv(ownManager(), dir, specs)), installPeers = async (names, why, opts = {}) => {
   const dir = peersDir();
-  mkdirSync2(dir, { recursive: true });
-  const manifest = join5(dir, "package.json");
-  if (!existsSync4(manifest)) {
-    writeFileSync2(manifest, JSON.stringify({
+  mkdirSync3(dir, { recursive: true });
+  const manifest = join6(dir, "package.json");
+  if (!existsSync5(manifest)) {
+    writeFileSync3(manifest, JSON.stringify({
       name: "lecodes-peers",
       private: true,
       description: "Optional lecodes-cli peers, installed on first use. Safe to delete — the CLI re-installs what a command needs."
@@ -792,16 +888,16 @@ var CANVAS_RANGE_FALLBACK = "^0.1.65", readJson = (path) => {
     const spec = await peerSpec(name);
     const argv = installIntoArgv(tool, dir, [spec]);
     note(`$ ${tool} ${argv.join(" ")}`);
-    const r = spawnSync2(tool, argv, { stdio: "inherit", shell: process.platform === "win32", timeout: 10 * 60000 });
+    const r = spawnSync3(tool, argv, { stdio: "inherit", shell: process.platform === "win32", timeout: 10 * 60000 });
     if (r.error)
       throw new CliError(`${tool} could not run: ${r.error.message}`);
     if (r.status !== 0)
       throw new CliError(`${tool} exited with ${r.status ?? "a signal"} while installing ${spec}. By hand:  ${manualCommand(dir, [spec])}`);
-    if (!existsSync4(join5(peerDirInPrefix(name), "package.json")))
+    if (!existsSync5(join6(peerDirInPrefix(name), "package.json")))
       throw new CliError(`${name} did not land in ${dir} — the installer finished but the package is missing`);
   }
 }, resolveEntry = (pkgDir, subpath) => {
-  const manifest = readJson(join5(pkgDir, "package.json"));
+  const manifest = readJson(join6(pkgDir, "package.json"));
   if (!manifest)
     throw new CliError(`${pkgDir} holds no package.json`);
   const key = subpath ? `./${subpath}` : ".";
@@ -829,8 +925,8 @@ var CANVAS_RANGE_FALLBACK = "^0.1.65", readJson = (path) => {
     rel = typeof manifest.main === "string" ? manifest.main : "index.js";
   if (!rel)
     throw new CliError(`${manifest.name} has no export "${key}"`);
-  return join5(pkgDir, rel);
-}, isNotFound = (e, spec) => {
+  return join6(pkgDir, rel);
+}, SET_ON_NPM, olderThanCli = (name, version) => SET_ON_NPM.has(name) && version !== null && semverNewer(version, package_default.version) > 0, isNotFound = (e, spec) => {
   const code = e?.code;
   const msg = e instanceof Error ? e.message : String(e);
   return (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || /Cannot find (module|package)/i.test(msg)) && msg.includes(spec.split("/")[0]);
@@ -838,9 +934,11 @@ var CANVAS_RANGE_FALLBACK = "^0.1.65", readJson = (path) => {
 var init_peerInstall = __esm(() => {
   init_package();
   init_peers();
+  init_releases();
   init_archives();
   init_packageManager();
   init_cli();
+  SET_ON_NPM = new Set(["lecodes-assets"]);
 });
 
 // ../../sdk/src/compile/resourceSlots.ts
@@ -880,13 +978,7 @@ var init_resourceSlots = __esm(() => {
       "map",
       "shader",
       "build",
-      "data",
-      "light",
-      "aux",
-      "direct",
-      "indirect",
-      "probes",
-      "volume"
+      "data"
     ]
   };
 });
@@ -1146,6 +1238,520 @@ var init_assetMacro = __esm(() => {
   SET_TARGET = /\.\s*([A-Za-z_$][\w$]*)\s*$/;
 });
 
+// ../../sdk/src/compile/assetIconMacro.ts
+var ICON_ID, isIdentStart = (c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c === "$", isIdentPart = (c) => isIdentStart(c) || c >= "0" && c <= "9", skipString = (src, start) => {
+  const quote = src[start];
+  const n = src.length;
+  let i = start + 1;
+  while (i < n) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (quote === "`" && c === "$" && src[i + 1] === "{") {
+      i = skipBraces(src, i + 1);
+      continue;
+    }
+    if (c === quote)
+      return i + 1;
+    i++;
+  }
+  return n;
+}, skipBraces = (src, open) => {
+  const n = src.length;
+  let depth = 0;
+  let i = open;
+  while (i < n) {
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0)
+        return i + 1;
+    }
+    i++;
+  }
+  return n;
+}, matchParen = (src, open) => {
+  const n = src.length;
+  let depth = 0;
+  let i = open;
+  while (i < n) {
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "/") {
+      i += 2;
+      while (i < n && src[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (c === "(")
+      depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  return -1;
+}, splitTopLevel = (text, delim) => {
+  const parts = [];
+  const n = text.length;
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < n) {
+    const c = text[i];
+    if (c === '"' || c === "'" || c === "`") {
+      i = skipString(text, i);
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}")
+      depth = Math.max(0, depth - 1);
+    else if (depth === 0 && c === delim) {
+      parts.push(text.slice(last, i));
+      last = i + 1;
+    }
+    i++;
+  }
+  parts.push(text.slice(last));
+  return parts;
+}, stringLiteralValue = (text) => {
+  const t = text.trim();
+  if (t.length < 2)
+    return null;
+  const q = t[0];
+  if (q !== '"' && q !== "'" && q !== "`" || t[t.length - 1] !== q)
+    return null;
+  const inner = t.slice(1, -1);
+  if (q === "`" && inner.includes("${"))
+    return null;
+  if (inner.includes(q) && !inner.includes("\\" + q))
+    return null;
+  return inner.replace(/\\(.)/g, "$1");
+}, scanAssetIconCalls = (source) => {
+  const calls = [];
+  const n = source.length;
+  let i = 0;
+  while (i < n) {
+    const c = source[i];
+    if (c === '"' || c === "'" || c === "`") {
+      i = skipString(source, i);
+      continue;
+    }
+    if (c === "/" && source[i + 1] === "/") {
+      i += 2;
+      while (i < n && source[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (c === "/" && source[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(source[i] === "*" && source[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (isIdentStart(c)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(source[j]))
+        j++;
+      if (source.slice(i, j) === "assetIcon" && prevNonSpace(source, i) !== ".") {
+        const call = parseCall(source, i, j);
+        if (call) {
+          calls.push(call);
+          i = call.end;
+          continue;
+        }
+      }
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return calls;
+}, prevNonSpace = (src, i) => {
+  let k = i - 1;
+  while (k >= 0 && /\s/.test(src[k]))
+    k--;
+  return k >= 0 ? src[k] : "";
+}, parseCall = (src, start, identEnd) => {
+  const n = src.length;
+  let i = identEnd;
+  while (i < n && /\s/.test(src[i]))
+    i++;
+  if (src[i] !== "(")
+    return null;
+  const close = matchParen(src, i);
+  if (close === -1)
+    return null;
+  const call = { start, end: close + 1, id: "", pack: "", name: "" };
+  const args = splitTopLevel(src.slice(i + 1, close), ",");
+  const id = stringLiteralValue(args[0] ?? "");
+  if (id === null) {
+    call.error = `assetIcon(...) needs a string-literal id like "lucide:bell" (got \`${(args[0] ?? "").trim() || "()"}\`).`;
+    return call;
+  }
+  const m = ICON_ID.exec(id);
+  if (!m) {
+    call.error = `assetIcon("${id}"): id must be "pack:name", lowercase [a-z0-9-] (e.g. "lucide:bell").`;
+    return call;
+  }
+  call.id = id;
+  call.pack = m[1];
+  call.name = m[2];
+  const optsText = args[1]?.trim();
+  if (optsText) {
+    const color = extractColor(optsText);
+    if (color.error) {
+      call.error = color.error;
+      return call;
+    }
+    if (color.bake !== undefined)
+      call.bake = color.bake;
+    else if (color.tint !== undefined)
+      call.tint = color.tint;
+  }
+  return call;
+}, extractColor = (optsText) => {
+  if (!optsText.startsWith("{") || !optsText.endsWith("}")) {
+    return { error: `assetIcon(id, opts): opts must be an object literal like { color: "#5b8cff" }.` };
+  }
+  for (const prop of splitTopLevel(optsText.slice(1, -1), ",")) {
+    const kv = splitTopLevel(prop, ":");
+    if (kv.length < 2)
+      continue;
+    const key = kv[0].trim().replace(/^["'`]|["'`]$/g, "");
+    if (key !== "color")
+      continue;
+    const raw = kv.slice(1).join(":").trim();
+    if (!raw)
+      continue;
+    const literal = stringLiteralValue(raw);
+    return literal !== null ? { bake: literal } : { tint: raw };
+  }
+  return {};
+}, rewriteAssetIcons = (source, calls, svgById) => {
+  let out = source;
+  for (const call of [...calls].sort((a, b) => b.start - a.start)) {
+    const svg = svgById.get(call.id);
+    if (svg === undefined)
+      continue;
+    out = out.slice(0, call.start) + iconExpr(svg, call) + out.slice(call.end);
+  }
+  return out;
+}, iconExpr = (svg, call) => {
+  const body = call.bake ? svg.split("currentColor").join(call.bake) : svg;
+  const src = `SvgSource(\`${escapeTemplate(body)}\`)`;
+  return call.tint ? `Object.assign(${src}, { tintColor: (${call.tint}) })` : src;
+}, escapeTemplate = (s) => s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), applyAssetIconMacro = async (entries, resolveSvgs) => {
+  const scanned = entries.filter((e) => e.type === "text" && typeof e.text === "string" && e.text.includes("assetIcon")).map((e) => ({ entry: e, calls: scanAssetIconCalls(e.text) })).filter((s) => s.calls.length > 0);
+  if (scanned.length === 0)
+    return [];
+  const errors = scanned.flatMap((s) => s.calls.filter((c) => c.error).map((c) => c.error));
+  if (errors.length)
+    throw new Error([...new Set(errors)].join(`
+`));
+  const ids = [...new Set(scanned.flatMap((s) => s.calls.map((c) => c.id)))];
+  const svgById = await resolveSvgs(ids);
+  const missing = ids.filter((id) => !svgById.has(id));
+  if (missing.length)
+    throw new Error(`assetIcon: could not resolve icon(s): ${missing.join(", ")}.`);
+  for (const { entry, calls } of scanned)
+    entry.text = rewriteAssetIcons(entry.text, calls, svgById);
+  return ids;
+}, buildIconsHeaderValue = (ids) => [...new Set(ids.map((id) => id.split(":")[0]))].sort().join(";"), editDistance = (a, b, cap) => {
+  if (Math.abs(a.length - b.length) > cap)
+    return cap + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1;i <= a.length; i++) {
+    const cur = [i];
+    let rowMin = i;
+    for (let j = 1;j <= b.length; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+      if (cur[j] < rowMin)
+        rowMin = cur[j];
+    }
+    if (rowMin > cap)
+      return cap + 1;
+    prev = cur;
+  }
+  return prev[b.length];
+}, suggestIconNames = (want, icons) => {
+  const wantParts = new Set(want.split("-").filter(Boolean));
+  const scored = [];
+  for (const [name, info] of Object.entries(icons)) {
+    const lenDiff = Math.abs(name.length - want.length) / 100;
+    let rank;
+    if (name.includes(want) || want.includes(name))
+      rank = lenDiff;
+    else {
+      const d = editDistance(want, name, 2);
+      if (d <= 2)
+        rank = 1 + d;
+      else if (info.kw?.some((k) => wantParts.has(k)))
+        rank = 4 + lenDiff;
+      else
+        continue;
+    }
+    scored.push({ name, rank });
+  }
+  return scored.sort((a, b) => a.rank - b.rank || (a.name < b.name ? -1 : 1)).slice(0, 5).map((s) => s.name);
+}, iconNotFoundError = async (pack, name, read, registry) => {
+  const metaRaw = await read(`${pack}/meta.json`);
+  if (metaRaw !== null) {
+    let icons = {};
+    try {
+      icons = JSON.parse(metaRaw).icons ?? {};
+    } catch {}
+    const similar = suggestIconNames(name, icons);
+    const hint = similar.length ? ` Did you mean ${similar.map((s) => `"${pack}:${s}"`).join(", ")}?` : ` No similar name in the "${pack}" pack either.`;
+    return new Error(`assetIcon: icon "${pack}:${name}" not found.${hint}`);
+  }
+  const licRaw = await read("licenses.json");
+  if (licRaw !== null) {
+    try {
+      const packs = Object.keys(JSON.parse(licRaw)).sort();
+      return new Error(`assetIcon: unknown icon pack "${pack}" (in "${pack}:${name}"). Available packs: ${packs.join(", ")}.`);
+    } catch {}
+  }
+  return Object.assign(new Error(`assetIcon: can't reach the icon registry${registry ? ` (${registry})` : ""} to resolve "${pack}:${name}". ` + `Check your connection, or set LECODES_ICON_REGISTRY.`), { transient: true });
+}, VENDORED_ICON_PATH, collectVendoredIcons = (entries) => {
+  const map = new Map;
+  for (const e of entries) {
+    if (e.type !== "text" || typeof e.text !== "string")
+      continue;
+    const m = VENDORED_ICON_PATH.exec(e.path);
+    if (m)
+      map.set(`${m[1]}:${m[2]}`, e.text);
+  }
+  return map;
+};
+var init_assetIconMacro = __esm(() => {
+  ICON_ID = /^([a-z0-9]+(?:-[a-z0-9]+)*):([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+  VENDORED_ICON_PATH = /(?:^|\/)assets\/icons\/([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)\.svg$/;
+});
+
+// ../../sdk/src/compile/bakeMacro.ts
+var BAKE_CALL, DECLARES_BAKE, DEFINITION_TAIL, hasBakeMacro = (src) => src.includes("bake"), stringLiteralValue2 = (text) => {
+  const t = text.trim();
+  if (t.length < 2)
+    return null;
+  const q = t[0];
+  if (q !== '"' && q !== "'" && q !== "`" || t[t.length - 1] !== q)
+    return null;
+  const inner = t.slice(1, -1);
+  if (q === "`" && inner.includes("${"))
+    return null;
+  if (/[\r\n]/.test(inner))
+    return null;
+  for (let i = 0;i < inner.length; i++) {
+    if (inner[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (inner[i] === q)
+      return null;
+  }
+  return inner.replace(/\\(.)/g, "$1");
+}, closeOf = (mask, open) => {
+  let depth = 0;
+  for (let i = open;i < mask.length; i++) {
+    const c = mask[i];
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return -1;
+}, argSpans = (mask, open, close) => {
+  const spans = [];
+  let depth = 0;
+  let start = open + 1;
+  for (let i = open + 1;i < close; i++) {
+    const c = mask[i];
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}")
+      depth--;
+    else if (c === "," && depth === 0) {
+      spans.push([start, i]);
+      start = i + 1;
+    }
+  }
+  spans.push([start, close]);
+  return spans;
+}, newlines = (s) => {
+  let n = 0;
+  for (let i = 0;i < s.length; i++)
+    if (s[i] === `
+`)
+      n++;
+  return n;
+}, stringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null, readManifest2 = (json) => {
+  if (!json || typeof json !== "object")
+    return null;
+  const m = json;
+  const light = stringArray(m.light), aux = stringArray(m.aux);
+  if (!light || !aux)
+    return null;
+  const file = (v) => typeof v === "string" && v !== "" ? v : v && typeof v === "object" && typeof v.file === "string" ? v.file : undefined;
+  return {
+    light,
+    aux,
+    direct: stringArray(m.direct) ?? undefined,
+    indirect: stringArray(m.indirect) ?? undefined,
+    probes: file(m.probes),
+    volume: file(m.volume),
+    uv1: file(m.uv1)
+  };
+}, expandBakeMacros = async (src, filePath, exists, read) => {
+  if (!hasBakeMacro(src))
+    return { src, bakes: [] };
+  const strings = [];
+  const mask = maskNonCode(src, (s, e) => {
+    strings.push([s, e]);
+  });
+  if (DECLARES_BAKE.test(mask))
+    return { src, bakes: [] };
+  const stringsIn = ([a, b]) => strings.filter(([s, e]) => s >= a && e <= b);
+  const blankArg = (span) => mask.slice(span[0], span[1]).trim() === "" && stringsIn(span).length === 0;
+  const literalOf = (span) => {
+    const inside = stringsIn(span);
+    if (inside.length === 1 && mask.slice(span[0], span[1]).trim() === "")
+      return src.slice(inside[0][0], inside[0][1]);
+    return src.slice(span[0], span[1]).trim();
+  };
+  const dir = filePath.slice(0, filePath.lastIndexOf("/"));
+  const at = (index) => `${filePath.replace(/^\//, "")}:${newlines(src.slice(0, index)) + 1}`;
+  const bakes = [];
+  const parts = [];
+  let done = 0;
+  for (const m of mask.matchAll(BAKE_CALL)) {
+    const start = m.index ?? 0;
+    if (start < done)
+      continue;
+    const open = start + m[0].length - 1;
+    const close = closeOf(mask, open);
+    if (close < 0)
+      throw new Error(`bake(): unclosed call (${at(start)})`);
+    const spans = argSpans(mask, open, close);
+    const pathText = literalOf(spans[0]);
+    const written = stringLiteralValue2(pathText);
+    if (written === null && DEFINITION_TAIL.test(mask.slice(close + 1, close + 160)))
+      continue;
+    if (written === null)
+      throw new Error(`bake() expects a string-literal path like bake('./assets/lightmap/level.bake'), found \`${pathText || "()"}\` (${at(start)})`);
+    if (!/\.bake$/i.test(written))
+      throw new Error(`bake('${written}'): the path names a .bake file — what \`lecodes lightmap bake\` writes (${at(start)})`);
+    if (spans.slice(2).some((s) => !blankArg(s)))
+      throw new Error(`bake('${written}'): one path and one options object at most (${at(start)})`);
+    let options = null;
+    if (spans.length > 1 && !blankArg(spans[1])) {
+      const [a, b] = spans[1];
+      const code = mask.slice(a, b);
+      const lead = a + (code.length - code.trimStart().length);
+      const tail = b - (code.length - code.trimEnd().length);
+      if (mask[lead] !== "{" || closeOf(mask, lead) !== tail - 1) {
+        throw new Error(`bake('${written}', options): options must be an object literal like { emissiveBake: false } (${at(start)})`);
+      }
+      options = [lead, tail];
+    }
+    const relative = written.startsWith("./") || written.startsWith("../");
+    const rooted = written.startsWith("/");
+    const candidates = rooted ? [normalizePath(written)] : relative ? [normalizePath(`${dir}/${written}`), normalizePath(written)] : [normalizePath(written), normalizePath(`${dir}/${written}`)];
+    const found = candidates.find(exists);
+    const target = found ?? candidates[0];
+    const ref = { path: target.slice(1), exists: found !== undefined, line: newlines(src.slice(0, start)) + 1, written, missing: [] };
+    let manifest = null;
+    if (found !== undefined) {
+      const body = read ? await read(found) : null;
+      if (body === null)
+        ref.unread = true;
+      else {
+        let json;
+        try {
+          json = JSON.parse(body.replace(/^\uFEFF/, ""));
+        } catch (e) {
+          throw new Error(`bake('${written}'): ${ref.path} is not a bake manifest (${e instanceof Error ? e.message : String(e)}) — rebake with \`lecodes lightmap bake\` (${at(start)})`);
+        }
+        manifest = readManifest2(json);
+        if (!manifest)
+          throw new Error(`bake('${written}'): ${ref.path} is not a bake manifest (no light / aux pages) — rebake with \`lecodes lightmap bake\` (${at(start)})`);
+      }
+    }
+    const bakeDir = target.slice(0, target.lastIndexOf("/"));
+    const ref1 = (name) => {
+      const p = normalizePath(`${bakeDir}/${name}`);
+      if (!exists(p) && !ref.missing.includes(p))
+        ref.missing.push(p);
+      return `asset(${JSON.stringify(p)})`;
+    };
+    const list = (names) => `[${names.map(ref1).join(", ")}]`;
+    const fields = [`path: \`${escapeTemplate(ref.path)}\``];
+    if (manifest) {
+      fields.unshift(`data: asset(${JSON.stringify(target)})`);
+      fields.push(`light: ${list(manifest.light)}`, `aux: ${list(manifest.aux)}`);
+      if (manifest.direct)
+        fields.push(`direct: ${list(manifest.direct)}`);
+      if (manifest.indirect)
+        fields.push(`indirect: ${list(manifest.indirect)}`);
+      if (manifest.probes)
+        fields.push(`probes: ${ref1(manifest.probes)}`);
+      if (manifest.volume)
+        fields.push(`volume: ${ref1(manifest.volume)}`);
+      if (manifest.uv1)
+        fields.push(`uv1: ${ref1(manifest.uv1)}`);
+    } else {
+      fields.unshift("data: null");
+      fields.push("light: []", "aux: []");
+    }
+    const head = `{ ${fields.join(", ")}`;
+    const expansion = options ? `${head}, ${`
+`.repeat(newlines(src.slice(start, options[0])))}...${src.slice(options[0], options[1])}${`
+`.repeat(newlines(src.slice(options[1], close + 1)))} }` : `${head}${`
+`.repeat(newlines(src.slice(start, close + 1)))} }`;
+    parts.push(src.slice(done, start), expansion);
+    done = close + 1;
+    bakes.push(ref);
+  }
+  if (bakes.length === 0)
+    return { src, bakes };
+  parts.push(src.slice(done));
+  return { src: parts.join(""), bakes };
+};
+var init_bakeMacro = __esm(() => {
+  init_assetMacro();
+  init_assetIconMacro();
+  BAKE_CALL = /(?<![.\w$])bake\s*\(/g;
+  DECLARES_BAKE = /\b(?:function|const|let|var|class)\s+bake\b|\bimport\s+(?:\{[^}]*\bbake\b[^}]*\}|bake)\s+from\b/;
+  DEFINITION_TAIL = /^\s*(?::[^;{}=()\n]*)?(?:\{|=>)/;
+});
+
 // ../../sdk/src/compile/detectEntry.ts
 var ENTRY_CONVENTION = "/main.ts", isCode = (path) => /\.[tj]s$/.test(path) && !path.endsWith(".d.ts"), isNonEntry = (path) => path.endsWith(".editor.ts") || /\.server\.[tj]s$/.test(path) || /^\/design\//.test(path), normalize = (path) => {
   const parts = [];
@@ -1242,7 +1848,7 @@ var HEAD_RE, hasAspectExtends = (src) => /\bextends\s+(?:Aspect|System)\s*</.tes
   for (;i < src.length && angle > 0; i++) {
     const c = src[i];
     if (c === '"' || c === "'" || c === "`") {
-      i = skipString(src, i) - 1;
+      i = skipString2(src, i) - 1;
       continue;
     }
     if (c === "=" && src[i + 1] === ">") {
@@ -1269,7 +1875,7 @@ var HEAD_RE, hasAspectExtends = (src) => /\bextends\s+(?:Aspect|System)\s*</.tes
       return -1;
   }
   return -1;
-}, skipString = (src, at) => {
+}, skipString2 = (src, at) => {
   const q = src[at];
   let i = at + 1;
   for (;i < src.length; i++) {
@@ -1533,18 +2139,18 @@ var init_chisel = __esm(() => {
 });
 
 // ../../sdk/src/compile/bundler.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync5, statSync } from "node:fs";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname4, join as join6, relative } from "node:path";
+import { dirname as dirname4, join as join7, relative } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var resolveInject = () => {
   const override = process.env.LECODES_SDK_INJECT;
-  if (override && existsSync5(override))
+  if (override && existsSync6(override))
     return override;
   const here = dirname4(fileURLToPath3(import.meta.url));
-  const src = join6(here, "..", "inject.ts");
-  if (existsSync5(src))
+  const src = join7(here, "..", "inject.ts");
+  if (existsSync6(src))
     return src;
   throw new Error("sdk: could not locate the inject source (LECODES_SDK_INJECT / src/inject.ts)");
 }, normalize2 = (path) => {
@@ -1560,7 +2166,7 @@ var resolveInject = () => {
   return "/" + parts.join("/");
 }, CHISEL_DEFINE, CHISEL_KEEP, CLIENT_INJECT = "/__sdk/inject.ts", SERVER_INJECT = "/__sdk/server/inject.ts", EDITOR_INJECT = "/__sdk/inject.editor.ts", readInjectSources = () => {
   const client = resolveInject();
-  return { client: readFileSync4(client, "utf8"), server: readFileSync4(join6(dirname4(client), "server", "inject.ts"), "utf8") };
+  return { client: readFileSync5(client, "utf8"), server: readFileSync5(join7(dirname4(client), "server", "inject.ts"), "utf8") };
 }, resolveSdkSrc = () => {
   const inject = resolveInject();
   if (!inject.endsWith("inject.ts")) {
@@ -1574,11 +2180,11 @@ var resolveInject = () => {
   const out = {};
   const walk = (dir) => {
     for (const name of readdirSync(dir)) {
-      const p = join6(dir, name);
+      const p = join7(dir, name);
       if (statSync(p).isDirectory())
         walk(p);
       else if (isSdkSource(p))
-        out["/__sdk/" + relative(sdkSrc, p).split("\\").join("/")] = readFileSync4(p, "utf8");
+        out["/__sdk/" + relative(sdkSrc, p).split("\\").join("/")] = readFileSync5(p, "utf8");
     }
   };
   walk(sdkSrc);
@@ -1587,13 +2193,13 @@ var resolveInject = () => {
 }, resolveChiselBin = () => {
   const override = process.env.LECODES_CHISEL_BIN;
   if (override) {
-    if (existsSync5(override))
+    if (existsSync6(override))
       return override;
     throw new Error(`LECODES_CHISEL_BIN points at a missing file: ${override}`);
   }
   try {
     const bin = createRequire3(import.meta.url)("@letary/chisel").binaryPath();
-    if (bin && existsSync5(bin))
+    if (bin && existsSync6(bin))
       return bin;
   } catch {}
   throw new Error("chisel binary not found. Install @letary/chisel, or set LECODES_CHISEL_BIN.");
@@ -1605,7 +2211,7 @@ var resolveInject = () => {
     return null;
   }
   const input = JSON.stringify({ scan: true, files });
-  const r = spawnSync3(bin, [], { input, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  const r = spawnSync4(bin, [], { input, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
   if (r.status !== 0 || r.error)
     return null;
   try {
@@ -1646,11 +2252,13 @@ var resolveInject = () => {
   if (missing.length > 0)
     throw new Error(missing.join(`
 `));
-}, bundleProjectChisel = async (entrypoint, files, format, sourcemap, minifyOverride, editor, libraries, inject = CLIENT_INJECT) => {
+}, bundleProjectChisel = async (entrypoint, files, format, sourcemap, minifyOverride, editor, libraries, inject = CLIENT_INJECT, readResource) => {
   const entry = normalize2(entrypoint);
   const slugs = new Set(Object.keys(libraries ?? {}));
+  const rootKeys = new Map(Object.keys(files).map((k) => [normalize2(k), k]));
   const projFiles = {};
   const assetRefs = [];
+  const bakeRefs = [];
   const scanSources = {};
   for (const [k, v] of Object.entries(files)) {
     const path = normalize2(k);
@@ -1659,6 +2267,12 @@ var resolveInject = () => {
       if (hasImportStatement(src))
         src = rewriteLibraryImports(src, slugs);
       scanSources[path] = src;
+      if (hasBakeMacro(src)) {
+        const expanded = await expandBakeMacros(src, path, (rootPath) => rootKeys.has(rootPath), readResource);
+        for (const ref of expanded.bakes)
+          bakeRefs.push({ file: path, ref });
+        src = expanded.src;
+      }
       const macros = hasAssetMacro(src) ? collectAssetMacros(src, path) : [];
       const paths = collectPathLiterals(src, path, (rootPath) => files[rootPath] !== undefined, macros);
       const found = macros.concat(paths).sort((a, b) => a.index - b.index);
@@ -1692,8 +2306,22 @@ var resolveInject = () => {
       projFiles[path] = src;
     }
   }
-  if (assetRefs.length > 0) {
+  const bakes = [];
+  const notes = [];
+  if (assetRefs.length > 0 || bakeRefs.length > 0) {
     const reachable = reachableFrom(entry, scanSources);
+    const reached = bakeRefs.filter(({ file }) => reachable.has(file));
+    const incomplete = reached.filter(({ ref }) => ref.missing.length > 0);
+    if (incomplete.length > 0) {
+      throw new Error(incomplete.map(({ file, ref }) => `bake('${ref.written}') (${file.replace(/^\//, "")}:${ref.line}): ${ref.path} names files that are not there: ${ref.missing.map((p) => p.replace(/^\//, "")).join(", ")} — rebake with \`lecodes lightmap bake\``).join(`
+`));
+    }
+    for (const { file, ref } of reached) {
+      if (!bakes.some((b) => b.path === ref.path))
+        bakes.push({ path: ref.path, exists: ref.exists });
+      if (ref.unread)
+        notes.push(`${file.replace(/^\//, "")}:${ref.line}: bake('${ref.written}'): this compile cannot read ${ref.path} — the level runs unbaked`);
+    }
     assertAssetsExist(assetRefs.filter(({ file }) => reachable.has(file)), projFiles);
   }
   const sdkFiles = collectSdkFiles(resolveSdkSrc());
@@ -1713,7 +2341,7 @@ var resolveInject = () => {
     vocab: chiselVocab
   });
   const bin = resolveChiselBin();
-  const r = spawnSync3(bin, [], { input, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  const r = spawnSync4(bin, [], { input, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
   if (r.status === 2 || r.error) {
     throw new Error(`chisel failed: ${r.error?.message ?? r.stderr ?? "unknown error"}`);
   }
@@ -1727,13 +2355,14 @@ var resolveInject = () => {
     throw new Error(`chisel: ${parsed.error}`);
   if (parsed.code == null)
     throw new Error("chisel produced no code");
-  const diagnostics = parsed.diagnostics ?? [];
+  const diagnostics = [...notes, ...parsed.diagnostics ?? []];
   for (const d of diagnostics)
     console.warn(`warning: ${d}`);
-  return { code: parsed.code, map: parsed.map ?? null, diagnostics };
-}, bundleProjectWithMap = async (entrypoint, files, format = "esm", minify, editor, libraries, sourcemap = true, inject) => bundleProjectChisel(entrypoint, files, format, sourcemap, minify, editor, libraries, inject);
+  return { code: parsed.code, map: parsed.map ?? null, diagnostics, bakes };
+}, bundleProjectWithMap = async (entrypoint, files, format = "esm", minify, editor, libraries, sourcemap = true, inject, readResource) => bundleProjectChisel(entrypoint, files, format, sourcemap, minify, editor, libraries, inject, readResource);
 var init_bundler = __esm(() => {
   init_assetMacro();
+  init_bakeMacro();
   init_detectEntry();
   init_aspectMacro();
   init_libraryImports();
@@ -170839,6 +171468,18 @@ var init_shaderSchema = __esm(() => {
   COLOR_NAME = /colou?r|tint|albedo|emissive|glare|glow/i;
 });
 
+// ../../sdk/src/compile/sourcemap.ts
+var offsetSourceMap = (mapJson, lines) => {
+  if (lines <= 0)
+    return mapJson;
+  const map = JSON.parse(mapJson);
+  map.mappings = ";".repeat(lines) + map.mappings;
+  return JSON.stringify(map);
+}, inlineSourceMapComment = (mapJson) => {
+  const b64 = Buffer.from(mapJson, "utf8").toString("base64");
+  return `//# lecodesMap=data:application/json;charset=utf-8;base64,${b64}`;
+};
+
 // ../../sdk/src/compile/header.ts
 var ENGINE_SIGNALS, buildHeader = (name, code, opts = {}) => {
   let header = `// sdk: ${SDK_VERSION}
@@ -170904,333 +171545,6 @@ var init_header = __esm(() => {
   ];
 });
 
-// ../../sdk/src/compile/sourcemap.ts
-var offsetSourceMap = (mapJson, lines) => {
-  if (lines <= 0)
-    return mapJson;
-  const map = JSON.parse(mapJson);
-  map.mappings = ";".repeat(lines) + map.mappings;
-  return JSON.stringify(map);
-}, inlineSourceMapComment = (mapJson) => {
-  const b64 = Buffer.from(mapJson, "utf8").toString("base64");
-  return `//# lecodesMap=data:application/json;charset=utf-8;base64,${b64}`;
-};
-
-// ../../sdk/src/compile/assetIconMacro.ts
-var ICON_ID, isIdentStart = (c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_" || c === "$", isIdentPart = (c) => isIdentStart(c) || c >= "0" && c <= "9", skipString2 = (src, start) => {
-  const quote = src[start];
-  const n = src.length;
-  let i = start + 1;
-  while (i < n) {
-    const c = src[i];
-    if (c === "\\") {
-      i += 2;
-      continue;
-    }
-    if (quote === "`" && c === "$" && src[i + 1] === "{") {
-      i = skipBraces(src, i + 1);
-      continue;
-    }
-    if (c === quote)
-      return i + 1;
-    i++;
-  }
-  return n;
-}, skipBraces = (src, open) => {
-  const n = src.length;
-  let depth = 0;
-  let i = open;
-  while (i < n) {
-    const c = src[i];
-    if (c === '"' || c === "'" || c === "`") {
-      i = skipString2(src, i);
-      continue;
-    }
-    if (c === "{")
-      depth++;
-    else if (c === "}") {
-      depth--;
-      if (depth === 0)
-        return i + 1;
-    }
-    i++;
-  }
-  return n;
-}, matchParen = (src, open) => {
-  const n = src.length;
-  let depth = 0;
-  let i = open;
-  while (i < n) {
-    const c = src[i];
-    if (c === '"' || c === "'" || c === "`") {
-      i = skipString2(src, i);
-      continue;
-    }
-    if (c === "/" && src[i + 1] === "/") {
-      i += 2;
-      while (i < n && src[i] !== `
-`)
-        i++;
-      continue;
-    }
-    if (c === "/" && src[i + 1] === "*") {
-      i += 2;
-      while (i < n && !(src[i] === "*" && src[i + 1] === "/"))
-        i++;
-      i += 2;
-      continue;
-    }
-    if (c === "(")
-      depth++;
-    else if (c === ")") {
-      depth--;
-      if (depth === 0)
-        return i;
-    }
-    i++;
-  }
-  return -1;
-}, splitTopLevel = (text, delim) => {
-  const parts = [];
-  const n = text.length;
-  let depth = 0;
-  let last = 0;
-  let i = 0;
-  while (i < n) {
-    const c = text[i];
-    if (c === '"' || c === "'" || c === "`") {
-      i = skipString2(text, i);
-      continue;
-    }
-    if (c === "(" || c === "[" || c === "{")
-      depth++;
-    else if (c === ")" || c === "]" || c === "}")
-      depth = Math.max(0, depth - 1);
-    else if (depth === 0 && c === delim) {
-      parts.push(text.slice(last, i));
-      last = i + 1;
-    }
-    i++;
-  }
-  parts.push(text.slice(last));
-  return parts;
-}, stringLiteralValue = (text) => {
-  const t = text.trim();
-  if (t.length < 2)
-    return null;
-  const q = t[0];
-  if (q !== '"' && q !== "'" && q !== "`" || t[t.length - 1] !== q)
-    return null;
-  const inner = t.slice(1, -1);
-  if (q === "`" && inner.includes("${"))
-    return null;
-  if (inner.includes(q) && !inner.includes("\\" + q))
-    return null;
-  return inner.replace(/\\(.)/g, "$1");
-}, scanAssetIconCalls = (source) => {
-  const calls = [];
-  const n = source.length;
-  let i = 0;
-  while (i < n) {
-    const c = source[i];
-    if (c === '"' || c === "'" || c === "`") {
-      i = skipString2(source, i);
-      continue;
-    }
-    if (c === "/" && source[i + 1] === "/") {
-      i += 2;
-      while (i < n && source[i] !== `
-`)
-        i++;
-      continue;
-    }
-    if (c === "/" && source[i + 1] === "*") {
-      i += 2;
-      while (i < n && !(source[i] === "*" && source[i + 1] === "/"))
-        i++;
-      i += 2;
-      continue;
-    }
-    if (isIdentStart(c)) {
-      let j = i + 1;
-      while (j < n && isIdentPart(source[j]))
-        j++;
-      if (source.slice(i, j) === "assetIcon" && prevNonSpace(source, i) !== ".") {
-        const call = parseCall(source, i, j);
-        if (call) {
-          calls.push(call);
-          i = call.end;
-          continue;
-        }
-      }
-      i = j;
-      continue;
-    }
-    i++;
-  }
-  return calls;
-}, prevNonSpace = (src, i) => {
-  let k = i - 1;
-  while (k >= 0 && /\s/.test(src[k]))
-    k--;
-  return k >= 0 ? src[k] : "";
-}, parseCall = (src, start, identEnd) => {
-  const n = src.length;
-  let i = identEnd;
-  while (i < n && /\s/.test(src[i]))
-    i++;
-  if (src[i] !== "(")
-    return null;
-  const close = matchParen(src, i);
-  if (close === -1)
-    return null;
-  const call = { start, end: close + 1, id: "", pack: "", name: "" };
-  const args = splitTopLevel(src.slice(i + 1, close), ",");
-  const id = stringLiteralValue(args[0] ?? "");
-  if (id === null) {
-    call.error = `assetIcon(...) needs a string-literal id like "lucide:bell" (got \`${(args[0] ?? "").trim() || "()"}\`).`;
-    return call;
-  }
-  const m = ICON_ID.exec(id);
-  if (!m) {
-    call.error = `assetIcon("${id}"): id must be "pack:name", lowercase [a-z0-9-] (e.g. "lucide:bell").`;
-    return call;
-  }
-  call.id = id;
-  call.pack = m[1];
-  call.name = m[2];
-  const optsText = args[1]?.trim();
-  if (optsText) {
-    const color = extractColor(optsText);
-    if (color.error) {
-      call.error = color.error;
-      return call;
-    }
-    if (color.bake !== undefined)
-      call.bake = color.bake;
-    else if (color.tint !== undefined)
-      call.tint = color.tint;
-  }
-  return call;
-}, extractColor = (optsText) => {
-  if (!optsText.startsWith("{") || !optsText.endsWith("}")) {
-    return { error: `assetIcon(id, opts): opts must be an object literal like { color: "#5b8cff" }.` };
-  }
-  for (const prop of splitTopLevel(optsText.slice(1, -1), ",")) {
-    const kv = splitTopLevel(prop, ":");
-    if (kv.length < 2)
-      continue;
-    const key = kv[0].trim().replace(/^["'`]|["'`]$/g, "");
-    if (key !== "color")
-      continue;
-    const raw = kv.slice(1).join(":").trim();
-    if (!raw)
-      continue;
-    const literal = stringLiteralValue(raw);
-    return literal !== null ? { bake: literal } : { tint: raw };
-  }
-  return {};
-}, rewriteAssetIcons = (source, calls, svgById) => {
-  let out = source;
-  for (const call of [...calls].sort((a, b) => b.start - a.start)) {
-    const svg = svgById.get(call.id);
-    if (svg === undefined)
-      continue;
-    out = out.slice(0, call.start) + iconExpr(svg, call) + out.slice(call.end);
-  }
-  return out;
-}, iconExpr = (svg, call) => {
-  const body = call.bake ? svg.split("currentColor").join(call.bake) : svg;
-  const src = `SvgSource(\`${escapeTemplate(body)}\`)`;
-  return call.tint ? `Object.assign(${src}, { tintColor: (${call.tint}) })` : src;
-}, escapeTemplate = (s) => s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), applyAssetIconMacro = async (entries, resolveSvgs) => {
-  const scanned = entries.filter((e) => e.type === "text" && typeof e.text === "string" && e.text.includes("assetIcon")).map((e) => ({ entry: e, calls: scanAssetIconCalls(e.text) })).filter((s) => s.calls.length > 0);
-  if (scanned.length === 0)
-    return [];
-  const errors = scanned.flatMap((s) => s.calls.filter((c) => c.error).map((c) => c.error));
-  if (errors.length)
-    throw new Error([...new Set(errors)].join(`
-`));
-  const ids = [...new Set(scanned.flatMap((s) => s.calls.map((c) => c.id)))];
-  const svgById = await resolveSvgs(ids);
-  const missing = ids.filter((id) => !svgById.has(id));
-  if (missing.length)
-    throw new Error(`assetIcon: could not resolve icon(s): ${missing.join(", ")}.`);
-  for (const { entry, calls } of scanned)
-    entry.text = rewriteAssetIcons(entry.text, calls, svgById);
-  return ids;
-}, buildIconsHeaderValue = (ids) => [...new Set(ids.map((id) => id.split(":")[0]))].sort().join(";"), editDistance = (a, b, cap) => {
-  if (Math.abs(a.length - b.length) > cap)
-    return cap + 1;
-  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1;i <= a.length; i++) {
-    const cur = [i];
-    let rowMin = i;
-    for (let j = 1;j <= b.length; j++) {
-      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-      if (cur[j] < rowMin)
-        rowMin = cur[j];
-    }
-    if (rowMin > cap)
-      return cap + 1;
-    prev = cur;
-  }
-  return prev[b.length];
-}, suggestIconNames = (want, icons) => {
-  const wantParts = new Set(want.split("-").filter(Boolean));
-  const scored = [];
-  for (const [name, info] of Object.entries(icons)) {
-    const lenDiff = Math.abs(name.length - want.length) / 100;
-    let rank;
-    if (name.includes(want) || want.includes(name))
-      rank = lenDiff;
-    else {
-      const d = editDistance(want, name, 2);
-      if (d <= 2)
-        rank = 1 + d;
-      else if (info.kw?.some((k) => wantParts.has(k)))
-        rank = 4 + lenDiff;
-      else
-        continue;
-    }
-    scored.push({ name, rank });
-  }
-  return scored.sort((a, b) => a.rank - b.rank || (a.name < b.name ? -1 : 1)).slice(0, 5).map((s) => s.name);
-}, iconNotFoundError = async (pack, name, read, registry) => {
-  const metaRaw = await read(`${pack}/meta.json`);
-  if (metaRaw !== null) {
-    let icons = {};
-    try {
-      icons = JSON.parse(metaRaw).icons ?? {};
-    } catch {}
-    const similar = suggestIconNames(name, icons);
-    const hint = similar.length ? ` Did you mean ${similar.map((s) => `"${pack}:${s}"`).join(", ")}?` : ` No similar name in the "${pack}" pack either.`;
-    return new Error(`assetIcon: icon "${pack}:${name}" not found.${hint}`);
-  }
-  const licRaw = await read("licenses.json");
-  if (licRaw !== null) {
-    try {
-      const packs = Object.keys(JSON.parse(licRaw)).sort();
-      return new Error(`assetIcon: unknown icon pack "${pack}" (in "${pack}:${name}"). Available packs: ${packs.join(", ")}.`);
-    } catch {}
-  }
-  return Object.assign(new Error(`assetIcon: can't reach the icon registry${registry ? ` (${registry})` : ""} to resolve "${pack}:${name}". ` + `Check your connection, or set LECODES_ICON_REGISTRY.`), { transient: true });
-}, VENDORED_ICON_PATH, collectVendoredIcons = (entries) => {
-  const map = new Map;
-  for (const e of entries) {
-    if (e.type !== "text" || typeof e.text !== "string")
-      continue;
-    const m = VENDORED_ICON_PATH.exec(e.path);
-    if (m)
-      map.set(`${m[1]}:${m[2]}`, e.text);
-  }
-  return map;
-};
-var init_assetIconMacro = __esm(() => {
-  ICON_ID = /^([a-z0-9]+(?:-[a-z0-9]+)*):([a-z0-9]+(?:-[a-z0-9]+)*)$/;
-  VENDORED_ICON_PATH = /(?:^|\/)assets\/icons\/([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)\.svg$/;
-});
-
 // ../../sdk/src/compile/compileProject.ts
 var localAssetBase = (path) => path.split(/[\\/]/).pop() ?? path, localAssetNames = (entries) => {
   const seen = new Map;
@@ -171328,7 +171642,7 @@ var localAssetBase = (path) => path.split(/[\\/]/).pop() ?? path, localAssetName
     throw new Error("Couldn't find an entrypoint (no .ts/.js project file — name yours main.ts). Pass entryOverride.");
   }
   const files = entriesToFiles(entries, opts);
-  const { code, map } = await bundleProjectWithMap(entry, files, opts.format ?? "esm", opts.minify, opts.editor, opts.libraries, opts.sourcemap ?? true);
+  const { code, map, bakes } = await bundleProjectWithMap(entry, files, opts.format ?? "esm", opts.minify, opts.editor, opts.libraries, opts.sourcemap ?? true, undefined, opts.readResource);
   const plugins = opts.plugins ?? pluginsOfAppJson(entries);
   if (map && opts.onWarning) {
     const missing = pluginsOfBundle(map).filter((id) => !plugins.includes(id));
@@ -171337,14 +171651,10 @@ var localAssetBase = (path) => path.split(/[\\/]/).pop() ?? path, localAssetName
     }
   }
   if (opts.header === false)
-    return { code, map, entry };
+    return { code, map, entry, bakes };
   const header = buildHeader(opts.name, code, { icon: opts.icon, fonts: opts.fontsHeader, icons: opts.iconsHeader, plugins });
   const headerLines = (header.match(/\n/g) ?? []).length;
-  return { code: header + code, map: map ? offsetSourceMap(map, headerLines) : null, entry };
-}, compileProject = async (opts) => {
-  const { code, map } = await compileProjectWithMap(opts);
-  return map ? `${code}
-${inlineSourceMapComment(map)}` : code;
+  return { code: header + code, map: map ? offsetSourceMap(map, headerLines) : null, entry, bakes };
 };
 var init_compileProject = __esm(() => {
   init_bundler();
@@ -171811,7 +172121,7 @@ var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart2 = (c) => c >= "A" && c <= "
   }
   parts.push(text.slice(last));
   return parts;
-}, stringLiteralValue2 = (text) => {
+}, stringLiteralValue3 = (text) => {
   const t = text.trim();
   if (t.length < 2)
     return null;
@@ -171883,7 +172193,7 @@ var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart2 = (c) => c >= "A" && c <= "
     return null;
   const call = { start, end: close + 1, arg: "", kind: "registry" };
   const args = splitTopLevel2(src.slice(i + 1, close), ",");
-  const arg = stringLiteralValue2(args[0] ?? "");
+  const arg = stringLiteralValue3(args[0] ?? "");
   if (arg === null) {
     call.error = `font(...) needs a string-literal argument — a registry id ("manrope") or a project path ("./fonts/Brand.ttf"). Got \`${(args[0] ?? "").trim() || "()"}\`.`;
     return call;
@@ -172138,15 +172448,15 @@ var init_compile = __esm(() => {
 });
 
 // src/compile/projectCompile.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname6, join as join7 } from "node:path";
+import { dirname as dirname6, join as join8 } from "node:path";
 var resolveSdkInject = () => {
   try {
     return createRequire4(import.meta.url).resolve("lecodes-sdk/inject");
   } catch {}
-  const vendored = join7(distRoot, "runtime", "sdk", "inject.ts");
-  return existsSync6(vendored) ? vendored : null;
+  const vendored = join8(distRoot, "runtime", "sdk", "inject.ts");
+  return existsSync7(vendored) ? vendored : null;
 }, sdkInject, sdkSourceDir, resolveChiselBin2 = () => {
   if (process.env.LECODES_CHISEL_BIN)
     return process.env.LECODES_CHISEL_BIN;
@@ -172155,29 +172465,46 @@ var resolveSdkInject = () => {
     if (fromPkg)
       return fromPkg;
   } catch {}
-  const local = join7(dirname6(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel");
-  return existsSync6(local) ? local : null;
+  const local = join8(dirname6(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel");
+  return existsSync7(local) ? local : null;
 }, chiselBin, ambiguousEntryWarning = (entries) => {
   const { entry, roots } = detectEntry(entries, scanModulesChisel);
   if (!entry || roots.length < 2 || roots.includes(ENTRY_CONVENTION))
     return null;
   return `Ambiguous entrypoint: nothing imports ${roots.join(", ")} — picked ${entry}. Rename your entry to main.ts (or pass --entry).`;
-}, compileProject2 = (opts) => compileProject({
-  entries: opts.entries.map((e) => ({ path: e.path, type: e.type, text: e.text, fileSrc: e.fileSrc, remote: e.remote, shaders: e.shaders, shadersLocal: e.shadersLocal })),
-  name: opts.name,
-  publicUrl: opts.publicUrl,
-  entryOverride: opts.entryOverride,
-  header: opts.header,
-  fontsHeader: opts.fontsHeader,
-  iconsHeader: opts.iconsHeader,
-  format: opts.format,
-  localAssets: opts.localAssets,
-  minify: opts.minify,
-  sourcemap: opts.sourcemap,
-  editor: opts.editor,
-  onWarning: opts.onWarning,
-  serverUrl: opts.serverUrl
-}), hasServerFiles = (entries) => entries.some((e) => e.type === "text" && isServerPath(e.path)), findTypescript = async (root) => {
+}, resourceReader = (entries) => {
+  const byRoot = new Map(entries.map((e) => ["/" + e.path.replace(/\\/g, "/").replace(/^[./]+/, ""), e]));
+  return (rootPath) => {
+    const e = byRoot.get(rootPath);
+    if (e?.text !== undefined)
+      return e.text;
+    try {
+      return e?.absPath ? readFileSync6(e.absPath, "utf8") : null;
+    } catch {
+      return null;
+    }
+  };
+}, compileProjectBundle = async (opts) => {
+  const { code, map, bakes } = await compileProjectWithMap({
+    entries: opts.entries.map((e) => ({ path: e.path, type: e.type, text: e.text, fileSrc: e.fileSrc, remote: e.remote, shaders: e.shaders, shadersLocal: e.shadersLocal })),
+    readResource: resourceReader(opts.entries),
+    name: opts.name,
+    publicUrl: opts.publicUrl,
+    entryOverride: opts.entryOverride,
+    header: opts.header,
+    fontsHeader: opts.fontsHeader,
+    iconsHeader: opts.iconsHeader,
+    format: opts.format,
+    localAssets: opts.localAssets,
+    minify: opts.minify,
+    sourcemap: opts.sourcemap,
+    editor: opts.editor,
+    onWarning: opts.onWarning,
+    serverUrl: opts.serverUrl
+  });
+  return { js: map ? `${code}
+${inlineSourceMapComment(map)}` : code, bakes };
+}, compileProject2 = async (opts) => (await compileProjectBundle(opts)).js, hasServerFiles = (entries) => entries.some((e) => e.type === "text" && isServerPath(e.path)), findTypescript = async (root) => {
   const api = (mod) => mod?.createProgram ? mod : mod?.default?.createProgram ? mod.default : null;
   const from = (at) => {
     try {
@@ -172188,15 +172515,15 @@ var resolveSdkInject = () => {
   };
   const dir = peerDirInPrefix("typescript");
   const peer = () => {
-    if (!existsSync6(join7(dir, "package.json")))
+    if (!existsSync7(join8(dir, "package.json")))
       return null;
     try {
-      return api(createRequire4(import.meta.url)(join7(dir, "lib", "typescript.js")));
+      return api(createRequire4(import.meta.url)(join8(dir, "lib", "typescript.js")));
     } catch {
       return null;
     }
   };
-  const found = from(join7(root, "package.json")) ?? from(import.meta.url) ?? peer();
+  const found = from(join8(root, "package.json")) ?? from(import.meta.url) ?? peer();
   if (found)
     return found;
   await installPeers(["typescript"], "The project's server code (*.server.ts)");
@@ -172381,8 +172708,8 @@ var init_assetName = __esm(() => {
 });
 
 // src/project/paths.ts
-import { createHash } from "node:crypto";
-var sha256 = (data) => createHash("sha256").update(data).digest("hex"), toKey = (path) => {
+import { createHash as createHash2 } from "node:crypto";
+var sha256 = (data) => createHash2("sha256").update(data).digest("hex"), toKey = (path) => {
   const parts = path.replace(/\\/g, "/").split("/").map((p) => p.trim()).filter((p) => p && p !== ".");
   if (parts.some((p) => p === ".."))
     throw new CliError(`Unsafe path: ${path}`);
@@ -172397,8 +172724,8 @@ var init_paths = __esm(() => {
 });
 
 // src/project/ignore.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join11 } from "node:path";
 var BUILTIN_PATTERNS, DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
 # Only untracked files are affected — assets already in the project stay tracked
 # even if they match a pattern. Built-in defaults (node_modules, _*, *.log, .artifacts)
@@ -172479,18 +172806,18 @@ design/comments/
   return (path) => match(path.startsWith("/") ? path : "/" + path, false);
 }, loadIgnore = (root) => {
   const lines = [...BUILTIN_PATTERNS];
-  const file = join10(root, ".lecodesignore");
-  if (existsSync9(file)) {
+  const file = join11(root, ".lecodesignore");
+  if (existsSync10(file)) {
     try {
-      lines.push(...readFileSync7(file, "utf8").split(/\r?\n/));
+      lines.push(...readFileSync9(file, "utf8").split(/\r?\n/));
     } catch {}
   }
   const rules = lines.map(compile).filter((r) => r !== null);
   return buildMatcher(rules);
 }, writeDefaultIgnore = (root) => {
-  const file = join10(root, ".lecodesignore");
-  if (!existsSync9(file))
-    writeFileSync3(file, DEFAULT_IGNORE_FILE);
+  const file = join11(root, ".lecodesignore");
+  if (!existsSync10(file))
+    writeFileSync4(file, DEFAULT_IGNORE_FILE);
 }, DEFAULT_GITIGNORE = `# LeCodes per-checkout state: generated IDE types + this machine's sync cursor
 # (.lecodes/manifest.json). Regenerate with \`lecodes update\` / re-attach with \`lecodes link\`.
 .lecodes/
@@ -172505,19 +172832,19 @@ node_modules/
 
 dist/
 `, ensureGitignore = (root) => {
-  const file = join10(root, ".gitignore");
-  if (!existsSync9(file)) {
-    writeFileSync3(file, DEFAULT_GITIGNORE);
+  const file = join11(root, ".gitignore");
+  if (!existsSync10(file)) {
+    writeFileSync4(file, DEFAULT_GITIGNORE);
     return "created";
   }
-  const text = readFileSync7(file, "utf8");
+  const text = readFileSync9(file, "utf8");
   const covered = text.split(/\r?\n/).some((l) => /^\/?\.lecodes\/?\s*$/.test(l.trim()));
   if (covered)
     return null;
   const sep = text.length === 0 || text.endsWith(`
 `) ? "" : `
 `;
-  writeFileSync3(file, `${text}${sep}
+  writeFileSync4(file, `${text}${sep}
 # LeCodes per-checkout state (generated types + sync cursor) — not source
 .lecodes/
 `);
@@ -172528,8 +172855,8 @@ var init_ignore = __esm(() => {
 });
 
 // src/project/localFiles.ts
-import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "node:fs";
-import { basename, dirname as dirname7, join as join11, relative as relative3 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "node:fs";
+import { basename, dirname as dirname7, join as join12, relative as relative3 } from "node:path";
 var SKIP_DIRS, SKIP_FILES, TEXT_EXTS, ext = (name) => {
   const i = name.lastIndexOf(".");
   return i < 0 ? "" : name.slice(i + 1).toLowerCase();
@@ -172547,14 +172874,14 @@ var SKIP_DIRS, SKIP_FILES, TEXT_EXTS, ext = (name) => {
       continue;
     let folder;
     try {
-      folder = JSON.parse(readFileSync8(file.absPath, "utf8").replace(/^\uFEFF/, "")).web?.static;
+      folder = JSON.parse(readFileSync10(file.absPath, "utf8").replace(/^\uFEFF/, "")).web?.static;
     } catch {
       continue;
     }
     if (typeof folder !== "string" || folder.trim() === "")
       continue;
     try {
-      folders.push(toKey(relative3(root, join11(dirname7(file.absPath), folder))) + "/");
+      folders.push(toKey(relative3(root, join12(dirname7(file.absPath), folder))) + "/");
     } catch {}
   }
   return folders;
@@ -172575,7 +172902,7 @@ var SKIP_DIRS, SKIP_FILES, TEXT_EXTS, ext = (name) => {
   };
   const walk = (dir, parentIgnored) => {
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-      const abs = join11(dir, entry.name);
+      const abs = join12(dir, entry.name);
       const key = toKey(relative3(root, abs));
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
@@ -172595,7 +172922,7 @@ var SKIP_DIRS, SKIP_FILES, TEXT_EXTS, ext = (name) => {
           ignored.push(key);
           continue;
         }
-        found.push({ path: key, absPath: abs, sha: sha256(readFileSync8(abs)) });
+        found.push({ path: key, absPath: abs, sha: sha256(readFileSync10(abs)) });
       }
     }
   };
@@ -172607,8 +172934,8 @@ var SKIP_DIRS, SKIP_FILES, TEXT_EXTS, ext = (name) => {
   }));
   return { files, dirs, ignored };
 }, resolveLocalPath = (root, key) => {
-  const direct = join11(root, key.slice(1));
-  if (existsSync10(direct))
+  const direct = join12(root, key.slice(1));
+  if (existsSync11(direct))
     return direct;
   let dir = root;
   try {
@@ -172616,7 +172943,7 @@ var SKIP_DIRS, SKIP_FILES, TEXT_EXTS, ext = (name) => {
       const match = readdirSync3(dir).find((entry) => entry === name || sanitizeAssetName2(entry) === name);
       if (!match)
         return null;
-      dir = join11(dir, match);
+      dir = join12(dir, match);
     }
   } catch {
     return null;
@@ -172675,9 +173002,9 @@ var init_localFiles = __esm(() => {
 });
 
 // src/compile/fonts.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname9, join as join13 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname9, join as join14 } from "node:path";
 var applyProjectFonts = async (entries, opts) => {
   const registry = (opts.registry ?? fontRegistryBase()).replace(/\/+$/, "");
   const byPath = () => new Map(entries.map((e) => [e.path.replace(/^\//, ""), e]));
@@ -172686,9 +173013,9 @@ var applyProjectFonts = async (entries, opts) => {
     registryBase: registry,
     readBytes: (entryPath) => {
       const entry = byPath().get(entryPath);
-      const abs = entry?.absPath ?? join13(opts.root, entryPath);
+      const abs = entry?.absPath ?? join14(opts.root, entryPath);
       try {
-        return new Uint8Array(readFileSync11(abs));
+        return new Uint8Array(readFileSync13(abs));
       } catch {
         return null;
       }
@@ -172696,9 +173023,9 @@ var applyProjectFonts = async (entries, opts) => {
     vendorFace: opts.mode === "vendor" ? async (face) => {
       const vendorDir = opts.vendorDir ?? opts.root;
       const rel = `assets/fonts/${face.fileName}`;
-      const abs = join13(vendorDir, rel);
+      const abs = join14(vendorDir, rel);
       const entryPath = `${opts.vendorPrefix ?? ""}/${rel}`;
-      if (!existsSync11(abs))
+      if (!existsSync12(abs))
         await downloadFace(registry, vendorDir, face, rel, abs);
       if (!byPath().has(entryPath.replace(/^\//, ""))) {
         entries.push(opts.makeResourceEntry?.(entryPath, abs) ?? { path: entryPath, type: "resource", absPath: abs });
@@ -172714,19 +173041,19 @@ var applyProjectFonts = async (entries, opts) => {
     const fileSrc = byPath().get(path.replace(/^\//, ""))?.fileSrc;
     return fileSrc ? (opts.publicUrl ?? "") + fileSrc : null;
   }) || undefined;
-}, isHttp = (s) => /^https?:/i.test(s), sha12 = (b) => createHash2("sha256").update(b).digest("hex").slice(0, 12), registryHome = (registry) => registry.replace(/\/v\d+$/, ""), readRegistry = async (registry, rel) => {
+}, isHttp = (s) => /^https?:/i.test(s), sha12 = (b) => createHash3("sha256").update(b).digest("hex").slice(0, 12), registryHome = (registry) => registry.replace(/\/v\d+$/, ""), readRegistry = async (registry, rel) => {
   if (isHttp(registry)) {
     const res = await fetch(`${registry}/${rel}`);
     return res.ok ? new Uint8Array(await res.arrayBuffer()) : null;
   }
   try {
-    return new Uint8Array(readFileSync11(join13(registry, rel)));
+    return new Uint8Array(readFileSync13(join14(registry, rel)));
   } catch {
     return null;
   }
 }, readLock = (path) => {
   try {
-    const lock = JSON.parse(readFileSync11(path, "utf8"));
+    const lock = JSON.parse(readFileSync13(path, "utf8"));
     if (lock && typeof lock === "object" && lock.faces && lock.families)
       return lock;
   } catch {}
@@ -172758,10 +173085,10 @@ var applyProjectFonts = async (entries, opts) => {
 `);
 }, writeIfChanged = (path, text) => {
   try {
-    if (readFileSync11(path, "utf8") === text)
+    if (readFileSync13(path, "utf8") === text)
       return;
   } catch {}
-  writeFileSync5(path, text);
+  writeFileSync6(path, text);
 }, downloadFace = async (registry, vendorDir, face, rel, abs) => {
   const licRaw = await readRegistry(registry, "licenses.json");
   if (!licRaw)
@@ -172773,15 +173100,15 @@ var applyProjectFonts = async (entries, opts) => {
   const bytes = await readRegistry(registry, `${face.id}/${face.fileName}`);
   if (!bytes)
     throw new Error(`font("${face.id}"): face "${face.fileName}" not found in the registry (${registryHome(registry)}).`);
-  mkdirSync4(dirname9(abs), { recursive: true });
-  writeFileSync5(abs, bytes);
-  const lockPath = join13(vendorDir, "fonts.lock.json");
+  mkdirSync5(dirname9(abs), { recursive: true });
+  writeFileSync6(abs, bytes);
+  const lockPath = join14(vendorDir, "fonts.lock.json");
   const lock = readLock(lockPath) ?? { registry, faces: {}, families: {} };
   lock.registry = registry;
   lock.faces[`${face.id}@${face.weight}${face.italic ? "i" : ""}`] = { id: face.id, family: face.family, weight: face.weight, italic: face.italic, hash: sha12(bytes), spdx: lic.spdx, path: rel };
   lock.families[face.id] = lic;
   writeIfChanged(lockPath, serializeLock(lock));
-  writeIfChanged(join13(vendorDir, "FONT-NOTICES.md"), renderNotices(lock));
+  writeIfChanged(join14(vendorDir, "FONT-NOTICES.md"), renderNotices(lock));
 };
 var init_fonts = __esm(() => {
   init_compile();
@@ -172789,7 +173116,7 @@ var init_fonts = __esm(() => {
 
 // src/compile/assetIcons.ts
 import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname10, join as join17 } from "node:path";
 var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => createHash5("sha256").update(s).digest("hex").slice(0, 12), readText = async (registry, rel) => {
@@ -172802,13 +173129,13 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
     }
   }
   try {
-    return readFileSync14(join17(registry, rel), "utf8");
+    return readFileSync15(join17(registry, rel), "utf8");
   } catch {
     return null;
   }
 }, safeRead = (path) => {
   try {
-    return readFileSync14(path, "utf8");
+    return readFileSync15(path, "utf8");
   } catch {
     return null;
   }
@@ -172830,7 +173157,7 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
   return JSON.parse(raw);
 }, readLock2 = (path) => {
   try {
-    const lock = JSON.parse(readFileSync14(path, "utf8"));
+    const lock = JSON.parse(readFileSync15(path, "utf8"));
     if (lock && typeof lock === "object" && lock.icons && lock.packs)
       return lock;
   } catch {}
@@ -172937,11 +173264,11 @@ var init_assetIcons = __esm(() => {
 // src/platform/config.ts
 import { homedir as homedir5 } from "node:os";
 import { join as join18 } from "node:path";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "node:fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "node:fs";
 var DEFAULT_API = "https://le.codes", CONFIG_DIR, CONFIG_FILE, loadConfig = () => {
   let stored = {};
   try {
-    stored = JSON.parse(readFileSync15(CONFIG_FILE, "utf8"));
+    stored = JSON.parse(readFileSync16(CONFIG_FILE, "utf8"));
   } catch {}
   return {
     apiUrl: process.env.LECODES_API ?? stored.apiUrl,
@@ -206398,7 +206725,7 @@ var init_esm29 = __esm(() => {
 
 // src/project/types.ts
 import { dirname as dirname18, join as join29, relative as relative5, sep as sep3 } from "node:path";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, readdirSync as readdirSync12, readFileSync as readFileSync24, rmSync as rmSync9, statSync as statSync10, writeFileSync as writeFileSync20 } from "node:fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17, readdirSync as readdirSync12, readFileSync as readFileSync25, rmSync as rmSync9, statSync as statSync10, writeFileSync as writeFileSync20 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   if (!existsSync27(dir))
@@ -206427,7 +206754,7 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
     const dest = join29(typesDir, path);
     if (!before.has(path))
       stats.added++;
-    else if (readFileSync24(dest, "utf8") !== text)
+    else if (readFileSync25(dest, "utf8") !== text)
       stats.updated++;
     else
       continue;
@@ -206446,7 +206773,7 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   const typesDir = join29(root, LECODES_DIR, "types");
   const bundle = {};
   for (const path of listBundleFiles(typesDir))
-    bundle[path] = readFileSync24(join29(typesDir, path), "utf8");
+    bundle[path] = readFileSync25(join29(typesDir, path), "utf8");
   return bundle;
 }, materializeTypes = async (root, apiUrl) => writeTypeBundle(root, await getTypes(apiUrl)), readLocalTypeBundle = () => {
   const fromPackage = (() => {
@@ -206464,7 +206791,7 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   for (const path of candidates) {
     if (existsSync27(path)) {
       try {
-        return JSON.parse(readFileSync24(path, "utf8"));
+        return JSON.parse(readFileSync25(path, "utf8"));
       } catch {}
     }
   }
@@ -206502,7 +206829,7 @@ var init_types4 = __esm(() => {
 });
 
 // src/compile/designCompile.ts
-import { readFileSync as readFileSync25 } from "node:fs";
+import { readFileSync as readFileSync26 } from "node:fs";
 var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) => {
   const { root, manifest, designDir, designKey, screenId, state } = opts;
   const entries = [];
@@ -206519,7 +206846,7 @@ var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) =>
     } else if (type === "shader") {
       entries.push({ path: file.path, type, shaders: [] });
     } else {
-      entries.push({ path: file.path, type, text: readFileSync25(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync26(file.absPath, "utf8") });
     }
   }
   const invoke = state !== undefined ? `screen(${JSON.stringify(state)})` : "screen()";
@@ -206641,11 +206968,11 @@ var init_browserAuth = __esm(() => {
 });
 
 // src/project/designMeta.ts
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync27 } from "node:fs";
 import { join as join31 } from "node:path";
 var PHONE_SIZE, readMetaFrames = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync26(join31(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync27(join31(designDir, "meta.json"), "utf8"));
     const d = meta?.defaultSize;
     const valid = Array.isArray(d) && d.length === 2 && d.every((n) => typeof n === "number" && Number.isFinite(n) && n >= 64 && n <= 8192);
     return {
@@ -206996,7 +207323,7 @@ var init_comments = __esm(() => {
 });
 
 // src/commands/design/snapshot.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync20, readdirSync as readdirSync15, readFileSync as readFileSync27, writeFileSync as writeFileSync22 } from "node:fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync20, readdirSync as readdirSync15, readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "node:fs";
 import { join as join33 } from "node:path";
 var listScreens = (designDir) => {
   const dir = join33(designDir, "screens");
@@ -207068,7 +207395,7 @@ var init_snapshot = __esm(() => {
         const [width, height] = frames.screens[id]?.size ?? frames.defaultSize;
         let plan = [{ state: undefined, bases: [id] }];
         if (discover) {
-          const { states, canonical } = discover(readFileSync27(join33(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+          const { states, canonical } = discover(readFileSync28(join33(ctx.designDir, "screens", `${id}.ts`), "utf8"));
           if (stateFlag !== undefined) {
             if (!states.includes(stateFlag)) {
               if (args.length === 1)
@@ -207598,7 +207925,7 @@ var init_templates2 = __esm(() => {
 });
 
 // src/commands/design/index.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync29, writeFileSync as writeFileSync23 } from "node:fs";
 import { join as join34 } from "node:path";
 var firstLine = (body, max = 64) => {
   const line = body.split(`
@@ -207673,7 +208000,7 @@ var firstLine = (body, max = 64) => {
   let config = {};
   if (existsSync33(path)) {
     try {
-      config = JSON.parse(readFileSync28(path, "utf8"));
+      config = JSON.parse(readFileSync29(path, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-design server by hand.");
       return;
@@ -207753,7 +208080,7 @@ var init_design = __esm(() => {
       }
       const ignorePath = join34(ctx.root, ".lecodesignore");
       const ignoreLines = [`${ctx.dirName}/.snapshots/`, `${ctx.dirName}/comments/`];
-      const current = existsSync33(ignorePath) ? readFileSync28(ignorePath, "utf8") : "";
+      const current = existsSync33(ignorePath) ? readFileSync29(ignorePath, "utf8") : "";
       const present = new Set(current.split(/\r?\n/));
       const missing = ignoreLines.filter((line) => !present.has(line));
       if (missing.length) {
@@ -227112,32 +227439,32 @@ import { delimiter as delimiter3, dirname as dirname31, join as join63 } from "n
 // src/commands/app/index.ts
 init_manifest();
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { cpSync as cpSync4, existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync23, readdirSync as readdirSync10, rmSync as rmSync8, statSync as statSync9, writeFileSync as writeFileSync19 } from "node:fs";
+import { cpSync as cpSync4, existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync24, readdirSync as readdirSync10, rmSync as rmSync8, statSync as statSync9, writeFileSync as writeFileSync19 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { basename as basename10, dirname as dirname17, join as join27, resolve as resolve14 } from "node:path";
 
 // src/plugin/manifest.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join9 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join10 } from "node:path";
 
 // src/plugin/firstParty.ts
 init_projectCompile();
-import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "node:fs";
+import { join as join9 } from "node:path";
 var ID = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 var firstPartyContractFile = (id) => {
   if (!sdkSourceDir || !ID.test(id))
     return null;
-  const file = join8(sdkSourceDir, "plugins", "gen", id, "contract.d.ts");
-  return existsSync7(file) ? file : null;
+  const file = join9(sdkSourceDir, "plugins", "gen", id, "contract.d.ts");
+  return existsSync8(file) ? file : null;
 };
 var firstPartyIds = () => {
   if (!sdkSourceDir)
     return [];
-  const gen = join8(sdkSourceDir, "plugins", "gen");
-  return existsSync7(gen) ? readdirSync2(gen).filter((id) => existsSync7(join8(gen, id, "contract.d.ts"))).sort() : [];
+  const gen = join9(sdkSourceDir, "plugins", "gen");
+  return existsSync8(gen) ? readdirSync2(gen).filter((id) => existsSync8(join9(gen, id, "contract.d.ts"))).sort() : [];
 };
-var firstPartyContractText = (file) => readFileSync5(file, "utf8").replace(/from "(?:\.\.\/)+plugin"/g, `from "lecodes-sdk/plugin"`);
+var firstPartyContractText = (file) => readFileSync7(file, "utf8").replace(/from "(?:\.\.\/)+plugin"/g, `from "lecodes-sdk/plugin"`);
 
 // src/plugin/manifest.ts
 var MANIFEST_FILE = "lecodes-plugin.json";
@@ -227170,15 +227497,15 @@ var BRANCH = {
   web: new Set(["register", "dependencies", "resources", "static"])
 };
 var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var isFolder = (path) => existsSync8(path) && statSync2(path).isDirectory();
+var isFolder = (path) => existsSync9(path) && statSync2(path).isDirectory();
 var pascal = (id) => id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 var XCFRAMEWORK = ".xcframework";
 var binaryName = (path) => path.split(/[\\/]/).pop().slice(0, -XCFRAMEWORK.length);
-var readManifest2 = (dir, id) => {
-  const file = join9(dir, MANIFEST_FILE);
+var readManifest3 = (dir, id) => {
+  const file = join10(dir, MANIFEST_FILE);
   let raw;
   try {
-    raw = JSON.parse(readFileSync6(file, "utf8").replace(/^/, ""));
+    raw = JSON.parse(readFileSync8(file, "utf8").replace(/^/, ""));
   } catch (e) {
     throw new ManifestError(file, [`not JSON: ${e instanceof Error ? e.message : String(e)}`]);
   }
@@ -227217,14 +227544,14 @@ var readManifest2 = (dir, id) => {
       problems.push(`implements: the id of the first-party plugin whose contract the folder implements ("ar")`);
     else if (!firstPartyContractFile(impl))
       problems.push(`implements: "${impl}" is no first-party plugin of this SDK (${firstPartyIds().join(", ") || "it carries none"})`);
-    if (existsSync8(join9(dir, CONTRACT_FILE)))
+    if (existsSync9(join10(dir, CONTRACT_FILE)))
       problems.push(`implements: the folder implements another plugin's contract — it has no ${CONTRACT_FILE} of its own`);
-    if (isFolder(join9(dir, "sdk")))
+    if (isFolder(join10(dir, "sdk")))
       problems.push("implements: the folder implements another plugin — its app side is the SDK's, it has no sdk/ of its own");
   }
   for (const platform of PLATFORMS) {
     const branch = raw[platform];
-    const folder = isFolder(join9(dir, platform));
+    const folder = isFolder(join10(dir, platform));
     if (branch === undefined) {
       problems.push(`${platform}: missing — an object, or null where the plugin has no ${platform} half`);
       continue;
@@ -227255,7 +227582,7 @@ var readManifest2 = (dir, id) => {
     if (platform === "web" && register !== undefined) {
       if (!register.startsWith("web/"))
         problems.push(`web.register: "${register}" — a module of the web/ folder`);
-      else if (!existsSync8(join9(dir, register)))
+      else if (!existsSync9(join10(dir, register)))
         problems.push(`web.register: ${register} is not there`);
     }
   }
@@ -227295,7 +227622,7 @@ var readManifest2 = (dir, id) => {
             problems.push(`ios.binaries[${i}]: ${path} is in ios/, the half's sources — a binary stands beside them ("binaries/ios/X.xcframework")`);
           else if (!/^[A-Za-z_]\w*$/.test(binaryName(path)))
             problems.push(`ios.binaries[${i}]: "${path}" — the folder's name is its binary target's: a Swift name before ${XCFRAMEWORK}`);
-          else if (!isFolder(join9(dir, path)))
+          else if (!isFolder(join10(dir, path)))
             problems.push(`ios.binaries[${i}]: ${path} is not a folder of the plugin`);
           else if (named.has(binaryName(path)))
             problems.push(`ios.binaries[${i}]: ${path} is named "${binaryName(path)}" like ${named.get(binaryName(path))} — a name is one binary target`);
@@ -227336,7 +227663,7 @@ var readManifest2 = (dir, id) => {
       const segments = typeof folder === "string" ? folder.split(/[\\/]/) : [];
       if (typeof folder !== "string" || folder.trim() === "" || isAbsolute2(folder) || segments.some((s) => s === ".." || s === "." || s === "")) {
         problems.push(`web.static: a folder of the plugin, by its path in it ("xr-runtime")`);
-      } else if (!isFolder(join9(dir, folder)))
+      } else if (!isFolder(join10(dir, folder)))
         problems.push(`web.static: ${folder} is not a folder of the plugin`);
       else if (folder === "index.js")
         problems.push(`web.static: "index.js" is the built module's name`);
@@ -227346,7 +227673,7 @@ var readManifest2 = (dir, id) => {
     throw new ManifestError(file, problems);
   return raw;
 };
-var readManifestIfAny = (dir, id) => existsSync8(join9(dir, MANIFEST_FILE)) ? readManifest2(dir, id) : null;
+var readManifestIfAny = (dir, id) => existsSync9(join10(dir, MANIFEST_FILE)) ? readManifest3(dir, id) : null;
 
 // src/commands/compile.ts
 init_api();
@@ -227357,15 +227684,15 @@ import { basename as basename6, resolve as resolve6 } from "node:path";
 // src/compile/collect.ts
 init_localFiles();
 init_ignore();
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 
 // src/project/materialize.ts
 init_api();
 init_paths();
-import { dirname as dirname8, join as join12 } from "node:path";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
 var kindOf = (type) => type === "file" ? "resource" : type;
-var absOf = (root, key) => join12(root, ...key.replace(/^\//, "").split("/"));
+var absOf = (root, key) => join13(root, ...key.replace(/^\//, "").split("/"));
 var buildPaths = (assets) => {
   const pathById = new Map;
   for (const asset of assets) {
@@ -227383,20 +227710,20 @@ var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
     const key = pathById.get(asset.id);
     const abs = absOf(root, key);
     if (asset.type === "folder") {
-      mkdirSync3(abs, { recursive: true });
+      mkdirSync4(abs, { recursive: true });
       continue;
     }
-    mkdirSync3(dirname8(abs), { recursive: true });
+    mkdirSync4(dirname8(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync4(abs, bytes);
+      writeFileSync5(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync4(abs, text);
+      writeFileSync5(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf(asset.type), sha };
@@ -227430,7 +227757,7 @@ var collectEntries = (root, manifest, project, opts = {}) => {
         warnings.push(`No compiled shader for ${file.path} — push it to compile the shader.`);
       entries.push({ path: file.path, type, shaders, absPath: file.absPath });
     } else {
-      entries.push({ path: file.path, type, text: readFileSync9(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync11(file.absPath, "utf8") });
     }
   }
   return { entries, warnings };
@@ -227439,11 +227766,11 @@ var collectEntries = (root, manifest, project, opts = {}) => {
 // src/compile/collectLocal.ts
 init_localFiles();
 init_ignore();
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { basename as basename2 } from "node:path";
 var isHalfManifest = (abs) => {
   try {
-    return typeof JSON.parse(readFileSync10(abs, "utf8").replace(/^/, "")).implements === "string";
+    return typeof JSON.parse(readFileSync12(abs, "utf8").replace(/^/, "")).implements === "string";
   } catch {
     return false;
   }
@@ -227465,7 +227792,7 @@ var collectLocalEntries = (root, manifest, assetBase, opts = {}) => {
       }
       entries.push({ path: file.path, type, shaders: [], absPath: file.absPath });
     } else {
-      entries.push({ path: file.path, type, text: readFileSync10(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync12(file.absPath, "utf8") });
     }
   }
   return { entries, warnings };
@@ -227479,110 +227806,16 @@ init_fonts();
 init_compile();
 import { execFile } from "node:child_process";
 import { createHash as createHash4, randomBytes } from "node:crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync13, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync14, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename as basename3, join as join16 } from "node:path";
 
 // src/hosts/matcTool.ts
+init_releases();
+init_cli();
 import { existsSync as existsSync13, readdirSync as readdirSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join15, resolve as resolve4 } from "node:path";
-
-// src/hosts/releases.ts
-init_cli();
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync12, renameSync, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join14 } from "node:path";
-import { spawnSync as spawnSync4 } from "node:child_process";
-var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json";
-var ARTIFACT_STAMP = ".lecodes-artifact.json";
-var cachedArtifactSha = (dir) => {
-  try {
-    return JSON.parse(readFileSync12(join14(dir, ARTIFACT_STAMP), "utf8")).sha256 ?? null;
-  } catch {
-    return null;
-  }
-};
-var macPlatformKey = () => process.arch === "arm64" ? "macos-arm64" : "macos-x64";
-var semverNewer = (a, b) => {
-  const pa = a.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
-  for (let i = 0;i < 3; i++)
-    if ((pb[i] ?? 0) !== (pa[i] ?? 0))
-      return (pb[i] ?? 0) - (pa[i] ?? 0);
-  return 0;
-};
-var newestForPlatform = (versions, key) => {
-  const carrying = versions.filter((v) => v.files[key]).sort((a, b) => semverNewer(a.version, b.version));
-  const newest = carrying[0];
-  return newest ? { version: newest.version, file: newest.files[key] } : null;
-};
-var fetchReleaseProduct = async (product, label) => {
-  let manifest;
-  try {
-    const res = await fetch(MANIFEST_URL);
-    if (!res.ok)
-      throw new Error(`HTTP ${res.status}`);
-    manifest = await res.json();
-  } catch (e) {
-    throw new CliError(`Can't fetch the release manifest (${MANIFEST_URL}): ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const entry = manifest.products?.[product];
-  if (!entry)
-    throw new CliError(`The release manifest has no ${label} product.`);
-  return entry;
-};
-var downloadReleaseArchive = async (file, opts) => {
-  let bytes;
-  try {
-    const res = await fetch(file.url);
-    if (!res.ok)
-      throw new Error(`HTTP ${res.status}`);
-    bytes = Buffer.from(await res.arrayBuffer());
-  } catch (e) {
-    throw new CliError(`Download failed (${file.url}): ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const sha = createHash3("sha256").update(bytes).digest("hex");
-  if (sha !== file.sha256)
-    throw new CliError(`Downloaded archive is corrupt (sha256 mismatch) — try again.`);
-  mkdirSync5(opts.cacheRoot, { recursive: true });
-  const stage = mkdtempSync(join14(opts.cacheRoot, "dl-"));
-  try {
-    const archiveName = file.url.split("/").pop() ?? "archive";
-    const archive = join14(stage, archiveName);
-    writeFileSync6(archive, bytes);
-    if (opts.extract) {
-      opts.extract(archive, stage);
-    } else {
-      const winTar = join14(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
-      const tarExe = process.platform === "win32" && existsSync12(winTar) ? winTar : "tar";
-      const tar = spawnSync4(tarExe, ["-xf", archiveName], { cwd: stage, stdio: ["ignore", "ignore", "pipe"] });
-      if (tar.status !== 0)
-        throw new CliError(`Couldn't extract the archive: ${tar.stderr?.toString() ?? "tar failed"}`);
-    }
-    rmSync(archive);
-    const bad = opts.validate(stage);
-    if (bad)
-      throw new CliError(bad);
-    writeFileSync6(join14(stage, ARTIFACT_STAMP), JSON.stringify({ sha256: file.sha256, url: file.url }, null, 2));
-    try {
-      renameSync(stage, opts.dest);
-    } catch {
-      let destBad;
-      try {
-        destBad = opts.validate(opts.dest);
-      } catch {
-        destBad = "missing";
-      }
-      if (destBad)
-        throw new CliError(`Couldn't move the download into ${opts.dest}.`);
-    }
-  } finally {
-    rmSync(stage, { recursive: true, force: true });
-  }
-};
-
-// src/hosts/matcTool.ts
-init_cli();
 var matcName = () => process.platform === "win32" ? "matc.exe" : "matc";
 var platformKey = () => {
   if (process.platform === "win32")
@@ -227729,7 +227962,7 @@ var applyLocalShaders = async (entries, opts) => {
   mkdirSync6(cacheDir, { recursive: true });
   const artifacts = [];
   for (const entry of shaderEntries) {
-    const text = readFileSync13(entry.absPath, "utf8");
+    const text = readFileSync14(entry.absPath, "utf8");
     const hash = shaderHash(text, matcId);
     const family = artifactFamily();
     const artifact = (platform) => `${hash}_${platform}.filamat`;
@@ -227787,7 +228020,7 @@ init_config();
 init_ignore();
 init_cli();
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync5, readFileSync as readFileSync16, statSync as statSync4, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync5, readFileSync as readFileSync17, statSync as statSync4, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { basename as basename4, dirname as dirname11, join as join19, resolve as resolve5 } from "node:path";
 init_compile();
@@ -228036,7 +228269,7 @@ var readJson2 = (path) => {
   if (!existsSync16(path))
     return null;
   try {
-    return JSON.parse(readFileSync16(path, "utf8").replace(/^\uFEFF/, ""));
+    return JSON.parse(readFileSync17(path, "utf8").replace(/^\uFEFF/, ""));
   } catch {
     throw new CliError(`Invalid JSON in ${path}`);
   }
@@ -228068,7 +228301,7 @@ ${tail}`);
 };
 var ensureShellIgnored = (root, dir) => {
   const ignorePath = join19(root, ".lecodesignore");
-  const ignore = existsSync16(ignorePath) ? readFileSync16(ignorePath, "utf8") : DEFAULT_IGNORE_FILE;
+  const ignore = existsSync16(ignorePath) ? readFileSync17(ignorePath, "utf8") : DEFAULT_IGNORE_FILE;
   if (new RegExp(`^${dir}\\/$`, "m").test(ignore))
     return;
   const comment = ignore.includes("# Native app shells") ? "" : "# Native app shells — generated by `lecodes app init`, never pushed to LeCodes.\n";
@@ -228201,7 +228434,7 @@ var localPlugin = (root, id, spec) => {
   if (!existsSync16(dir) || !statSync4(dir).isDirectory())
     throw new CliError(`Plugin "${id}": ${spec} is not a folder (${dir})`);
   const folder = basename4(dir);
-  const manifest = readManifest2(dir, folder);
+  const manifest = readManifest3(dir, folder);
   if (manifest.implements ? manifest.implements !== id : folder !== id) {
     throw new CliError(manifest.implements ? `Plugin "${id}": ${spec} implements "${manifest.implements}" — app.json names it under that plugin: "${manifest.implements}": { "<platform>": "${spec}" }` : `Plugin "${id}": ${spec} is the plugin "${folder}" — app.json names a plugin of the project by its folder's name`);
   }
@@ -228212,7 +228445,7 @@ var localPluginKey = (root, spec) => {
   const dir = resolve5(root, spec.startsWith("file:") ? spec.slice("file:".length) : spec);
   if (!existsSync16(join19(dir, "lecodes-plugin.json")))
     return basename4(dir);
-  return readManifest2(dir, basename4(dir)).implements ?? basename4(dir);
+  return readManifest3(dir, basename4(dir)).implements ?? basename4(dir);
 };
 function resolvePlugin(id, entry, lock, platform, opts) {
   const spec = pluginSpecOf(entry, platform);
@@ -228244,7 +228477,7 @@ function resolvePlugin(id, entry, lock, platform, opts) {
   const dir = subdir ? join19(checkout.dir, subdir) : checkout.dir;
   if (!existsSync16(join19(dir, "lecodes-plugin.json")))
     throw new CliError(`Plugin "${id}": no lecodes-plugin.json in ${dir}`);
-  const manifest = readManifest2(dir, id);
+  const manifest = readManifest3(dir, id);
   fillManifestDefaults(manifest, id);
   if (!manifest[platform]) {
     if (opts?.optional)
@@ -228435,7 +228668,7 @@ var buildBundle = async (bundle, opts = {}) => {
       warnErr(ambiguous);
   }
   const serverUrl = await opts.backend?.start(entries, (w) => warnings.push(w));
-  const js = await compileProject2({
+  const { js, bakes } = await compileProjectBundle({
     entries,
     name,
     publicUrl,
@@ -228456,7 +228689,7 @@ var buildBundle = async (bundle, opts = {}) => {
   const resources = entries.filter((e) => e.type === "resource").map((e) => ({ path: e.path.replace(/^\//, ""), name: localNames.get(e.path) ?? e.path.split(/[\\/]/).pop() ?? e.path, absPath: e.absPath, remote: !!e.remote }));
   for (const artifact of stagedShaders)
     resources.push({ path: artifact.name, name: artifact.name, absPath: artifact.absPath, remote: false, shader: true });
-  return { js, resources };
+  return { js, resources, bakes: bakes.map((b) => ({ path: b.path, absPath: resolve6(root, b.path), exists: b.exists })) };
 };
 
 // src/commands/app/index.ts
@@ -229431,13 +229664,13 @@ init_compile();
 init_manifest();
 import { execFileSync as execFileSync2, spawn, spawnSync as spawnSync5 } from "node:child_process";
 import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync, cpSync, existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync21, readdirSync as readdirSync6, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync15 } from "node:fs";
+import { chmodSync, cpSync, existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync22, readdirSync as readdirSync6, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync15 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { basename as basename7, dirname as dirname15, join as join23, relative as relative4, resolve as resolve10 } from "node:path";
 init_cli();
 
 // src/project/env.ts
-import { appendFileSync, existsSync as existsSync17, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
+import { appendFileSync, existsSync as existsSync17, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { dirname as dirname12, join as join20, resolve as resolve7 } from "node:path";
 var KEY_RE = /^(LECODES|CREATOR)_[A-Z0-9_]+$/;
@@ -229505,7 +229738,7 @@ var loadProjectEnv = (cwd = process.cwd()) => {
     const file = join20(root, ".env");
     if (!existsSync17(file))
       return [];
-    const added = applyDotEnv(parseDotEnv(readFileSync17(file, "utf8")), root, process.env);
+    const added = applyDotEnv(parseDotEnv(readFileSync18(file, "utf8")), root, process.env);
     for (const [k, v] of Object.entries(added))
       process.env[k] = v;
     return Object.keys(added);
@@ -229516,7 +229749,7 @@ var loadProjectEnv = (cwd = process.cwd()) => {
 var upsertDotEnv = (root, entries) => {
   const touched = [];
   const envPath = join20(root, ".env");
-  let content = existsSync17(envPath) ? readFileSync17(envPath, "utf8") : "";
+  let content = existsSync17(envPath) ? readFileSync18(envPath, "utf8") : "";
   for (const [key, value] of Object.entries(entries)) {
     const line = `${key}=${value}`;
     const re = new RegExp(`^(?:export\\s+)?${key}\\s*=.*$`, "m");
@@ -229531,7 +229764,7 @@ var upsertDotEnv = (root, entries) => {
   writeFileSync12(envPath, content);
   touched.push(".env");
   const ignorePath = join20(root, ".gitignore");
-  const ignore = existsSync17(ignorePath) ? readFileSync17(ignorePath, "utf8") : "";
+  const ignore = existsSync17(ignorePath) ? readFileSync18(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l) => l.trim() === ".env")) {
     appendFileSync(ignorePath, `${!ignore || ignore.endsWith(`
@@ -229544,7 +229777,7 @@ var upsertDotEnv = (root, entries) => {
 };
 
 // src/commands/app/icon.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
 import { dirname as dirname13, join as join21, resolve as resolve8 } from "node:path";
 
 // ../../sdk/src/canvas/gen/cssColor.ts
@@ -230088,7 +230321,7 @@ var restampManifestIcon = (androidDir) => {
   const path = join21(androidDir, "app", "src", "main", "AndroidManifest.xml");
   if (!existsSync19(path))
     return;
-  const content = readFileSync18(path, "utf8");
+  const content = readFileSync19(path, "utf8");
   if (content.includes(`android:icon="@mipmap/ic_launcher"`))
     return;
   if (!/android:icon="[^"]*"/.test(content)) {
@@ -230100,7 +230333,7 @@ var restampManifestIcon = (androidDir) => {
 };
 
 // src/commands/app/splash.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, rmSync as rmSync3, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync20, rmSync as rmSync3, writeFileSync as writeFileSync14 } from "node:fs";
 import { dirname as dirname14, join as join22, resolve as resolve9 } from "node:path";
 init_cli();
 
@@ -230978,7 +231211,7 @@ var androidSplashThemeHint = (androidDir) => {
   const path = join22(androidDir, "app", "src", "main", "res", "values", "themes.xml");
   if (!existsSync20(path))
     return null;
-  const xml = readFileSync19(path, "utf8");
+  const xml = readFileSync20(path, "utf8");
   const style = /<style\b[^>]*\bname="Theme\.LeCodesApp"[^>]*?(?:\/>|>([\s\S]*?)<\/style>)/.exec(xml);
   if (!style) {
     return /\bparent="Theme\.LeCodesRuntime"/.test(xml) ? null : `app/src/main/res/values/themes.xml: the app's theme needs parent="Theme.LeCodesRuntime" and no android:windowBackground of its own for the splash to show — see "Splash screen" in android/README.md`;
@@ -231346,13 +231579,13 @@ if "%OS%"=="Windows_NT" endlocal
 // src/commands/app/play.ts
 init_cli();
 import { sign } from "node:crypto";
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 var SCOPE = "https://www.googleapis.com/auth/androidpublisher";
 var apiBase = () => process.env.LECODES_PLAY_API_URL ?? "https://androidpublisher.googleapis.com";
 var readServiceAccount = (path) => {
   let key;
   try {
-    key = JSON.parse(readFileSync20(path, "utf8"));
+    key = JSON.parse(readFileSync21(path, "utf8"));
   } catch {
     throw new CliError(`${path} is not a JSON key file.`);
   }
@@ -231432,7 +231665,7 @@ var shellSdkVersionAndroid = (androidDir) => {
   const path = join23(androidDir, "lecodes-runtime", "build.gradle.kts");
   if (!existsSync21(path))
     return null;
-  const m = /io\.letary:lecodes-sdk(?:-(?:core|2d|3d))?:(\d+\.\d+\.\d+)@aar/.exec(readFileSync21(path, "utf8"));
+  const m = /io\.letary:lecodes-sdk(?:-(?:core|2d|3d))?:(\d+\.\d+\.\d+)@aar/.exec(readFileSync22(path, "utf8"));
   return m ? m[1] : null;
 };
 var GRADLE_WRAPPER_JAR_URL = "https://raw.githubusercontent.com/gradle/gradle/v8.13.0/gradle/wrapper/gradle-wrapper.jar";
@@ -231440,7 +231673,7 @@ var GRADLE_WRAPPER_JAR_SHA256 = "81a82aaea5abcc8ff68b3dfcb58b3c3c429378efd98e743
 var ensureGradleWrapperJar = async () => {
   const cached = join23(homedir8(), ".lecodes", "gradle-wrapper", GRADLE_VERSION, "gradle-wrapper.jar");
   if (existsSync21(cached))
-    return new Uint8Array(readFileSync21(cached));
+    return new Uint8Array(readFileSync22(cached));
   try {
     const res = await fetch(GRADLE_WRAPPER_JAR_URL);
     if (!res.ok)
@@ -231571,7 +231804,7 @@ var syncAndroid = async (root, config, prior) => {
     resources = prior.resources;
   } else {
     resources = await compileShell(join23(assetsDir, "app.js"), { remotePatterns });
-    bundleJs = readFileSync21(join23(assetsDir, "app.js"), "utf8");
+    bundleJs = readFileSync22(join23(assetsDir, "app.js"), "utf8");
   }
   const requestedVariant = config.android?.variant ?? "auto";
   if (requestedVariant !== "auto" && !ANDROID_SDK_VARIANTS.includes(requestedVariant)) {
@@ -231716,7 +231949,7 @@ var restampManifestBlock = (androidDir, tag, block, what, missing, after = []) =
   const path = join23(androidDir, "app", "src", "main", "AndroidManifest.xml");
   if (!existsSync21(path))
     return;
-  const content = readFileSync21(path, "utf8");
+  const content = readFileSync22(path, "utf8");
   const tagged = new RegExp(`\\n[ \\t]*<!-- lecodes:${tag}[\\s\\S]*?<!-- \\/lecodes:${tag} -->`);
   let next;
   if (tagged.test(content))
@@ -231745,7 +231978,7 @@ var restampAppBuildGradle = (androidDir, config, gradlePlugins) => {
     warn("android/app/build.gradle.kts is missing — run `lecodes app init android` on a clean tree to regenerate the shell.");
     return;
   }
-  let content = readFileSync21(path, "utf8");
+  let content = readFileSync22(path, "utf8");
   const before = content;
   const versionName = config.version ?? "1.0.0";
   const versionCode = config.android?.versionCode ?? 1;
@@ -231958,7 +232191,7 @@ var uploadAndroid = async (flags) => {
   const token = await serviceAccountToken(key);
   const { versionCode } = await uploadToPlay(token, {
     packageName,
-    aab: readFileSync21(aabPath),
+    aab: readFileSync22(aabPath),
     track: flags.track,
     status: flags.draft ? "draft" : "completed"
   });
@@ -231987,7 +232220,7 @@ var ANDROID_SIGNING_ENV = {
 };
 var readProperties = (path) => {
   const out = {};
-  for (const raw of readFileSync21(path, "utf8").split(/\r?\n/)) {
+  for (const raw of readFileSync22(path, "utf8").split(/\r?\n/)) {
     const line = raw.trim();
     if (!line || line.startsWith("#") || line.startsWith("!"))
       continue;
@@ -232087,7 +232320,7 @@ var writeSigningConfig = (root, config, storeFile, alias, storePassword, keyPass
   const rel = relative4(root, storeFile);
   if (rel && !rel.startsWith("..") && !rel.includes(":") && !rel.replace(/\\/g, "/").startsWith("android/")) {
     const ignorePath = join23(root, ".gitignore");
-    const ignore = existsSync21(ignorePath) ? readFileSync21(ignorePath, "utf8") : "";
+    const ignore = existsSync21(ignorePath) ? readFileSync22(ignorePath, "utf8") : "";
     if (!ignore.split(`
 `).some((l) => l.trim() === "*.keystore")) {
       writeFileSync15(ignorePath, ignore + (!ignore || ignore.endsWith(`
@@ -232325,10 +232558,10 @@ var doctorAndroidChecks = async (root, config, check) => {
   }
   if (config.update) {
     const manifest = join23(androidDir, "lecodes-runtime", "src", "main", "AndroidManifest.xml");
-    check(existsSync21(manifest) && readFileSync21(manifest, "utf8").includes("io.letary.lecodes.UPDATE_URL"), "OTA update URL in the runtime manifest", "run `lecodes app sync`", false);
+    check(existsSync21(manifest) && readFileSync22(manifest, "utf8").includes("io.letary.lecodes.UPDATE_URL"), "OTA update URL in the runtime manifest", "run `lecodes app sync`", false);
     const appSrc = join23(androidDir, "app", "src", "main", "java");
     const kt = existsSync21(appSrc) ? readdirSync6(appSrc, { recursive: true }).map(String).filter((f) => f.endsWith(".kt")) : [];
-    const sources = kt.map((f) => readFileSync21(join23(appSrc, f), "utf8"));
+    const sources = kt.map((f) => readFileSync22(join23(appSrc, f), "utf8"));
     const boots = sources.some((src) => src.includes("LeCodesShell.boot"));
     check(boots, "App code launches via the updater (LeCodesShell.boot)", 'no app/src/main/java/**/*.kt calls LeCodesShell.boot(engine, activity) — downloaded updates would never run; see "Over-the-air updates" in android/README.md for the AppViewModel snippet', false);
     const waits = sources.some((src) => /LeCodesShell\.boot\(\s*engine\s*,\s*activity\b/.test(src));
@@ -232348,7 +232581,7 @@ var doctorAndroidChecks = async (root, config, check) => {
   }
   check(!!findKeytool(), "keytool", "install a JDK or set JAVA_HOME (`lecodes app keystore …` needs it)", false);
   const appGradle = join23(androidDir, "app", "build.gradle.kts");
-  const gradleText = existsSync21(appGradle) ? readFileSync21(appGradle, "utf8") : "";
+  const gradleText = existsSync21(appGradle) ? readFileSync22(appGradle, "utf8") : "";
   check(gradleText.includes("abiFilters"), "abiFilters in app/build.gradle.kts", 'add `ndk { abiFilters += listOf("arm64-v8a", "armeabi-v7a") }` to defaultConfig — x86_64 devices crash at launch without it', false);
   check(["isMinifyEnabled", "isShrinkResources"].every((k) => new RegExp(`${k} = (true|false)`).test(gradleText)), "R8 block in app/build.gradle.kts", 'shell predates R8-by-default — see android/README.md "Building"', false);
   if (Object.keys(config.plugins ?? {}).includes("push")) {
@@ -232362,11 +232595,12 @@ import { cpSync as cpSync3, existsSync as existsSync24, mkdirSync as mkdirSync15
 import { basename as basename9, dirname as dirname16, join as join26, resolve as resolve13 } from "node:path";
 
 // src/hosts/desktopRenderer.ts
+init_releases();
+init_cli();
 import { execFileSync as execFileSync3, spawn as spawn2, spawnSync as spawnSync6 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, readdirSync as readdirSync7, readFileSync as readFileSync22, rmSync as rmSync5, statSync as statSync6, writeFileSync as writeFileSync16, linkSync } from "node:fs";
+import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, readdirSync as readdirSync7, readFileSync as readFileSync23, rmSync as rmSync5, statSync as statSync6, writeFileSync as writeFileSync16, linkSync } from "node:fs";
 import { homedir as homedir9, tmpdir as tmpdir2 } from "node:os";
 import { delimiter, join as join24, resolve as resolve11 } from "node:path";
-init_cli();
 
 // ../../renderers/web-shared/src/sourcemapError.ts
 var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -232508,7 +232742,7 @@ var installedDesktopVersions = () => {
 };
 var selectedDesktopVersion = () => {
   try {
-    const saved = JSON.parse(readFileSync22(currentFile(), "utf8")).version;
+    const saved = JSON.parse(readFileSync23(currentFile(), "utf8")).version;
     if (saved && /^\d+\.\d+\.\d+/.test(saved) && semverNewer(DESKTOP_RENDERER_VERSION, saved) > 0)
       return saved;
   } catch {}
@@ -233630,7 +233864,7 @@ var shellSdkVersion = (iosDir) => {
   const path = join27(iosDir, "LeCodesRuntime", "Package.swift");
   if (!existsSync25(path))
     return null;
-  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"(\d+\.\d+\.\d+)(?:-(?:core|2d|3d))?"/.exec(readFileSync23(path, "utf8"));
+  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"(\d+\.\d+\.\d+)(?:-(?:core|2d|3d))?"/.exec(readFileSync24(path, "utf8"));
   return m && VERSION_RE.test(m[1]) ? m[1] : null;
 };
 var IOS_SDK_OPTS = { repo: SDK_REPO, minVersion: SDK_MIN_VERSION, configKey: "ios.sdk" };
@@ -233836,7 +234070,7 @@ var syncIos = async (root, config) => {
   rmSync8(resourcesDir, { recursive: true, force: true });
   mkdirSync16(resourcesDir, { recursive: true });
   const resources = await compileShell(join27(resourcesDir, "app.js"), { remotePatterns });
-  const bundleJs = readFileSync23(join27(resourcesDir, "app.js"), "utf8");
+  const bundleJs = readFileSync24(join27(resourcesDir, "app.js"), "utf8");
   const { variant, why } = resolveVariant(requestedVariant, bundleJs);
   log(`${c.green("variant")}   ${variant}${requestedVariant === "auto" ? ` (auto: ${why})` : " (forced by ios.variant)"}`);
   const sdkWhy = sdkPin === "latest" ? "latest" : config.ios.sdk ? "pinned by ios.sdk" : "from the shell — set ios.sdk or run `lecodes app update`";
@@ -233902,7 +234136,7 @@ var syncIos = async (root, config) => {
   if (pluginSpecs.length > 0 || existsSync25(lockPath))
     writeJson(lockPath, { plugins: newLock });
   const pbxPath = join27(iosDir, "App.xcodeproj", "project.pbxproj");
-  let pbx = readFileSync23(pbxPath, "utf8").replace(/MARKETING_VERSION = [^;]+;/g, `MARKETING_VERSION = ${config.version ?? "1.0.0"};`).replace(/CURRENT_PROJECT_VERSION = [^;]+;/g, `CURRENT_PROJECT_VERSION = ${config.ios.buildNumber ?? 1};`);
+  let pbx = readFileSync24(pbxPath, "utf8").replace(/MARKETING_VERSION = [^;]+;/g, `MARKETING_VERSION = ${config.version ?? "1.0.0"};`).replace(/CURRENT_PROJECT_VERSION = [^;]+;/g, `CURRENT_PROJECT_VERSION = ${config.ios.buildNumber ?? 1};`);
   const mergedEntitlements = {};
   const appLinks = appLinksOf(config);
   if (appLinks.length) {
@@ -234194,8 +234428,8 @@ var doctorIosChecks = async (root, config, check) => {
   const validVariant = requestedVariant === "auto" || SDK_VARIANTS.includes(requestedVariant);
   check(validVariant, `ios.variant "${requestedVariant}"`, `use "auto" or one of ${SDK_VARIANTS.join(", ")}`);
   if (existsSync25(bundle) && validVariant) {
-    const { variant } = resolveVariant(requestedVariant, readFileSync23(bundle, "utf8"));
-    const pkg = readFileSync23(join27(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
+    const { variant } = resolveVariant(requestedVariant, readFileSync24(bundle, "utf8"));
+    const pkg = readFileSync24(join27(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
     const tag = /lecodes-ios-sdk\.git",\s*exact:\s*"([^"]+)"/.exec(pkg)?.[1] ?? "";
     const tagVariant = /-(core|2d|3d)$/.exec(tag)?.[1] ?? "full";
     check(tagVariant === variant, `SDK variant ${variant}`, "run `lecodes app sync`");
@@ -234217,25 +234451,25 @@ var doctorIosChecks = async (root, config, check) => {
   const inSync = wanted.every((id) => lock[id]) && Object.keys(lock).every((id) => wanted.includes(id));
   check(wanted.length === 0 || inSync, "Plugins synced", "run `lecodes app sync`");
   const pbxFile = join27(root, "ios", "App.xcodeproj", "project.pbxproj");
-  if (existsSync25(pbxFile) && readFileSync23(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
+  if (existsSync25(pbxFile) && readFileSync24(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
     check(existsSync25(join27(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
   }
   if (wanted.includes("push")) {
     const runtimeSwift = join27(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
-    const baked = existsSync25(runtimeSwift) && readFileSync23(runtimeSwift, "utf8").includes("bootProjectUuid");
+    const baked = existsSync25(runtimeSwift) && readFileSync24(runtimeSwift, "utf8").includes("bootProjectUuid");
     check(baked, "Push world identity baked", `without it Push.register() rejects "unavailable" — needs a pushed project (uuid), lecodes-ios-sdk ${SDK_IDENTITY_VERSION}+ and \`lecodes app sync\``, false);
   }
   if (config.update) {
-    const plist = readFileSync23(join27(root, "ios", "App", "Info.plist"), "utf8");
+    const plist = readFileSync24(join27(root, "ios", "App", "Info.plist"), "utf8");
     check(plist.includes("<key>LeCodesUpdateURL</key>"), "OTA update URL in Info.plist", "run `lecodes app sync`", false);
     const appDir = join27(root, "ios", "App");
-    const swift = readdirSync10(appDir).filter((f) => f.endsWith(".swift")).map((f) => readFileSync23(join27(appDir, f), "utf8"));
+    const swift = readdirSync10(appDir).filter((f) => f.endsWith(".swift")).map((f) => readFileSync24(join27(appDir, f), "utf8"));
     const launchesViaUpdater = swift.some((t) => t.includes("LeCodesAppViewController") || t.includes("LeCodesUpdater.activeBundle"));
     check(launchesViaUpdater, "App code launches via the updater", `no App/*.swift subclasses LeCodesAppViewController or calls LeCodesUpdater.activeBundle() — downloaded updates would never run; see "Over-the-air updates" in ios/README.md`, false);
   }
   {
     const vc = join27(root, "ios", "App", "ViewController.swift");
-    const is2x = !existsSync25(vc) || readFileSync23(vc, "utf8").includes("LeCodesAppViewController");
+    const is2x = !existsSync25(vc) || readFileSync24(vc, "utf8").includes("LeCodesAppViewController");
     check(is2x, "App/ViewController.swift is the 2.x shell (LeCodesAppViewController)", "a 1.x shell's App/*.swift: replace AppDelegate.swift, SceneDelegate.swift and ViewController.swift with the ones `lecodes app init ios` writes today (your own code goes into ViewController.configure(_:))", false);
   }
   const asc = readJson2(join27(homedir10(), ".lecodes", "asc.json"));
@@ -234465,10 +234699,11 @@ var app_default = defineCommand({
 init_cli();
 
 // src/hosts/cmgenTool.ts
+init_releases();
+init_cli();
 import { existsSync as existsSync26, readdirSync as readdirSync11 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { join as join28, resolve as resolve15 } from "node:path";
-init_cli();
 var exeName2 = () => process.platform === "win32" ? "cmgen.exe" : "cmgen";
 var platformKey3 = () => {
   if (process.platform === "win32")
@@ -234652,6 +234887,7 @@ lecodes render --sim --script <file>      # the WINDOWLESS native host (lecodes-
                                   # engines, no GPU, no pixels, no UI hit-test — expect.log /
                                   # expect.paint only; runs on CI and beside an open desktop window
 lecodes test                      # all tests/*.flow.json + design-derived flows; run before "done"
+bunx -p typescript tsc --noEmit   # typecheck against .lecodes/types (the SDK's globals); also before "done"
 lecodes test --desktop            # the file flows on the NATIVE host (design flows stay headless)
 lecodes test --sim                # the windowless twin: coordinates + expect.log / expect.paint only
 lecodes dev --android --time 12 --png phone.png   # the REAL phone over adb (USB): launches the app on
@@ -234775,9 +235011,9 @@ fetch the docs — they are served as raw markdown for AI tools:
   with a COOKBOOK: read the matching recipe BEFORE you design the structure.** It has the file
   layout, a skeleton per part, how to verify, and the traps already paid for (start with
   "Project architecture for a game" for any game bigger than one file).
-- https://le.codes/en/docs/api/<area>/<page>.md — one reference page as raw markdown
+- https://le.codes/docs/api/<area>/<page>.md — one reference page as raw markdown
   (e.g. \`ui/styling.md\`, \`2d/scene2d.md\`, \`3d/scene.md\`, \`runtime/storage.md\`)
-- https://le.codes/en/docs/guide/<page>.md — guide pages (project anatomy, CLI, tracks)
+- https://le.codes/docs/guide/<page>.md — guide pages (project anatomy, CLI, tracks)
 - https://le.codes/llms-full.txt — everything in one file (large; prefer per-page)
 
 Always fetch the \`.md\` URLs — the HTML routes are a JS app and return an empty shell.
@@ -235575,7 +235811,7 @@ var desktop_default = defineCommand({
 
 // src/commands/dev.ts
 init_manifest();
-import { existsSync as existsSync38, mkdirSync as mkdirSync22, readFileSync as readFileSync32, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync22, readFileSync as readFileSync33, writeFileSync as writeFileSync25 } from "node:fs";
 import { randomBytes as randomBytes5 } from "node:crypto";
 import { networkInterfaces } from "node:os";
 import { basename as basename15, join as join43 } from "node:path";
@@ -235583,7 +235819,7 @@ import { basename as basename15, join as join43 } from "node:path";
 // src/dev/devServer.ts
 init_localFiles();
 import { createHash as createHash8 } from "node:crypto";
-import { createReadStream as createReadStream2, readFileSync as readFileSync30, statSync as statSync11 } from "node:fs";
+import { createReadStream as createReadStream2, readFileSync as readFileSync31, statSync as statSync11 } from "node:fs";
 import { join as join39 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 init_projectCompile();
@@ -235718,7 +235954,7 @@ init_paths();
 // src/web/halves.ts
 init_compile();
 init_cli();
-import { cpSync as cpSync5, existsSync as existsSync34, readFileSync as readFileSync29 } from "node:fs";
+import { cpSync as cpSync5, existsSync as existsSync34, readFileSync as readFileSync30 } from "node:fs";
 import { join as join38, sep as sep4 } from "node:path";
 var halfModule = (half) => `plugins/${half.folder}/index.js`;
 var asCliError = (e) => new CliError(e instanceof Error ? e.message : String(e));
@@ -235729,7 +235965,7 @@ var projectHalves = (root) => {
     const folder = dir.split(sep4).pop();
     let web;
     try {
-      web = webHalfManifestOf(readFileSync29(join38(dir, MANIFEST_FILE), "utf8"), folder, id);
+      web = webHalfManifestOf(readFileSync30(join38(dir, MANIFEST_FILE), "utf8"), folder, id);
     } catch (e) {
       throw asCliError(e);
     }
@@ -235870,7 +236106,7 @@ var startDevServer = async (options) => {
   const liteTable = () => {
     let plugins = {};
     try {
-      plugins = JSON.parse(readFileSync30(join39(lite, "plugins.json"), "utf8")).plugins ?? {};
+      plugins = JSON.parse(readFileSync31(join39(lite, "plugins.json"), "utf8")).plugins ?? {};
     } catch {}
     const table = { ...plugins };
     for (const { half, hash } of halves) {
@@ -236361,7 +236597,7 @@ var androidCrashLines = (session) => {
 
 // src/dev/iosDev.ts
 init_cli();
-import { existsSync as existsSync37, readdirSync as readdirSync17, readFileSync as readFileSync31, statSync as statSync13, unlinkSync } from "node:fs";
+import { existsSync as existsSync37, readdirSync as readdirSync17, readFileSync as readFileSync32, statSync as statSync13, unlinkSync } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { join as join42 } from "node:path";
 import { spawnSync as spawnSync10 } from "node:child_process";
@@ -236394,7 +236630,7 @@ var listDevices2 = () => {
   if (!ok || !existsSync37(tmp))
     return [];
   try {
-    const json = JSON.parse(readFileSync31(tmp, "utf8"));
+    const json = JSON.parse(readFileSync32(tmp, "utf8"));
     return (json.result?.devices ?? []).map((d) => ({
       udid: d.identifier,
       name: d.deviceProperties?.name ?? d.identifier,
@@ -236441,7 +236677,7 @@ var deviceHasApp = (udid, bundleId) => {
   if (!ok || !existsSync37(tmp))
     return false;
   try {
-    const json = JSON.parse(readFileSync31(tmp, "utf8"));
+    const json = JSON.parse(readFileSync32(tmp, "utf8"));
     return (json.result?.apps ?? []).some((a) => a.bundleIdentifier === bundleId);
   } catch {
     return false;
@@ -236481,7 +236717,7 @@ var launchOnIos = (opts) => {
     if (!start.ok)
       throw new CliError(`Could not launch ${bundleId} on ${target.name}: ${start.out}`);
     try {
-      const json = JSON.parse(readFileSync31(tmp, "utf8"));
+      const json = JSON.parse(readFileSync32(tmp, "utf8"));
       pid = json.result?.process?.processIdentifier?.toString() ?? null;
     } catch {
       pid = null;
@@ -236553,7 +236789,7 @@ var lanCandidates = () => {
 var loadDevToken = (root) => {
   const path = join43(root, LECODES_DIR, "dev.json");
   try {
-    const token = JSON.parse(readFileSync32(path, "utf8")).token;
+    const token = JSON.parse(readFileSync33(path, "utf8")).token;
     if (token && /^[a-z0-9]{8,}$/.test(token))
       return token;
   } catch {}
@@ -236788,7 +237024,7 @@ init_api();
 
 // src/platform/serverDiff.ts
 init_localFiles();
-import { readFileSync as readFileSync33 } from "node:fs";
+import { readFileSync as readFileSync34 } from "node:fs";
 var isTextAsset = (t) => t === "text" || t === "shader" || t === "scene";
 var computeServerDiff = (project, scan) => {
   const pathById = buildPaths(project.assets);
@@ -236806,7 +237042,7 @@ var computeServerDiff = (project, scan) => {
     const local = localByPath.get(path);
     if (local && !server2) {
       const text = isTextKind(local.kind);
-      entries.push({ path, status: "added", binary: !text, serverText: "", localText: text ? readFileSync33(local.absPath, "utf8") : undefined });
+      entries.push({ path, status: "added", binary: !text, serverText: "", localText: text ? readFileSync34(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server2 && !local) {
@@ -236817,12 +237053,12 @@ var computeServerDiff = (project, scan) => {
     if (server2 && local) {
       if (isTextAsset(server2.type)) {
         const serverText = server2.text ?? "";
-        const localText = readFileSync33(local.absPath, "utf8");
+        const localText = readFileSync34(local.absPath, "utf8");
         if (serverText !== localText)
           entries.push({ path, status: "modified", binary: false, serverText, localText });
       } else {
         const serverSize = server2.file?.size;
-        const localSize = Buffer.byteLength(readFileSync33(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync34(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path, status: "modified", binary: true });
         }
@@ -237154,7 +237390,7 @@ var init3 = (dir, forDesktop) => {
 // src/commands/install.ts
 init_cli();
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync6, existsSync as existsSync40, mkdirSync as mkdirSync24, readFileSync as readFileSync34, realpathSync as realpathSync2, rmSync as rmSync11, symlinkSync as symlinkSync2 } from "node:fs";
+import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync6, existsSync as existsSync40, mkdirSync as mkdirSync24, readFileSync as readFileSync35, realpathSync as realpathSync2, rmSync as rmSync11, symlinkSync as symlinkSync2 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 import { basename as basename17, delimiter as delimiter2, dirname as dirname22, join as join45, resolve as resolve21 } from "node:path";
 var isWin = process.platform === "win32";
@@ -237208,7 +237444,7 @@ var appendPathToShellRc = (binDir) => {
   const { file, name } = shellRc();
   const line = `export PATH="${binDir}:$PATH"`;
   try {
-    const existing = existsSync40(file) ? readFileSync34(file, "utf8") : "";
+    const existing = existsSync40(file) ? readFileSync35(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -237330,9 +237566,9 @@ var install_default = defineCommand({
 });
 
 // src/commands/lightmap.ts
-import { closeSync, existsSync as existsSync41, mkdirSync as mkdirSync25, mkdtempSync as mkdtempSync4, openSync, readFileSync as readFileSync35, readSync, rmSync as rmSync12, statSync as statSync14, writeFileSync as writeFileSync27 } from "node:fs";
+import { closeSync, existsSync as existsSync41, mkdirSync as mkdirSync25, mkdtempSync as mkdtempSync4, openSync, readdirSync as readdirSync18, readFileSync as readFileSync36, readSync, rmSync as rmSync12, writeFileSync as writeFileSync27 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename18, join as join46, relative as relative7, resolve as resolve22 } from "node:path";
+import { basename as basename18, dirname as dirname23, join as join46, relative as relative7, resolve as resolve22, sep as sep5 } from "node:path";
 import { deflateSync } from "node:zlib";
 init_peerInstall();
 init_cli();
@@ -237345,7 +237581,7 @@ var range = (name, value, min, max) => {
 var readBake = (file) => {
   if (!existsSync41(file))
     throw new CliError(`No bake at ${file} — run \`lecodes lightmap bake\` first.`);
-  const data = JSON.parse(readFileSync35(file, "utf8"));
+  const data = JSON.parse(readFileSync36(file, "utf8"));
   if (data.version !== 4)
     throw new CliError(`${file} is not a creator-bake file (version ${String(data.version)}) — rebake.`);
   return data;
@@ -237381,54 +237617,47 @@ var cubePatternsOf = (argv) => {
   }
   return out.filter((p) => p !== "");
 };
-var placeholderBake = (stem) => JSON.stringify({ version: 4, placeholder: true, size: 4, pages: 0, texel: 0, lightScale: 0, light: [`${stem}-light.ktx2`], aux: [`${stem}-aux.ktx2`], instances: [] }) + `
-`;
-var ktx2Placeholder = (vkFormat) => {
-  const raw = Buffer.alloc(vkFormat === 143 ? 16 : 64);
-  const dfdSize = 44;
-  const dfdOffset = 80 + 24;
-  const b = Buffer.alloc(dfdOffset + dfdSize + raw.length);
-  Buffer.from([171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10]).copy(b, 0);
-  let o = 12;
-  for (const v of [vkFormat, 1, 4, 4, 0, 0, 1, 1, 0]) {
-    b.writeUInt32LE(v, o);
-    o += 4;
-  }
-  b.writeUInt32LE(dfdOffset, o);
-  b.writeUInt32LE(dfdSize, o + 4);
-  o += 8;
-  b.writeUInt32LE(0, o);
-  b.writeUInt32LE(0, o + 4);
-  o += 8;
-  b.writeBigUInt64LE(0n, o);
-  b.writeBigUInt64LE(0n, o + 8);
-  o += 16;
-  b.writeBigUInt64LE(BigInt(dfdOffset + dfdSize), o);
-  b.writeBigUInt64LE(BigInt(raw.length), o + 8);
-  b.writeBigUInt64LE(BigInt(raw.length), o + 16);
-  o += 24;
-  b.writeUInt32LE(dfdSize, o);
-  raw.copy(b, dfdOffset + dfdSize);
-  return b;
+var stemOf = (path) => basename18(path).replace(/\.bake$/i, "");
+var pickTarget2 = (bakes, name, entry) => {
+  if (bakes.length === 0)
+    throw new CliError(`${entry} reaches no bake(): the level's scene file says where its bake goes — add \`env: { lightmap: bake('./assets/lightmap/level.bake') }\` (a hand-built scene: \`Lightmap.load(scene, bake('./assets/lightmap/level.bake'))\`).`);
+  const listed = bakes.map((b) => `${stemOf(b.path)} (${b.path})`).join(", ");
+  if (name === undefined) {
+    if (bakes.length > 1)
+      throw new CliError(`${entry} reaches ${bakes.length} bake() calls: ${listed} — pass --name <stem> to pick the level to bake.`);
+    return bakes[0];
+  }
+  const named = bakes.filter((b) => stemOf(b.path) === name);
+  if (named.length === 0)
+    throw new CliError(`--name ${name}: ${entry} reaches no bake() of that stem — it reaches ${listed}.`);
+  if (named.length > 1)
+    throw new CliError(`--name ${name}: two bake() targets share that stem (${named.map((b) => b.path).join(", ")}) — rename one.`);
+  return named[0];
 };
-var ensurePlaceholders = (outDir, stem) => {
-  const missing = (f) => !existsSync41(f) || statSync14(f).size === 0;
-  const bake = join46(outDir, `${stem}.bake`);
-  if (missing(bake))
-    writeFileSync27(bake, placeholderBake(stem));
-  const light = join46(outDir, `${stem}-light.ktx2`), aux = join46(outDir, `${stem}-aux.ktx2`), probes = join46(outDir, `${stem}-probes.ktx2`);
-  if (missing(light))
-    writeFileSync27(light, ktx2Placeholder(143));
-  if (missing(aux))
-    writeFileSync27(aux, ktx2Placeholder(37));
-  if (missing(probes))
-    writeFileSync27(probes, ktx2Placeholder(143));
-  const grid = join46(outDir, `${stem}.lgrid`);
-  if (missing(grid))
-    writeFileSync27(grid, "NONE");
-  const uv1 = join46(outDir, `${stem}-uv1.bin`);
-  if (missing(uv1))
-    writeFileSync27(uv1, "NONE");
+var findBakes = (root) => {
+  const SKIP = new Set(["node_modules", ".lightmap", ".git", ".lecodes"]);
+  const out = [];
+  const walk = (dir) => {
+    for (const e of readdirSync18(dir, { withFileTypes: true })) {
+      if (e.isDirectory()) {
+        if (!SKIP.has(e.name))
+          walk(join46(dir, e.name));
+      } else if (/\.bake$/i.test(e.name))
+        out.push(relative7(root, join46(dir, e.name)).replace(/\\/g, "/"));
+    }
+  };
+  walk(root);
+  return out.sort();
+};
+var bakeFileOf = (root, flag) => {
+  if (flag)
+    return resolve22(root, flag);
+  const found = findBakes(root);
+  if (found.length === 0)
+    throw new CliError("No .bake in the project — run `lecodes lightmap bake` first.");
+  if (found.length > 1)
+    throw new CliError(`The project has ${found.length} bakes (${found.join(", ")}) — pass --bake <file>.`);
+  return resolve22(root, found[0]);
 };
 var readGlbJson = (file) => {
   let fd;
@@ -237474,6 +237703,9 @@ var unwrapReferenced = async (js, resources, root, texel) => {
   }
   note(`Unwrapping ${raw.length} of the ${glbs.length} GLB(s) the app references — no lightmap uvs; written in place (--no-unwrap skips)…`);
   const assets = await loadPeer("lecodes-assets", "cli", { for: "lecodes lightmap bake (lightmap uvs)" });
+  if (typeof assets.unwrapGlbFiles !== "function") {
+    throw new CliError("The lecodes-assets this CLI loaded has no unwrapGlbFiles (it predates the bake's unwrap) — `lecodes update` moves it forward; --no-unwrap bakes the GLBs as they are.");
+  }
   const t0 = performance.now();
   const rel = (f) => relative7(root, f).replace(/\\/g, "/");
   const reports = await assets.unwrapGlbFiles(raw, {
@@ -237491,25 +237723,27 @@ var unwrapReferenced = async (js, resources, root, texel) => {
 var bake = defineCommand({
   name: "bake",
   summary: "Bake the sun, the sky and the lamps into a lux atlas for the level's statics",
-  description: `Runs the app in bake mode in lecodes-bake — the windowless host with the bake built in (no physics, 2D, audio, net or navmesh), downloaded on first use like the desktop host; LECODES_BAKE_EXE points at a local build (hosts/desktop build.ps1 -Bake). The statics are what the app registers with Lightmap.add (a scene file does it for every node no Physics aspect moves), the bake fires at its Lightmap.load call. Writes <out>/<name>.bake + <name>-light[_n].ktx2 (irradiance, BC6H) + <name>-aux[_n].ktx2 (sky visibility, the directional share and direction of the light) + <name>-probes.ktx2 (the reflection probes: a cubemap of the level's radiance per probe, prefiltered per roughness; --probe-spacing 0 = none). Needs a GPU with hardware ray tracing (--tracer).
+  description: `Runs the app in bake mode in lecodes-bake — the windowless host with the bake built in (no physics, 2D, audio, net or navmesh), downloaded on first use like the desktop host; LECODES_BAKE_EXE points at a local build (hosts/desktop build.ps1 -Bake). The statics are what the app registers with Lightmap.add (a scene file does it for every node no Physics aspect moves), the bake fires at its Lightmap.load call. Needs a GPU with hardware ray tracing (--tracer).
+
+Where: the level's own bake('<dir>/<stem>.bake') — env: { lightmap: bake('./assets/lightmap/level.bake') } in a scene file, the path relative to that file — names the target; nothing has to exist before the first bake. Writes into <dir>: <stem>.bake (the manifest: it names every file below, and the next compile reads it — nothing to paste into the scene) + <stem>-light[_n].ktx2 (irradiance, BC6H, a page per _n) + <stem>-aux[_n].ktx2 (sky visibility, the directional share and direction of the light) + <stem>-probes.ktx2 (the reflection probes: a cubemap of the level's radiance per probe, prefiltered per roughness; --probe-spacing 0 = none) + <stem>.lgrid (the light grid the movers read; --volume 0 = none) + <stem>-uv1.bin (the packed lightmap uv1 the rects map) + with --split <stem>-direct[_n].ktx2 / <stem>-indirect[_n].ktx2.
 
 Lightmap UVs: the GLBs the app references that have none (TEXCOORD_1) are unwrapped first, IN PLACE — the same as lecodes assets unwrap, run on just those files; a file that has them is left alone, --no-unwrap skips the step. A whole level in one GLB that wants --groups / --zone is unwrapped by hand first (lecodes assets unwrap --help).`,
   flags: {
-    out: str("where the atlas lands", { value: "<dir>", default: "assets/lightmap" }),
-    name: str("file stem — one per baked level", { value: "<stem>", default: "lightmap" }),
+    out: str("write the files into this folder instead of next to the level's .bake (a second seed for `lightmap diff`)", { value: "<dir>" }),
+    name: str("bake the level whose bake() names <stem>.bake — when the entry reaches several", { value: "<stem>" }),
     ...bundleFlags,
-    entry: str("the file that builds the scene and calls Lightmap.load", { value: "<file>", default: "main.ts" }),
+    entry: str("the file that opens the level (it reaches the bake() that names the target)", { value: "<file>", default: "main.ts" }),
     size: num("atlas page edge (texels)", { default: 4096 }),
     texel: num("texel size (m); the bake coarsens only when the pages are full", { default: 0.05 }),
     pages: num("atlas pages to fill before the bake coarsens the texel", { default: 4 }),
     "sun-rays": num("shadow rays into the sun's disc per texel", { default: 64 }),
-    "sky-rays": num("hemisphere rays per texel (the sky's irradiance and visibility). 2048 (2026-09-16): shadow rays are cheap (the school's direct pass 2 s a page) and a texel deep in a corridor sees the sky through a far window with 1 ray in 256 — every hit was 410 lux", { default: 2048 }),
-    "light-rays": num("shadow rays per lamp per texel (64: at 32 the school's lamp layer read 43 % noise between two seeds, the ceilings and doors next to a lamp 48 %)", { default: 64 }),
-    "bounce-rays": num("bounce paths per texel; 0 = direct light only. 128 (2026-09-16): a dark room's floor in the school reads 240 % noise at 64, 160 % at 128, 130 % at 256 — the last doubling costs 2x the bake time for little", { default: 128 }),
+    "sky-rays": num("hemisphere rays per texel (the sky's irradiance and visibility). 2048 (2026-09-16): shadow rays are cheap (an interior level's direct pass: 2 s a page) and a texel deep in a corridor sees the sky through a far window with 1 ray in 256 — every hit was 410 lux", { default: 2048 }),
+    "light-rays": num("shadow rays per lamp per texel (64: at 32 an interior level's lamp layer read 43 % noise between two seeds, the ceilings and doors next to a lamp 48 %)", { default: 64 }),
+    "bounce-rays": num("bounce paths per texel; 0 = direct light only. 128 (2026-09-16): a dark room's floor of an interior level reads 240 % noise at 64, 160 % at 128, 130 % at 256 — the last doubling costs 2x the bake time for little", { default: 128 }),
     bounces: num("path vertices at most (Russian roulette from the third); 0 = direct light only", { default: 3 }),
     "patch-samples": num("next-event samples per texel over the BRIGHT PATCHES of a first direct pass (sunlit floors, the ceiling around a lamp) — what keeps the bounce in dark rooms from arriving as impulses (every path vertex takes one more); 0 = the cosine paths alone", { default: 64 }),
-    split: bool('also write <name>-direct[_n].ktx2 / <name>-indirect[_n].ktx2 — the pages the "direct" / "indirect" views bind (list them as env.lightmap.direct / .indirect)'),
-    denoise: str("the AI denoiser (--denoiser) over: indirect = the bounce alone (the range 2026-09-16: bounce noise 57 % -> 23 % of the mean, per-instance means unchanged), no-sun = + the sky and the lamps (the sky through a small opening: 0..3 hits of 256 rays, a texel is one of four values), all = + the sun (its shadow edges too: a sunlit pillar's mean moved 6 %), none. School, two seeds: no-sun took the sky 1.8 % -> 0.5 %, the lamps 43 % -> 21 %", { value: "<none|indirect|no-sun|all>", default: "no-sun" }),
+    split: bool('also write <stem>-direct[_n].ktx2 / <stem>-indirect[_n].ktx2 — the pages the "direct" / "indirect" views bind (the manifest names them)'),
+    denoise: str("the AI denoiser (--denoiser) over: indirect = the bounce alone (an interior level, 2026-09-16: bounce noise 57 % -> 23 % of the mean, per-instance means unchanged), no-sun = + the sky and the lamps (the sky through a small opening: 0..3 hits of 256 rays, a texel is one of four values), all = + the sun (its shadow edges too: a sunlit pillar's mean moved 6 %), none. An interior level, two seeds: no-sun took the sky 1.8 % -> 0.5 %, the lamps 43 % -> 21 %", { value: "<none|indirect|no-sun|all>", default: "no-sun" }),
     tracer: str("which GPU API traces: auto = OptiX where an NVIDIA driver with OptiX opens, else Vulkan ray query — any card with hardware ray tracing (RTX, Radeon RX 6000+, Arc) with its driver alone; optix / vulkan by name (the bake fails when it cannot open)", { value: "<auto|optix|vulkan>", default: "auto" }),
     denoiser: str("which AI denoiser --denoise runs: auto = OptiX's on an NVIDIA card, else Intel Open Image Denoise (its CUDA / HIP / CPU device, the DLLs next to the host); optix / oidn by name. Independent of --tracer; one that cannot open is a warning and the pages stay as traced", { value: "<auto|optix|oidn>", default: "auto" }),
     "light-radius": num("lamps: the emitter's radius (m) — soft shadows, no 1/d² singularity", { default: 0.05 }),
@@ -237523,13 +237757,13 @@ Lightmap UVs: the GLBs the app references that have none (TEXCOORD_1) are unwrap
     "probe-indoor": bool("keep only the probes under a roof — those whose open share of the sphere (rays from the point that meet nothing) is at most 15 %, holes in the geometry or not: outdoor statics reflect the sky through their baked sky visibility instead — an environment map without the ground, but no outdoor probe can reach indoors and the atlas shrinks"),
     "probe-layout": str("rooms = every indoor point of the grid slides to the middle of its room and the points of one room merge: one probe per room, far from the walls, its box the room (stations every ~8 m along a room over 12 m), outdoor points stay on the grid; grid = everything stays on the grid. Either way the pages carry which probes each block of texels sees (rays at bake time)", { value: "<rooms|grid>", default: "rooms" }),
     "min-texels": num("instances smaller than this many ATLAS TEXELS along every axis (x --texel: 12 at 5 cm = 0.6 m) get no place in the atlas: they still cast their baked shadow and bounce, their own light is baked where they stand (six sides, no atlas texels) — cartridges, boxes, pipe elbows, a fire extinguisher: a baked shadow does not read on them and their tight charts are where the seams are. 0 = everything bakes; --dry-run lists what falls under it", { default: 12 }),
-    "thin-texels": num("ROUND AND NARROW objects leave the atlas like --min-texels: an instance none of whose lightmap charts is wider than this many texels across its short side (at --texel) — a railing's tubes, a cable, a pipe run, blinds, a gun barrel. A strip of 1-3 texels around a tube cannot hold the light's change around it and its uv seam shows as a step (the range's railing: two texels 5 mm apart on the seam, one lit, one shadowed); the ambient cube baked where it stands is smooth. A flat object has a wide chart somewhere and stays. 0 = off; --dry-run lists what falls under it", { default: 4 }),
-    cube: str(`BAKE AS CUBES BY NAME: a regular expression (ECMAScript, case-sensitive) searched in every record's key — <node path>@<ordinal>, one record per mesh of a model, so SM_pipe takes every pipe node and @1$ the second mesh of each. A record that matches leaves the atlas like a --min-texels / --thin-texels one, whatever its size or charts: an occluder whose own light is baked where it stands as ambient cubes (in slabs along a long one, --object-slab) — a pipe run, a fence, a prop whose lightmap seams show. Repeat the flag (--cube SM_pipe --cube SM_fence) or join with | in one (--cube "SM_pipe|SM_fence", quoted for the shell); a pattern that starts with - goes as --cube=<regex>. The scene's env.lightmap.cube adds its own patterns, a node's lightmap: 'cube' marks one node by hand; --dry-run lists what matches`, { value: "<regex>" }),
+    "thin-texels": num("ROUND AND NARROW objects leave the atlas like --min-texels: an instance none of whose lightmap charts is wider than this many texels across its short side (at --texel) — a railing's tubes, a cable, a pipe run, blinds, a gun barrel. A strip of 1-3 texels around a tube cannot hold the light's change around it and its uv seam shows as a step (a railing: two texels 5 mm apart on the seam, one lit, one shadowed); the ambient cube baked where it stands is smooth. A flat object has a wide chart somewhere and stays. 0 = off; --dry-run lists what falls under it", { default: 4 }),
+    cube: str(`BAKE AS CUBES BY NAME: a regular expression (ECMAScript, case-sensitive) searched in every record's key — <node path>@<ordinal>, one record per mesh of a model, so SM_pipe takes every pipe node and @1$ the second mesh of each. A record that matches leaves the atlas like a --min-texels / --thin-texels one, whatever its size or charts: an occluder whose own light is baked where it stands as ambient cubes (in slabs along a long one, --object-slab) — a pipe run, a fence, a prop whose lightmap seams show. Repeat the flag (--cube SM_pipe --cube SM_fence) or join with | in one (--cube "SM_pipe|SM_fence", quoted for the shell); a pattern that starts with - goes as --cube=<regex>. The level's bake() option cube adds its own patterns, a node's lightmap: 'cube' marks one node by hand; --dry-run lists what matches`, { value: "<regex>" }),
     "object-slab": num("A LONG object the atlas left out (--min-texels, --thin-texels, --cube) takes its light in SLABS of this many metres along the longest axis of its bounds — round(length / this) ambient cubes, 16 at most — a 6 m pipe run, a railing along a wall: one end under a lamp, the other in the dark, where one cube gave all of it the mean. The shader blends the two slabs around each pixel along that axis. 0 = one cube an object", { value: "<m>", default: 1 }),
     "emissive-nits": num("EMISSIVE SURFACES LIGHT THE LEVEL: cd/m² of emission 1.0 (emissive factor x strength x map) — every lit region of an emissive surface (a panel drawn in a ceiling's texture, a screen, a sign) bakes as a rectangle lamp. Default: what the level's camera makes of 1.0, 1.2 x 2^EV100, so a panel lights as brightly as it looks. 0 = emissive surfaces light nothing"),
     "detail-texels": num("A SMALL SURFACE GETS A FINER TEXEL: an instance whose surface is under this many atlas texels (area / texel²) is laid out denser by sqrt(this / its texels), 3x at most — a pipe of 1 m is ~300 texels at 5 cm, its charts a few texels wide and every chart edge a step; at 2000 it bakes at ~2 cm. 0 = off", { default: 2000 }),
-    volume: num("THE LIGHT GRID for movers: the cell size in metres (0.75 of it tall) — per cell in free space the baked ambient light (sky, lamps, every bounce; not the direct sun, which stays real-time on movers), links between cells a ray connects so nothing blends through a wall; written as <name>.lgrid, list it as env.lightmap.volume. 0 = none", { default: 1 }),
-    "probe-box": str("only grid cells whose centre lies inside this world box get a probe: x0,y0,z0,x1,y1,z1 in metres — keeps probes off a roof top the player never sees (the range: 79 probes above a ceiling with holes where the fixtures were bled the sky onto the walls). Default: the receivers' bounds", { value: "<x0,y0,z0,x1,y1,z1>" }),
+    volume: num("THE LIGHT GRID for movers: the cell size in metres (0.75 of it tall) — per cell in free space the baked ambient light (sky, lamps, every bounce; not the direct sun, which stays real-time on movers), links between cells a ray connects so nothing blends through a wall; written as <stem>.lgrid. 0 = none", { default: 1 }),
+    "probe-box": str("only grid cells whose centre lies inside this world box get a probe: x0,y0,z0,x1,y1,z1 in metres — keeps probes off a roof top the player never sees (79 probes above a ceiling with holes where the fixtures were bled the sky onto the walls of a level). Default: the receivers' bounds", { value: "<x0,y0,z0,x1,y1,z1>" }),
     "debug-dir": str("keep the float layers per page (PFM) here for `lightmap inspect` — gigabytes per level; a `.lightmap/` dir inside the project is skipped by the compile scan, anywhere else must be outside the project", { value: "<dir>" }),
     "dry-run": bool("only the atlas LAYOUT: pages, texel size, the largest rects — no tracing, nothing written (seconds, not minutes; the host still loads the level)"),
     frames: num("host frames to run before giving up — load headroom", { default: 900 }),
@@ -237540,14 +237774,16 @@ Lightmap UVs: the GLBs the app references that have none (TEXCOORD_1) are unwrap
     logs: bool("forward the host's output"),
     "no-unwrap": bool("leave the referenced GLBs as they are: no lightmap unwrap of those without TEXCOORD_1 (they bake without lightmap uvs)")
   },
-  examples: ["lecodes lightmap bake", "lecodes lightmap bake --entry school.ts --name school --texel 0.04 --pages 4 --debug-dir .lightmap/school --logs"],
+  examples: [
+    "lecodes lightmap bake",
+    "lecodes lightmap bake --dry-run --logs",
+    "lecodes lightmap bake --entry level2.ts --texel 0.04 --debug-dir .lightmap/level2 --logs"
+  ],
   run: async ({ flags, argv }) => {
     const { root } = localProject();
-    const outDir = resolve22(root, flags.out);
-    const stem = flags.name;
     const cube = cubePatternsOf(argv);
-    if (!/^[A-Za-z0-9_-]+$/.test(stem))
-      throw new CliError(`--name wants a plain file stem (letters, digits, - and _), got "${stem}".`);
+    if (flags.name !== undefined && !/^[A-Za-z0-9_.-]+$/.test(flags.name))
+      throw new CliError(`--name wants the stem of a .bake (its file name without .bake), got "${flags.name}".`);
     const entryFile = flags.entry;
     if (!existsSync41(resolve22(root, entryFile))) {
       throw new CliError(`No ${entryFile} in ${root} — pass --entry <file> (the file that builds the scene and calls Lightmap.load).`);
@@ -237560,8 +237796,9 @@ Lightmap UVs: the GLBs the app references that have none (TEXCOORD_1) are unwrap
     if (!["auto", "optix", "oidn"].includes(flags.denoiser))
       throw new CliError(`--denoiser wants auto, optix or oidn, got "${flags.denoiser}".`);
     const cfg = {
-      outDir: outDir.replace(/\\/g, "/"),
-      stem,
+      root: root.replace(/\\/g, "/"),
+      ...flags.out ? { outDir: resolve22(root, flags.out).replace(/\\/g, "/") } : {},
+      ...flags.name !== undefined ? { stem: flags.name } : {},
       size: range("size", flags.size, 256, 16384),
       texel: range("texel", flags.texel, 0.001, 2),
       pages: range("pages", flags.pages, 1, 16),
@@ -237604,23 +237841,26 @@ Lightmap UVs: the GLBs the app references that have none (TEXCOORD_1) are unwrap
     const entryText = `globalThis.__lecodesLightmap = ${JSON.stringify(cfg)}
 import ${JSON.stringify(importPath)}
 `;
-    mkdirSync25(outDir, { recursive: true });
-    ensurePlaceholders(outDir, stem);
-    if (debugDir)
-      mkdirSync25(debugDir, { recursive: true });
     const desktopRenderer = "gl";
-    const { js, resources } = await buildBundle(bundleOptions(flags), {
+    const { js, resources, bakes } = await buildBundle(bundleOptions(flags), {
       localAssets: true,
       desktopRenderer,
       extraEntries: [{ path: entryPath, type: "text", text: entryText }],
       entryOverride: entryPath
     });
+    const target = pickTarget2(bakes, flags.name, entryFile);
+    const stem = stemOf(target.path);
+    const outDir = flags.out ? resolve22(root, flags.out) : dirname23(target.absPath);
+    mkdirSync25(outDir, { recursive: true });
+    if (debugDir)
+      mkdirSync25(debugDir, { recursive: true });
+    note(`Target: ${relative7(root, join46(outDir, `${stem}.bake`)).replace(/\\/g, "/")}${target.exists ? "" : " (the first bake: nothing there yet)"}${flags.out ? " (--out)" : ""}`);
     if (!flags["no-unwrap"])
       await unwrapReferenced(js, resources, root, cfg.texel);
     const scratch = mkdtempSync4(join46(tmpdir4(), "lecodes-lightmap-"));
     const outPng = join46(scratch, "frame.png");
     const bounce = cfg.bounceRays > 0 && cfg.bounces > 0 ? `, ${cfg.bounceRays} bounce paths of ${cfg.bounces}${cfg.patchSamples > 0 ? ` + ${cfg.patchSamples} patch samples` : ""}${cfg.denoise !== "none" ? `, denoised (${cfg.denoise})` : ", raw"}` : ", no bounce";
-    note(`Baking up to ${cfg.pages} × ${cfg.size}² at ${(cfg.texel * 100).toFixed(1)} cm texels (${cfg.sunRays} sun + ${cfg.skyRays} sky + ${cfg.lightRays} lamp rays${bounce}) → ${relative7(root, outDir) || "."}/${stem}.*…`);
+    note(`Baking up to ${cfg.pages} × ${cfg.size}² at ${(cfg.texel * 100).toFixed(1)} cm texels (${cfg.sunRays} sun + ${cfg.skyRays} sky + ${cfg.lightRays} lamp rays${bounce}) → ${relative7(root, outDir).split(sep5).join("/") || "."}/${stem}.*…`);
     let output = "";
     if (flags["dry-run"])
       process.env.CBK_LAYOUT_ONLY = "1";
@@ -237664,16 +237904,12 @@ import ${JSON.stringify(importPath)}
     }
     if (/\[lightmap\] done/.test(output)) {
       const data = readBake(join46(outDir, `${stem}.bake`));
-      const rel = (f) => relative7(root, join46(outDir, f)).replace(/\\/g, "/");
-      const assets = (files) => files.length === 1 ? `asset('<rel>/${rel(files[0])}')` : `[${files.map((f) => `asset('<rel>/${rel(f)}')`).join(", ")}]`;
       const splitFiles = data.direct && data.indirect ? ` + ${data.direct.join(", ")} + ${data.indirect.join(", ")}` : "";
-      const splitDef = data.direct && data.indirect ? `, direct: ${assets(data.direct)}, indirect: ${assets(data.indirect)}` : "";
       const probeFiles = data.probes ? ` + ${data.probes.file} (${data.probes.count} probe(s) of ${data.probes.size}² at ${data.probes.spacing} m)` : "";
       const gridFile = data.volume ? ` + ${data.volume.file} (light grid ${data.volume.n.join(" x ")}, ${data.volume.valid} cell(s) in free space)` : "";
-      const probeDef = (data.probes ? `, probes: asset('<rel>/${rel(data.probes.file)}')` : "") + (data.volume ? `, volume: asset('<rel>/${rel(data.volume.file)}')` : "") + (data.uv1 ? `, uv1: asset('<rel>/${rel(data.uv1)}')` : "");
-      const uv1File = data.uv1 ? ` + ${data.uv1} (the packed lightmap uv1 — list it as env.lightmap.uv1, the rects map it)` : "";
-      logErr(c.green(`✓ baked → ${relative7(root, outDir) || "."}/${stem}.bake + ${data.light.join(", ")} + ${data.aux.join(", ")}${splitFiles}${probeFiles}${gridFile}${uv1File}`));
-      logErr(c.dim(`  scene file: env.lightmap: { data: asset('<rel>/${rel(`${stem}.bake`)}'), light: ${assets(data.light)}, aux: ${assets(data.aux)}${splitDef}${probeDef} }  — asset() paths are relative to the scene file`));
+      const uv1File = data.uv1 ? ` + ${data.uv1} (the packed lightmap uv1)` : "";
+      logErr(c.green(`✓ baked → ${relative7(root, outDir).replace(/\\/g, "/") || "."}/${stem}.bake + ${data.light.join(", ")} + ${data.aux.join(", ")}${splitFiles}${probeFiles}${gridFile}${uv1File}`));
+      logErr(c.dim(flags.out ? `  written to --out: the level's bake() still reads ${target.path}` : `  the manifest names them: the next compile of ${entryFile} stages them (bake('…') in the scene reads it)`));
       if (debugDir)
         logErr(c.dim(`  debug layers: ${relative7(root, debugDir)} (lecodes lightmap inspect --bake ${relative7(root, join46(outDir, `${stem}.bake`)).replace(/\\/g, "/")} --debug-dir ${relative7(root, debugDir).replace(/\\/g, "/")})`));
       return;
@@ -237693,15 +237929,16 @@ var stats = defineCommand({
   summary: "The per-instance numbers a .bake carries: mean lux, sun / sky visibility, texels, rect",
   description: "Reads the .bake alone (no debug layers needed). One row per receiver, sorted by mean lux unless --sort says otherwise; --key filters by a regular expression over the keys.",
   flags: {
-    bake: str("the .bake file", { value: "<file>", default: "assets/lightmap/lightmap.bake" }),
+    bake: str("the .bake file (default: the project's one .bake)", { value: "<file>" }),
     key: str("only instances whose key matches this regular expression", { value: "<regex>" }),
     sort: str("row order", { value: "<lux|key|texels|sun|sky>", default: "lux" }),
     limit: num("rows to print (0 = all)", { default: 60 })
   },
-  examples: ["lecodes lightmap stats --bake assets/school/lightmap/school.bake --key Wall", "lecodes lightmap stats --sort sky --limit 0"],
+  examples: ["lecodes lightmap stats --key Wall", "lecodes lightmap stats --bake assets/level2/lightmap/level2.bake --sort sky --limit 0"],
   run: ({ flags }) => {
     const { root } = localProject();
-    const data = readBake(resolve22(root, flags.bake));
+    const bakeFile = bakeFileOf(root, flags.bake);
+    const data = readBake(bakeFile);
     const re = flags.key ? new RegExp(flags.key) : null;
     let rows = data.instances.filter((i) => i.receiver && (!re || re.test(i.key)));
     const sorters = {
@@ -237718,7 +237955,7 @@ var stats = defineCommand({
     const total = rows.length;
     if (flags.limit > 0)
       rows = rows.slice(0, flags.limit);
-    log(`${basename18(flags.bake)}: ${data.pages} page(s) of ${data.size}, ${(data.texel * 100).toFixed(2)} cm texels, ${data.texels ?? "?"} texels, lightScale ${data.lightScale}`);
+    log(`${basename18(bakeFile)}: ${data.pages} page(s) of ${data.size}, ${(data.texel * 100).toFixed(2)} cm texels, ${data.texels ?? "?"} texels, lightScale ${data.lightScale}`);
     log(`${"key".padEnd(48)} ${"page".padStart(4)} ${"rect".padStart(20)} ${"texels".padStart(8)} ${"lux".padStart(9)} ${"sun".padStart(6)} ${"sky".padStart(6)} ${"dir".padStart(6)}`);
     for (const r of rows) {
       const rect = r.rect ? `${r.rect[0]},${r.rect[1]} ${r.rect[2]}x${r.rect[3]}` : "";
@@ -237733,7 +237970,7 @@ var diff = defineCommand({
   summary: "The noise of a bake, per instance: two bakes that differ only by --seed, compared texel by texel",
   description: "Bake the level twice with different --seed (and --out / --debug-dir, so the second does not overwrite the first — a `.lightmap/` dir inside the project is skipped by the compile scan). Both must share the layout (same instances, rects and pages — a seed changes nothing else). Per instance: the mean of the layer, the noise as the RMS of (a − b) / √2 over the mean, in %, and the share of texels that differ by more than half their mean. Sorted by noise unless --sort says otherwise.",
   flags: {
-    bake: str("the first .bake", { value: "<file>", default: "assets/lightmap/lightmap.bake" }),
+    bake: str("the first .bake (default: the project's one .bake)", { value: "<file>" }),
     "debug-dir": str("where the first bake kept its PFM layers", { value: "<dir>", default: ".lightmap" }),
     bake2: str("the second .bake (another --seed)", { value: "<file>" }),
     "debug-dir2": str("where the second bake kept its PFM layers", { value: "<dir>" }),
@@ -237744,21 +237981,23 @@ var diff = defineCommand({
     limit: num("rows to print (0 = all)", { default: 40 })
   },
   examples: [
-    "lecodes lightmap bake --entry range.ts --name range --seed 2 --out .lightmap/range-seed2/bake --debug-dir .lightmap/range-seed2 --logs",
-    "lecodes lightmap diff --bake assets/range/lightmap/range.bake --debug-dir .lightmap/range --bake2 .lightmap/range-seed2/bake/range.bake --debug-dir2 .lightmap/range-seed2 --layer bounce"
+    "lecodes lightmap bake --debug-dir .lightmap/seed1 --logs",
+    "lecodes lightmap bake --seed 2 --out .lightmap/seed2/bake --debug-dir .lightmap/seed2 --logs",
+    "lecodes lightmap diff --debug-dir .lightmap/seed1 --bake2 .lightmap/seed2/bake/level.bake --debug-dir2 .lightmap/seed2 --layer bounce"
   ],
   run: ({ flags }) => {
     const { root } = localProject();
     if (!flags.bake2 || !flags["debug-dir2"])
       throw new CliError("--bake2 and --debug-dir2 name the second bake (another --seed).");
-    const a = readBake(resolve22(root, flags.bake)), b = readBake(resolve22(root, flags.bake2));
+    const bakeFile = bakeFileOf(root, flags.bake);
+    const a = readBake(bakeFile), b = readBake(resolve22(root, flags.bake2));
     if (a.size !== b.size || a.pages !== b.pages)
       throw new CliError(`The bakes differ in layout (${a.pages} × ${a.size} vs ${b.pages} × ${b.size}) — a diff needs the same scene baked twice with another --seed.`);
     const ra = a.instances.filter((i) => i.receiver), rb = b.instances.filter((i) => i.receiver);
     if (ra.length !== rb.length || ra.some((i, k) => i.key !== rb[k].key || i.page !== rb[k].page || String(i.rect) !== String(rb[k].rect))) {
       throw new CliError("The bakes list different instances or rects — a diff needs the same scene baked twice with another --seed.");
     }
-    const stemA = basename18(flags.bake, ".bake"), stemB = basename18(flags.bake2, ".bake");
+    const stemA = basename18(bakeFile, ".bake"), stemB = basename18(flags.bake2, ".bake");
     const dirA = resolve22(root, flags["debug-dir"]), dirB = resolve22(root, flags["debug-dir2"]);
     const layer = flags.layer;
     if (!["irradiance", "bounce", "sun", "sky", "lamps"].includes(layer))
@@ -237831,7 +238070,7 @@ var diff = defineCommand({
   }
 });
 var readPfm = (file) => {
-  const buf = readFileSync35(file);
+  const buf = readFileSync36(file);
   let o = 0;
   const token = () => {
     while (o < buf.length && /\s/.test(String.fromCharCode(buf[o])))
@@ -237911,7 +238150,7 @@ var inspect = defineCommand({
   summary: "PNGs from a bake's debug layers: whole pages, or one instance's rect enlarged",
   description: "Reads the PFM float layers `bake --debug-dir` kept next to the .bake's rects. Without --key: one PNG per page and layer with every rect outlined. With --key: the matching instances' rects (plus a margin) enlarged by --scale, one PNG per instance and layer. Lux layers are shown as log10 over --lux-range (or linear over --white); vectors as x0.5+0.5.",
   flags: {
-    bake: str("the .bake file", { value: "<file>", default: "assets/lightmap/lightmap.bake" }),
+    bake: str("the .bake file (default: the project's one .bake)", { value: "<file>" }),
     "debug-dir": str("where the bake kept its PFM layers", { value: "<dir>", default: ".lightmap" }),
     out: str("where the PNGs go", { value: "<dir>", default: ".lightmap/png" }),
     key: str("instances whose key matches this regular expression (default: whole pages)", { value: "<regex>" }),
@@ -237922,10 +238161,10 @@ var inspect = defineCommand({
     white: num("linear mode: the lux shown as white (0 = log mode)", { default: 0 }),
     limit: num("instances to render with --key (0 = all)", { default: 24 })
   },
-  examples: ["lecodes lightmap inspect --bake assets/school/lightmap/school.bake --debug-dir .lightmap/school", "lecodes lightmap inspect --key 'Wall_05' --layer irradiance,sun,sky,lamps --scale 6"],
+  examples: ["lecodes lightmap inspect --debug-dir .lightmap/level", "lecodes lightmap inspect --key 'Wall_05' --layer irradiance,sun,sky,lamps --scale 6"],
   run: ({ flags }) => {
     const { root } = localProject();
-    const bakeFile = resolve22(root, flags.bake);
+    const bakeFile = bakeFileOf(root, flags.bake);
     const data = readBake(bakeFile);
     const stem = basename18(bakeFile).replace(/\.bake$/, "");
     const dbg = resolve22(root, flags["debug-dir"]);
@@ -238097,7 +238336,7 @@ init_types4();
 // src/commands/push.ts
 init_cli();
 init_api();
-import { readFileSync as readFileSync37 } from "node:fs";
+import { readFileSync as readFileSync38 } from "node:fs";
 import { basename as basename19 } from "node:path";
 init_localFiles();
 init_manifest();
@@ -238106,7 +238345,7 @@ init_manifest();
 init_cli();
 init_api();
 init_localFiles();
-import { existsSync as existsSync42, readFileSync as readFileSync36 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync37 } from "node:fs";
 import { resolve as resolve23 } from "node:path";
 init_shared();
 var compareVersions = (a, b) => {
@@ -238193,11 +238432,11 @@ var upload2 = defineCommand({
     const path = resolve23(file);
     if (!existsSync42(path))
       throw new CliError(`No such file: ${file}`);
-    const code = readFileSync36(path, "utf8");
+    const code = readFileSync37(path, "utf8");
     const sdk = /^\/\/ sdk: (\S+)/m.exec(code)?.[1];
     if (!sdk)
       throw new CliError(`${file} is not a LeCodes bundle: no \`// sdk:\` header line. \`lecodes compile --remote-assets -o app.js\` writes one.`);
-    const map = existsSync42(`${path}.map`) ? readFileSync36(`${path}.map`, "utf8") : null;
+    const map = existsSync42(`${path}.map`) ? readFileSync37(`${path}.map`, "utf8") : null;
     const { root, manifest, apiUrl, token } = linkedProject();
     if (hasChanges(diffLocal(manifest, scanProject(root, manifest))))
       await runPush({ message: flags.message || "Release" });
@@ -238302,9 +238541,9 @@ var runPush = async (opts) => {
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind))
-      entry.text = readFileSync37(file.absPath, "utf8");
+      entry.text = readFileSync38(file.absPath, "utf8");
     else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename19(file.path), readFileSync37(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename19(file.path), readFileSync38(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -238504,7 +238743,7 @@ var login_default = defineCommand({
 });
 
 // src/commands/navmesh.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync26, mkdtempSync as mkdtempSync5, readdirSync as readdirSync18, readFileSync as readFileSync38, rmSync as rmSync13, statSync as statSync15, unlinkSync as unlinkSync2, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync44, mkdirSync as mkdirSync26, mkdtempSync as mkdtempSync5, readdirSync as readdirSync19, readFileSync as readFileSync39, rmSync as rmSync13, statSync as statSync14, unlinkSync as unlinkSync2, writeFileSync as writeFileSync28 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename21, join as join48, relative as relative8, resolve as resolve25 } from "node:path";
 init_cli();
@@ -239307,7 +239546,7 @@ var guessName = (root) => {
       continue;
     let entries;
     try {
-      entries = readdirSync18(dir);
+      entries = readdirSync19(dir);
     } catch {
       continue;
     }
@@ -239315,7 +239554,7 @@ var guessName = (root) => {
       if (!f.endsWith(".scene.ts"))
         continue;
       try {
-        if (/\bnavmesh\s*:/.test(readFileSync38(join48(dir, f), "utf8")))
+        if (/\bnavmesh\s*:/.test(readFileSync39(join48(dir, f), "utf8")))
           return f.slice(0, -".scene.ts".length);
       } catch {}
     }
@@ -239465,7 +239704,7 @@ import ${JSON.stringify(importPath)}
     const geoPath = join48(outDir, `${name}.navgeo`);
     if (!existsSync44(geoPath))
       throw new CliError(`The host reported a dump but ${geoPath} is missing.`);
-    const geo = readNgeo(new Uint8Array(readFileSync38(geoPath)));
+    const geo = readNgeo(new Uint8Array(readFileSync39(geoPath)));
     const params = {
       agentRadius: range2("radius", flags.radius, config.agent.radius, 0.05, 10),
       agentHeight: range2("height", flags.height, config.agent.height, 0.1, 20),
@@ -239519,7 +239758,7 @@ import ${JSON.stringify(importPath)}
     }
     if (!flags["keep-geometry"])
       unlinkSync2(geoPath);
-    const kb = Math.round(statSync15(navmeshPath).size / 1024);
+    const kb = Math.round(statSync14(navmeshPath).size / 1024);
     const b = result.bounds;
     logErr(c.dim(`  ${result.tiles} tiles, ${result.polys} polygons, ${(b.max[0] - b.min[0]).toFixed(0)} × ${(b.max[2] - b.min[2]).toFixed(0)} m, ${result.time.toFixed(1)} s`));
     logErr(c.green(`✓ baked → ${relative8(root, navmeshPath).replace(/\\/g, "/")} (${kb} KB)`));
@@ -239539,9 +239778,9 @@ init_cli();
 
 // src/plugin/generate.ts
 init_cli();
-import { existsSync as existsSync45, mkdirSync as mkdirSync27, readFileSync as readFileSync39, readdirSync as readdirSync19, statSync as statSync16, writeFileSync as writeFileSync29 } from "node:fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync27, readFileSync as readFileSync40, readdirSync as readdirSync20, statSync as statSync15, writeFileSync as writeFileSync29 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { basename as basename22, join as join49, relative as relative9, resolve as resolve26, sep as sep5 } from "node:path";
+import { basename as basename22, join as join49, relative as relative9, resolve as resolve26, sep as sep6 } from "node:path";
 
 // src/plugin/permissions.ts
 var PERMISSION_KINDS = ["camera", "microphone", "location", "speech"];
@@ -242410,10 +242649,10 @@ const wire = {
 `;
 
 // src/plugin/generate.ts
-var shown = (from, to) => relative9(from, to).split(sep5).join("/");
+var shown = (from, to) => relative9(from, to).split(sep6).join("/");
 var implementsOf = (dir) => {
   try {
-    const raw = JSON.parse(readFileSync39(join49(dir, MANIFEST_FILE), "utf8").replace(/^/, ""));
+    const raw = JSON.parse(readFileSync40(join49(dir, MANIFEST_FILE), "utf8").replace(/^/, ""));
     return typeof raw.implements === "string" ? raw.implements : null;
   } catch {
     return null;
@@ -242427,7 +242666,7 @@ var findPlugins = (path) => {
   const holder = join49(root, "plugins");
   if (!existsSync45(holder))
     return [];
-  return readdirSync19(holder).sort().map((id) => ({ id, dir: join49(holder, id) })).filter((p) => statSync16(p.dir).isDirectory() && isPluginDir(p.dir));
+  return readdirSync20(holder).sort().map((id) => ({ id, dir: join49(holder, id) })).filter((p) => statSync15(p.dir).isDirectory() && isPluginDir(p.dir));
 };
 var loadTypescript = (dir) => {
   for (const from of [join49(dir, "package.json"), import.meta.url]) {
@@ -242444,7 +242683,7 @@ var generatePlugin = (ts, plugin) => {
   const manifest = readManifestIfAny(plugin.dir, plugin.id);
   const implemented = manifest?.implements;
   const file = implemented ? firstPartyContractFile(implemented) : join49(plugin.dir, CONTRACT_FILE);
-  const contract = readContract(ts, file, implemented ? firstPartyContractText(file) : readFileSync39(file, "utf8"));
+  const contract = readContract(ts, file, implemented ? firstPartyContractText(file) : readFileSync40(file, "utf8"));
   checkPermissions(plugin, contract, manifest);
   const id = implemented ?? plugin.id;
   const handWritten = existsSync45(join49(plugin.dir, "sdk", `${id}.ts`));
@@ -242484,7 +242723,7 @@ var checkPermissions = (plugin, contract, manifest) => {
   if (kinds.length === 0)
     return;
   const androidManifest = join49(plugin.dir, "android", "src", "main", "AndroidManifest.xml");
-  const androidXml = manifest.android ? existsSync45(androidManifest) ? readFileSync39(androidManifest, "utf8") : "" : null;
+  const androidXml = manifest.android ? existsSync45(androidManifest) ? readFileSync40(androidManifest, "utf8") : "" : null;
   const missing = missingDeclarations(kinds, manifest.ios ? manifest.ios.infoPlist ?? {} : null, androidXml === null ? null : usesPermissions(androidXml), androidXml === null ? null : usesFeatures(androidXml));
   const problems = [];
   if (missing.infoPlist.length)
@@ -242499,16 +242738,16 @@ var checkPermissions = (plugin, contract, manifest) => {
 var hostImports = (web) => {
   const found = [];
   const walk = (dir) => {
-    for (const entry of readdirSync19(dir).sort()) {
+    for (const entry of readdirSync20(dir).sort()) {
       const path = join49(dir, entry);
-      if (statSync16(path).isDirectory()) {
+      if (statSync15(path).isDirectory()) {
         if (entry !== "node_modules" && entry !== "dist")
           walk(path);
         continue;
       }
       if (!/\.(ts|tsx|js|mjs)$/.test(entry))
         continue;
-      readFileSync39(path, "utf8").split(`
+      readFileSync40(path, "utf8").split(`
 `).forEach((line, i) => {
         const m = /(?:from\s+|import\s*\(\s*|import\s+)["'](lecodes-[^"']*)["']/.exec(line);
         if (m && !/^\s*\/\//.test(line))
@@ -242529,8 +242768,8 @@ var kotlinPackage = (android, register) => {
   }
   let dir = root;
   while (existsSync45(dir)) {
-    const entries = readdirSync19(dir).filter((e) => !e.startsWith("."));
-    const dirs = entries.filter((e) => statSync16(join49(dir, e)).isDirectory());
+    const entries = readdirSync20(dir).filter((e) => !e.startsWith("."));
+    const dirs = entries.filter((e) => statSync15(join49(dir, e)).isDirectory());
     if (dirs.length !== 1 || entries.length !== 1)
       break;
     dir = join49(dir, dirs[0]);
@@ -242545,7 +242784,7 @@ var repoSdkPath = (root) => {
   if (!existsSync45(file))
     return DEFAULT_SDK_PATH;
   try {
-    const pkg = JSON.parse(readFileSync39(file, "utf8"));
+    const pkg = JSON.parse(readFileSync40(file, "utf8"));
     const path = pkg.lecodes?.iosSdkPath;
     if (path !== undefined && typeof path !== "string")
       throw new PackageError(`package.json lecodes.iosSdkPath: a path, as a string`);
@@ -242565,7 +242804,7 @@ var generate = (path, opts = {}) => {
   const report = { plugins: [], repo: { written: [], stale: [], fresh: [] }, failures: [] };
   const place = (f, entry) => {
     const name = shown(root, f.file) || basename22(f.file);
-    const current = existsSync45(f.file) ? readFileSync39(f.file, "utf8") : null;
+    const current = existsSync45(f.file) ? readFileSync40(f.file, "utf8") : null;
     if (current === f.text) {
       entry.fresh.push(name);
       return;
@@ -243002,7 +243241,7 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync30, readFileSync as readFileSync41, writeFileSync as writeFileSync32 } from "node:fs";
+import { mkdirSync as mkdirSync30, readFileSync as readFileSync42, writeFileSync as writeFileSync32 } from "node:fs";
 import { dirname as dirname25, resolve as resolve30 } from "node:path";
 
 // src/compile/headlessBundle.ts
@@ -243090,7 +243329,7 @@ var compileHeadlessBundle = async (opts = {}) => {
 init_designMeta();
 init_cli();
 init_paths();
-import { existsSync as existsSync47, readFileSync as readFileSync40, statSync as statSync17 } from "node:fs";
+import { existsSync as existsSync47, readFileSync as readFileSync41, statSync as statSync16 } from "node:fs";
 import { isAbsolute as isAbsolute3, join as join51, relative as relative10, resolve as resolve27 } from "node:path";
 var SCREEN_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
 var SCREEN_ENTRY_PATH = "/.screen-entry.ts";
@@ -243102,7 +243341,7 @@ var findScreenFile = (root, file, dirFlag) => {
     candidates.push(join51(root, (dirFlag ?? DEFAULT_DESIGN_DIR).replace(/[/\\]+$/, ""), "screens", file));
   }
   for (const base of candidates) {
-    if (existsSync47(base) && statSync17(base).isFile())
+    if (existsSync47(base) && statSync16(base).isFile())
       return base;
     for (const ext of SCREEN_EXTS)
       if (existsSync47(base + ext))
@@ -243124,7 +243363,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(readFileSync40(abs, "utf8"))) {
+  if (!/^\s*export\s+default\b/m.test(readFileSync41(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()";
@@ -243921,7 +244160,7 @@ var resolveFixtures = (value, baseDir) => {
   if (typeof value === "string") {
     const abs = resolve30(baseDir, value);
     try {
-      map = JSON.parse(readFileSync41(abs, "utf8"));
+      map = JSON.parse(readFileSync42(abs, "utf8"));
     } catch (e) {
       throw new CliError(`Can't read fixtures "${value}": ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -243934,7 +244173,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync41(resolve30(path), "utf8"));
+    raw = JSON.parse(readFileSync42(resolve30(path), "utf8"));
   } catch (e) {
     throw new CliError(`Can't read scenario "${path}": ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -244279,7 +244518,7 @@ var renderHeadless = async (flags, file) => {
 
 // src/commands/scene.ts
 init_cli();
-import { existsSync as existsSync50, readFileSync as readFileSync43, readdirSync as readdirSync20, statSync as statSync18, writeFileSync as writeFileSync34 } from "node:fs";
+import { existsSync as existsSync50, readFileSync as readFileSync44, readdirSync as readdirSync21, statSync as statSync17, writeFileSync as writeFileSync34 } from "node:fs";
 import { basename as basename23, dirname as dirname26, join as join54, relative as relative11, resolve as resolve31 } from "node:path";
 
 // src/compile/sceneCompile.ts
@@ -244288,7 +244527,7 @@ init_ignore();
 init_cli();
 init_projectCompile();
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync49, mkdirSync as mkdirSync31, readFileSync as readFileSync42, writeFileSync as writeFileSync33 } from "node:fs";
+import { existsSync as existsSync49, mkdirSync as mkdirSync31, readFileSync as readFileSync43, writeFileSync as writeFileSync33 } from "node:fs";
 import { join as join53 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
@@ -244300,11 +244539,11 @@ var compileSceneEditor = async (opts) => {
   for (const file of scan.files) {
     const path = "./" + rel(file.path);
     if (TEXT_EXT.test(path)) {
-      entries.push({ path, type: "text", text: readFileSync42(file.absPath, "utf8") });
+      entries.push({ path, type: "text", text: readFileSync43(file.absPath, "utf8") });
     } else if (/\.mat$/i.test(path)) {
-      entries.push({ path, type: "shader", text: readFileSync42(file.absPath, "utf8"), absPath: file.absPath });
+      entries.push({ path, type: "shader", text: readFileSync43(file.absPath, "utf8"), absPath: file.absPath });
     } else {
-      entries.push({ path, type: "resource", fileSrc: "/project/" + rel(file.path) });
+      entries.push({ path, type: "resource", fileSrc: "/project/" + rel(file.path), absPath: file.absPath });
     }
   }
   const shaderEntries = entries.filter((e) => e.type === "shader");
@@ -244384,7 +244623,7 @@ var getContext2 = (pathArg) => {
     manifest = null;
     if (pathArg) {
       const abs = resolve31(process.cwd(), pathArg);
-      if (existsSync50(abs) && statSync18(abs).isDirectory())
+      if (existsSync50(abs) && statSync17(abs).isDirectory())
         root = abs;
       else if (abs.endsWith(".scene.ts") && existsSync50(abs))
         root = findAppRoot(dirname26(abs)) ?? dirname26(abs);
@@ -244409,7 +244648,7 @@ var writeMcpConfig2 = (root, port) => {
   let config = {};
   if (existsSync50(path)) {
     try {
-      config = JSON.parse(readFileSync43(path, "utf8"));
+      config = JSON.parse(readFileSync44(path, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -244428,11 +244667,11 @@ var writeMcpConfig2 = (root, port) => {
 };
 var countScenes = (dir) => {
   let n = 0;
-  for (const name of readdirSync20(dir)) {
+  for (const name of readdirSync21(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
     const full = join54(dir, name);
-    if (statSync18(full).isDirectory())
+    if (statSync17(full).isDirectory())
       n += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n++;
@@ -244524,8 +244763,9 @@ var serve_default = defineCommand({
 });
 
 // src/commands/shaders/index.ts
-import { readFileSync as readFileSync45 } from "node:fs";
+import { readFileSync as readFileSync46 } from "node:fs";
 import { relative as relative13 } from "node:path";
+init_releases();
 init_cli();
 init_shared();
 
@@ -244533,7 +244773,7 @@ init_shared();
 init_compile();
 init_distRoot();
 init_cli();
-import { existsSync as existsSync51, mkdirSync as mkdirSync32, readdirSync as readdirSync21, readFileSync as readFileSync44, writeFileSync as writeFileSync35 } from "node:fs";
+import { existsSync as existsSync51, mkdirSync as mkdirSync32, readdirSync as readdirSync22, readFileSync as readFileSync45, writeFileSync as writeFileSync35 } from "node:fs";
 import { basename as basename25, join as join55, relative as relative12, resolve as resolve32 } from "node:path";
 var engineMaterialsDir = () => {
   const candidates = [
@@ -244549,7 +244789,7 @@ var engineMaterialNames = () => {
   const dir = engineMaterialsDir();
   if (!dir)
     return [];
-  return readdirSync21(dir).filter((f) => f.endsWith(".mat") && !f.startsWith("camera") && f !== "shader360.mat").map((f) => f.slice(0, -4)).sort();
+  return readdirSync22(dir).filter((f) => f.endsWith(".mat") && !f.startsWith("camera") && f !== "shader360.mat").map((f) => f.slice(0, -4)).sort();
 };
 var NAME_RE = /^[a-z][a-z0-9_-]*$/i;
 var matName = (name) => name.replace(/-/g, "_");
@@ -244640,7 +244880,7 @@ var writeNewShader = (o) => {
     const known = engineMaterialNames();
     if (!known.includes(ref))
       throw new CliError(`no engine material "${ref}". Known: ${known.join(", ")}`);
-    mat = refMat(name, ref, readFileSync44(join55(srcDir, `${ref}.mat`), "utf8"));
+    mat = refMat(name, ref, readFileSync45(join55(srcDir, `${ref}.mat`), "utf8"));
   } else
     mat = starterMat(name);
   mkdirSync32(dir, { recursive: true });
@@ -244672,7 +244912,7 @@ var status2 = async () => {
       if (matcId === null)
         state = c.dim("unknown (matc not downloaded)");
       else {
-        const text = readFileSync45(shader.absPath, "utf8");
+        const text = readFileSync46(shader.absPath, "utf8");
         if (shaderIsCompiled(root, text, matcId))
           state = "compiled";
         else {
@@ -244681,7 +244921,7 @@ var status2 = async () => {
         }
       }
       log(`  ${shader.path.padEnd(width)}  ${state}`);
-      const schema = parseShaderSchema(readFileSync45(shader.absPath, "utf8"));
+      const schema = parseShaderSchema(readFileSync46(shader.absPath, "utf8"));
       for (const p of schema.params) {
         const range = p.min !== undefined ? ` [${p.min}..${p.max}]` : "";
         const def = p.default !== null && p.default !== undefined ? ` = ${JSON.stringify(p.default)}` : "";
@@ -244722,7 +244962,7 @@ var compileShaders = async (platforms) => {
   }
   const matcExe = await resolveMatcExe();
   const matcId = matcIdentity(matcExe);
-  const wasCompiled = new Map(shaders.map((s) => [s.path, shaderIsCompiled(root, readFileSync45(s.absPath, "utf8"), matcId)]));
+  const wasCompiled = new Map(shaders.map((s) => [s.path, shaderIsCompiled(root, readFileSync46(s.absPath, "utf8"), matcId)]));
   const errors = [];
   for (const shader of shaders) {
     try {
@@ -244824,7 +245064,7 @@ var status_default = defineCommand({
 });
 
 // src/commands/test.ts
-import { existsSync as existsSync53, mkdirSync as mkdirSync34, readFileSync as readFileSync46, readdirSync as readdirSync22 } from "node:fs";
+import { existsSync as existsSync53, mkdirSync as mkdirSync34, readFileSync as readFileSync47, readdirSync as readdirSync23 } from "node:fs";
 import { dirname as dirname28, resolve as resolve33 } from "node:path";
 init_manifest();
 
@@ -245341,7 +245581,7 @@ var slug = (s) => s.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").sli
 var readFlowFile = (abs, displayName) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync46(abs, "utf8"));
+    raw = JSON.parse(readFileSync47(abs, "utf8"));
   } catch (e) {
     throw new CliError(`Can't read "${displayName}": ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -245449,7 +245689,7 @@ var runTests = async (args, flags) => {
       cases.push(readFlowFile(abs, given));
     }
   } else if (existsSync53(testsDir)) {
-    for (const f of readdirSync22(testsDir).filter((f) => f.endsWith(".flow.json")).sort()) {
+    for (const f of readdirSync23(testsDir).filter((f) => f.endsWith(".flow.json")).sort()) {
       cases.push(readFlowFile(resolve33(testsDir, f), f));
     }
   }
@@ -245467,7 +245707,7 @@ var runTests = async (args, flags) => {
   if (!desktop && !lite && (wantFlows || flowsOnly) && existsSync53(designMetaPath)) {
     let meta;
     try {
-      meta = JSON.parse(readFileSync46(designMetaPath, "utf8"));
+      meta = JSON.parse(readFileSync47(designMetaPath, "utf8"));
     } catch (e) {
       throw new CliError(`Can't read ${designMetaPath}: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -245540,7 +245780,7 @@ var runTests = async (args, flags) => {
       script: plan.text,
       fixedDtMs: nativeFixedDt
     });
-    const r = evaluateDesktopRun(plan, output, (path) => existsSync53(path) ? readFileSync46(path, "utf8") : null);
+    const r = evaluateDesktopRun(plan, output, (path) => existsSync53(path) ? readFileSync47(path, "utf8") : null);
     if (!r.loaded)
       throw new CliError("This desktop host doesn't support scripted input (CREATOR_SCRIPT). Update it: lecodes desktop update (or point LECODES_DESKTOP_EXE at a newer build).");
     return {
@@ -245579,7 +245819,7 @@ var runTests = async (args, flags) => {
       height: flags.height || kase.height || projectViewport?.height || 844,
       onConsole
     });
-    const r = evaluateDesktopRun(plan, output, (path) => existsSync53(path) ? readFileSync46(path, "utf8") : null);
+    const r = evaluateDesktopRun(plan, output, (path) => existsSync53(path) ? readFileSync47(path, "utf8") : null);
     return {
       name: kase.name,
       kind: kase.kind,
@@ -245688,7 +245928,7 @@ var runTests = async (args, flags) => {
 init_peerInstall();
 import { createRequire as createRequire8 } from "node:module";
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { existsSync as existsSync54, mkdtempSync as mkdtempSync7, readdirSync as readdirSync23, rmSync as rmSync17, statSync as statSync19 } from "node:fs";
+import { existsSync as existsSync54, mkdtempSync as mkdtempSync7, readdirSync as readdirSync24, rmSync as rmSync17, statSync as statSync18 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
 import { extname, join as join57, relative as relative14, resolve as resolve34 } from "node:path";
 init_cli();
@@ -245746,11 +245986,11 @@ var ktxToPng = (ktx, file, out) => {
 };
 var collect = (dir) => {
   const out = [];
-  for (const name of readdirSync23(dir)) {
+  for (const name of readdirSync24(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
     const full = join57(dir, name);
-    if (statSync19(full).isDirectory())
+    if (statSync18(full).isDirectory())
       out.push(...collect(full));
     else if (IMAGE_EXT.test(name))
       out.push(full);
@@ -245778,7 +246018,7 @@ var thumbs = async (targets, size, force) => {
       const abs = resolve34(process.cwd(), arg);
       if (!existsSync54(abs))
         throw new CliError(`No such file or folder: ${arg}`);
-      if (statSync19(abs).isDirectory())
+      if (statSync18(abs).isDirectory())
         files.push(...collect(abs));
       else if (IMAGE_EXT.test(abs))
         files.push(abs);
@@ -245855,7 +246095,7 @@ init_peerInstall();
 init_archives();
 init_packageManager();
 import { spawnSync as spawnSync11 } from "node:child_process";
-import { existsSync as existsSync55, readdirSync as readdirSync24 } from "node:fs";
+import { existsSync as existsSync55, readdirSync as readdirSync25 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 import { dirname as dirname29, join as join58, resolve as resolve36 } from "node:path";
 
@@ -246026,7 +246266,7 @@ ${c.bold(name)}  ${c.dim(what)}`);
         return ["skipped", "not inside a project"];
       if (flags["no-shells"])
         return ["skipped", "--no-shells"];
-      const present = ["ios", "android"].filter((d) => existsSync55(join58(root, d)) && readdirSync24(join58(root, d)).length > 0);
+      const present = ["ios", "android"].filter((d) => existsSync55(join58(root, d)) && readdirSync25(join58(root, d)).length > 0);
       if (present.length === 0)
         return ["skipped", "no ios/ or android/ shell in this project (`lecodes app init ios|android`)"];
       await runSubcommand(app_default, "update");
@@ -246105,7 +246345,7 @@ init_cli();
 // src/web/build.ts
 init_compile();
 import { createHash as createHash10 } from "node:crypto";
-import { copyFileSync as copyFileSync2, cpSync as cpSync7, existsSync as existsSync56, mkdirSync as mkdirSync35, readFileSync as readFileSync47, readdirSync as readdirSync25, rmSync as rmSync18, statSync as statSync20, writeFileSync as writeFileSync37 } from "node:fs";
+import { copyFileSync as copyFileSync2, cpSync as cpSync7, existsSync as existsSync56, mkdirSync as mkdirSync35, readFileSync as readFileSync48, readdirSync as readdirSync26, rmSync as rmSync18, statSync as statSync19, writeFileSync as writeFileSync37 } from "node:fs";
 import { dirname as dirname30, extname as extname2, join as join59, resolve as resolve37 } from "node:path";
 init_fonts();
 init_assetIcons();
@@ -246118,9 +246358,9 @@ var normalBase = (base) => {
 };
 var walk = (dir, prefix = "") => {
   const out = [];
-  for (const name of readdirSync25(dir)) {
+  for (const name of readdirSync26(dir)) {
     const abs = join59(dir, name);
-    const stat = statSync20(abs);
+    const stat = statSync19(abs);
     if (stat.isDirectory())
       out.push(...walk(abs, `${prefix}${name}/`));
     else
@@ -246149,7 +246389,7 @@ var buildWeb = async (options) => {
   for (const entry of entries) {
     if (entry.type !== "shader" || !entry.absPath)
       continue;
-    const text = readFileSync47(entry.absPath, "utf8");
+    const text = readFileSync48(entry.absPath, "utf8");
     const hash = createHash10("sha256").update(text).digest("hex").slice(0, 16);
     shaders.set(hash, JSON.stringify(buildLiteMaterialArtifact(text)));
     entry.shaders = [{ platform: "opengl", src: `shaders/${hash}_opengl.filamat` }];
@@ -246196,7 +246436,7 @@ var buildWeb = async (options) => {
   cpSync7(lite, out, { recursive: true });
   const table = join59(out, "features.json");
   if (existsSync56(table)) {
-    const { features, fonts } = JSON.parse(readFileSync47(table, "utf8"));
+    const { features, fonts } = JSON.parse(readFileSync48(table, "utf8"));
     if (config.font === "system")
       for (const file of fonts ?? [])
         rmSync18(join59(out, file), { force: true });
@@ -246210,7 +246450,7 @@ var buildWeb = async (options) => {
   }
   const pluginsTable = join59(out, "plugins.json");
   if (existsSync56(pluginsTable) || halves.length > 0) {
-    const { plugins } = existsSync56(pluginsTable) ? JSON.parse(readFileSync47(pluginsTable, "utf8")) : { plugins: {} };
+    const { plugins } = existsSync56(pluginsTable) ? JSON.parse(readFileSync48(pluginsTable, "utf8")) : { plugins: {} };
     const kept = {};
     for (const id of Object.keys(plugins)) {
       if (listed.has(id))
@@ -246260,7 +246500,7 @@ var buildWeb = async (options) => {
     writeFileSync37(join59(out, "shaders", `${hash}_webgl-lite.filamat`), artifact);
   }
   const app = readAppConfigAt(root);
-  let html = readFileSync47(join59(lite, "index.html"), "utf8");
+  let html = readFileSync48(join59(lite, "index.html"), "utf8");
   const head = [];
   head.push(`<meta name="theme-color" content="${escapeHtml(config.themeColor ?? "#000000")}" />`);
   if (app?.icon) {
@@ -246300,7 +246540,7 @@ var buildWeb = async (options) => {
 };
 
 // src/web/preview.ts
-import { createReadStream as createReadStream3, existsSync as existsSync57, statSync as statSync21 } from "node:fs";
+import { createReadStream as createReadStream3, existsSync as existsSync57, statSync as statSync20 } from "node:fs";
 import { createServer as createServer4 } from "node:http";
 import { join as join60, resolve as resolve38 } from "node:path";
 var startPreview = async (dir, port) => {
@@ -246322,10 +246562,10 @@ var startPreview = async (dir, port) => {
       return;
     }
     let file = join60(root, ...parts);
-    if (existsSync57(file) && statSync21(file).isDirectory())
+    if (existsSync57(file) && statSync20(file).isDirectory())
       file = join60(file, "index.html");
     let status = 200;
-    if (!existsSync57(file) || !statSync21(file).isFile()) {
+    if (!existsSync57(file) || !statSync20(file).isFile()) {
       if (!fallback || /\.[a-z0-9]+$/i.test(parts[parts.length - 1] ?? "")) {
         res.writeHead(404, { "content-type": "text/plain" });
         res.end("Not found");
@@ -246355,7 +246595,7 @@ var startPreview = async (dir, port) => {
 init_shared();
 
 // src/dev/https.ts
-import { existsSync as existsSync58, mkdirSync as mkdirSync36, readFileSync as readFileSync48, writeFileSync as writeFileSync38 } from "node:fs";
+import { existsSync as existsSync58, mkdirSync as mkdirSync36, readFileSync as readFileSync49, writeFileSync as writeFileSync38 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
 import { join as join61 } from "node:path";
 var DIR = () => join61(homedir15(), ".lecodes", "dev-https");
@@ -246365,12 +246605,12 @@ var devCertificate = async (names, dir = DIR()) => {
   const files = { cert: join61(dir, "cert.pem"), key: join61(dir, "key.pem"), meta: join61(dir, "names.json") };
   let kept = null;
   try {
-    kept = JSON.parse(readFileSync48(files.meta, "utf8"));
+    kept = JSON.parse(readFileSync49(files.meta, "utf8"));
   } catch {}
   const wanted = [...new Set(["localhost", "127.0.0.1", ...names])];
   const fresh = kept && Date.now() - kept.made < RENEW_DAYS * 86400000 && wanted.every((n) => kept.names.includes(n));
   if (fresh && existsSync58(files.cert) && existsSync58(files.key)) {
-    return { cert: readFileSync48(files.cert, "utf8"), key: readFileSync48(files.key, "utf8") };
+    return { cert: readFileSync49(files.cert, "utf8"), key: readFileSync49(files.key, "utf8") };
   }
   const { generate } = await Promise.resolve().then(() => __toESM(require_selfsigned(), 1));
   const all = [...new Set([...kept?.names ?? [], ...wanted])];