lecodes-cli 0.17.1 → 0.18.0

package/dist/index.js

@@ -171459,6 +171459,264 @@ var init_detectEntry = __esm(() => {
   EXPORT_RE = /(?:^|[\n;])\s*export\b/;
 });
 
+// ../sdk/src/compile/shaderTargets.ts
+var externalSamplerReg, PLATFORM_BUILD, matcPlatformsFor = (text) => {
+  externalSamplerReg.lastIndex = 0;
+  return externalSamplerReg.test(text) ? ["opengl", "metal", "webgl", "desktop"] : ["opengl", "metal", "desktop"];
+}, matcArgs = (platform, outPath, inPath) => {
+  const build = PLATFORM_BUILD[platform];
+  return ["-p", build.profile, "--no-essl1", "-a", build.api, "-o", outPath, inPath];
+};
+var init_shaderTargets = __esm(() => {
+  externalSamplerReg = /type\s*:\s*samplerExternal/g;
+  PLATFORM_BUILD = {
+    opengl: { profile: "mobile", api: "opengl", replaceExternal: false },
+    metal: { profile: "mobile", api: "metal", replaceExternal: false },
+    webgl: { profile: "mobile", api: "opengl", replaceExternal: true },
+    desktop: { profile: "desktop", api: "opengl", replaceExternal: true }
+  };
+});
+
+// ../sdk/src/compile/liteMaterial.ts
+var extractMatBlocks = (text) => {
+  const blocks = {};
+  let i = 0;
+  const skipNoise = () => {
+    for (;; ) {
+      while (i < text.length && /\s/.test(text[i]))
+        i++;
+      if (text[i] === "/" && text[i + 1] === "/") {
+        while (i < text.length && text[i] !== `
+`)
+          i++;
+      } else if (text[i] === "/" && text[i + 1] === "*") {
+        i += 2;
+        while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+          i++;
+        i += 2;
+      } else
+        return;
+    }
+  };
+  while (i < text.length) {
+    skipNoise();
+    const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(i));
+    if (!m) {
+      i++;
+      continue;
+    }
+    i += m[0].length;
+    skipNoise();
+    if (text[i] !== "{")
+      continue;
+    let depth = 0;
+    const start = i;
+    while (i < text.length) {
+      const c2 = text[i];
+      if (c2 === "/" && text[i + 1] === "/") {
+        while (i < text.length && text[i] !== `
+`)
+          i++;
+      } else if (c2 === "/" && text[i + 1] === "*") {
+        i += 2;
+        while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+          i++;
+        i++;
+      } else if (c2 === "{")
+        depth++;
+      else if (c2 === "}") {
+        depth--;
+        if (depth === 0)
+          break;
+      }
+      i++;
+    }
+    blocks[m[0]] = text.slice(start + 1, i);
+    i++;
+  }
+  return blocks;
+}, parseJsonish = (src) => {
+  let i = 0;
+  const fail = (msg) => {
+    throw new Error(`material block: ${msg} at offset ${i}`);
+  };
+  const skip = () => {
+    for (;; ) {
+      while (i < src.length && /[\s,]/.test(src[i]))
+        i++;
+      if (src[i] === "/" && src[i + 1] === "/") {
+        while (i < src.length && src[i] !== `
+`)
+          i++;
+      } else if (src[i] === "/" && src[i + 1] === "*") {
+        i += 2;
+        while (i < src.length && !(src[i] === "*" && src[i + 1] === "/"))
+          i++;
+        i += 2;
+      } else
+        return;
+    }
+  };
+  const quoted = (q) => {
+    i++;
+    const start = i;
+    while (i < src.length && src[i] !== q)
+      i++;
+    return src.slice(start, i++);
+  };
+  const word = () => {
+    const m = /^[^\s{}[\]:,="']+/.exec(src.slice(i));
+    if (!m)
+      fail("expected a value");
+    i += m[0].length;
+    return m[0];
+  };
+  const value = () => {
+    skip();
+    const c2 = src[i];
+    if (c2 === "{")
+      return object();
+    if (c2 === "[")
+      return array();
+    if (c2 === '"' || c2 === "'")
+      return quoted(c2);
+    const w = word();
+    if (w === "true")
+      return true;
+    if (w === "false")
+      return false;
+    const n = Number(w);
+    return Number.isNaN(n) ? w : n;
+  };
+  const array = () => {
+    i++;
+    const out = [];
+    for (;; ) {
+      skip();
+      if (i >= src.length)
+        fail("unterminated array");
+      if (src[i] === "]") {
+        i++;
+        return out;
+      }
+      out.push(value());
+    }
+  };
+  const object = () => {
+    i++;
+    const out = {};
+    for (;; ) {
+      skip();
+      if (i >= src.length)
+        fail("unterminated object");
+      if (src[i] === "}") {
+        i++;
+        return out;
+      }
+      const key = src[i] === '"' || src[i] === "'" ? quoted(src[i]) : word();
+      skip();
+      if (src[i] !== ":" && src[i] !== "=")
+        fail(`expected ':' after key "${key}"`);
+      i++;
+      out[key] = value();
+    }
+  };
+  skip();
+  if (src[i] !== "{")
+    fail("expected '{'");
+  return object();
+}, PARAM_TYPES, SAMPLER_TYPES, unsupported = (reason) => ({
+  lecodesLiteMaterial: 1,
+  unsupported: reason,
+  shadingModel: "unlit",
+  blending: "opaque",
+  maskThreshold: 0.4,
+  doubleSided: false,
+  culling: "back",
+  depthWrite: true,
+  shadowMultiplier: false,
+  params: [],
+  samplers: [],
+  fragmentCode: "",
+  writesNormal: false,
+  hasVertexBlock: false
+}), buildLiteMaterialArtifact = (text) => {
+  try {
+    const blocks = extractMatBlocks(text);
+    if (blocks.material === undefined)
+      return unsupported("no material block");
+    if (blocks.fragment === undefined)
+      return unsupported("no fragment block");
+    const def = parseJsonish("{" + blocks.material + "}");
+    const params = [];
+    const samplers = [];
+    const rawParams = def.parameters === undefined ? [] : Array.isArray(def.parameters) ? def.parameters : [def.parameters];
+    for (const raw of rawParams) {
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return unsupported("malformed parameter entry");
+      const name = String(raw.name ?? "");
+      const typeRaw = String(raw.type ?? "");
+      const typeMatch = /^(\w+)(?:\[(\d+)\])?$/.exec(typeRaw);
+      if (!name || !typeMatch)
+        return unsupported(`malformed parameter "${name || typeRaw}"`);
+      const [, type, size] = typeMatch;
+      if (SAMPLER_TYPES.has(type)) {
+        if (size)
+          return unsupported(`sampler arrays are not supported ("${name}")`);
+        samplers.push({ name });
+      } else if (PARAM_TYPES.has(type)) {
+        params.push(size ? { name, type, size: Number(size) } : { name, type });
+      } else {
+        return unsupported(`parameter type "${typeRaw}" ("${name}")`);
+      }
+    }
+    const shadingModel = def.shadingModel === "unlit" ? "unlit" : "lit";
+    const blendingRaw = String(def.blending ?? "opaque");
+    const blending = blendingRaw === "transparent" || blendingRaw === "fade" || blendingRaw === "add" || blendingRaw === "masked" ? blendingRaw : blendingRaw === "multiply" || blendingRaw === "screen" ? "transparent" : "opaque";
+    const culling = def.culling === "none" ? "none" : def.culling === "front" ? "front" : "back";
+    const depthWrite = typeof def.depthWrite === "boolean" ? def.depthWrite : blending !== "transparent" && blending !== "fade" && blending !== "add";
+    const fragmentCode = blocks.fragment.replace(/\bmaterialParams\./g, "materialParams_");
+    if (!/\bvoid\s+material\s*\(/.test(fragmentCode))
+      return unsupported("fragment block has no material() function");
+    return {
+      lecodesLiteMaterial: 1,
+      shadingModel,
+      blending,
+      maskThreshold: typeof def.maskThreshold === "number" ? def.maskThreshold : 0.4,
+      doubleSided: def.doubleSided === true,
+      culling,
+      depthWrite,
+      shadowMultiplier: def.shadowMultiplier === true,
+      params,
+      samplers,
+      fragmentCode,
+      writesNormal: /\.normal\s*=/.test(fragmentCode),
+      hasVertexBlock: blocks.vertex !== undefined
+    };
+  } catch (e) {
+    return unsupported(e instanceof Error ? e.message : String(e));
+  }
+};
+var init_liteMaterial = __esm(() => {
+  PARAM_TYPES = new Set([
+    "float",
+    "float2",
+    "float3",
+    "float4",
+    "int",
+    "int2",
+    "int3",
+    "int4",
+    "bool",
+    "bool2",
+    "bool3",
+    "bool4",
+    "float3x3",
+    "float4x4"
+  ]);
+  SAMPLER_TYPES = new Set(["sampler2d", "samplerExternal"]);
+});
+
 // ../sdk/src/compile/sourcemap.ts
 var offsetSourceMap = (mapJson, lines) => {
   if (lines <= 0)
@@ -171494,7 +171752,10 @@ var buildHeader = (name, code, opts = {}) => {
 `;
   const localAssets = new Set;
   for (const m of code.matchAll(/_creatorUtils\.fetchLocal\((.+?)\)/g)) {
-    localAssets.add(m[1].replaceAll(/['"]/g, "").trim());
+    const arg = m[1].trim();
+    if (!/^(['"])[^'"]*\1$/.test(arg))
+      continue;
+    localAssets.add(arg.slice(1, -1).trim());
   }
   if (/_creator\.createGlb/.test(code))
     localAssets.add("uberarchive");
@@ -171540,7 +171801,11 @@ var compileProject = async (opts) => {
       }
     } else if (e.type === "shader") {
       const shaders = e.shaders ?? [];
-      if (shaders.length > 2) {
+      if (e.shadersLocal && shaders.length > 0) {
+        const name = shaders[0].src.split(/[\\/]/).pop() ?? "";
+        const [prefix, suffix = ".filamat"] = name.split("_opengl");
+        files[e.path] = `export default ("id:" + _creatorUtils.fetchLocal(${JSON.stringify(prefix + "_")} + _creator.backend + ${JSON.stringify(suffix)}))`;
+      } else if (shaders.length > 2) {
         files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.subBackend ?? _creator.backend}")}\``;
       } else if (shaders.length > 0) {
         files[e.path] = `export default \`${opts.publicUrl}${shaders[0].src.replace("_opengl", "_${_creator.backend}")}\``;
@@ -172479,7 +172744,10 @@ __export(exports_compile, {
   sanitizeAssetName: () => sanitizeAssetName,
   rewriteAssetIcons: () => rewriteAssetIcons,
   parseSfnt: () => parseSfnt,
+  parseJsonish: () => parseJsonish,
   offsetSourceMap: () => offsetSourceMap,
+  matcPlatformsFor: () => matcPlatformsFor,
+  matcArgs: () => matcArgs,
   loadSceneHarness: () => loadSceneHarness,
   isServerPath: () => isServerPath,
   isCanonicalAssetName: () => isCanonicalAssetName,
@@ -172487,6 +172755,8 @@ __export(exports_compile, {
   iconNotFoundError: () => iconNotFoundError,
   fontRegistryBase: () => fontRegistryBase,
   faceFileName: () => faceFileName,
+  extractMatBlocks: () => extractMatBlocks,
+  externalSamplerReg: () => externalSamplerReg,
   detectProjectKind: () => detectProjectKind,
   detectEntry: () => detectEntry,
   deriveEndpointParams: () => deriveEndpointParams,
@@ -172495,6 +172765,7 @@ __export(exports_compile, {
   collectVendoredIcons: () => collectVendoredIcons,
   bundleProjectWithMap: () => bundleProjectWithMap,
   bundleProject: () => bundleProject,
+  buildLiteMaterialArtifact: () => buildLiteMaterialArtifact,
   buildIconsHeaderValue: () => buildIconsHeaderValue,
   buildHeader: () => buildHeader,
   buildFontsHeaderValue: () => buildFontsHeaderValue,
@@ -172504,6 +172775,7 @@ __export(exports_compile, {
   SERVER_ENTRY_PATH: () => SERVER_ENTRY_PATH,
   SCENE_HARNESS_DIR: () => SCENE_HARNESS_DIR,
   SCENE_ENTRY_PATH: () => SCENE_ENTRY_PATH,
+  PLATFORM_BUILD: () => PLATFORM_BUILD,
   ICON_ID: () => ICON_ID,
   FONT_REGISTRY: () => FONT_REGISTRY,
   EndpointTypeError: () => EndpointTypeError,
@@ -172517,6 +172789,8 @@ var init_compile = __esm(() => {
   init_serverTypes();
   init_detectEntry();
   init_assetName();
+  init_shaderTargets();
+  init_liteMaterial();
   init_compileProject();
   init_sceneEditor();
   init_fontMacro();
@@ -172544,7 +172818,7 @@ var vendoredInject, resolveChiselBin2 = () => {
     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 })),
+  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,
@@ -172682,11 +172956,11 @@ var init_fonts = __esm(() => {
 });
 
 // src/compile/assetIcons.ts
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname7, join as join11 } from "node:path";
-var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => createHash3("sha256").update(s).digest("hex").slice(0, 12), readText = async (registry, rel) => {
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname7, join as join14 } 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) => {
   if (isHttp2(registry)) {
     try {
       const res = await fetch(`${registry}/${rel}`);
@@ -172696,21 +172970,21 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
     }
   }
   try {
-    return readFileSync10(join11(registry, rel), "utf8");
+    return readFileSync11(join14(registry, rel), "utf8");
   } catch {
     return null;
   }
 }, safeRead = (path) => {
   try {
-    return readFileSync10(path, "utf8");
+    return readFileSync11(path, "utf8");
   } catch {
     return null;
   }
 }, writeIfChanged2 = (path, text) => {
-  const current = existsSync9(path) ? safeRead(path) : null;
+  const current = existsSync12(path) ? safeRead(path) : null;
   if (current === text)
     return false;
-  writeFileSync6(path, text);
+  writeFileSync8(path, text);
   return true;
 }, fetchIcon = async (registry, pack, name) => {
   const svg = await readText(registry, `${pack}/${name}.svg`);
@@ -172724,7 +172998,7 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
   return JSON.parse(raw);
 }, readLock2 = (path) => {
   try {
-    const lock = JSON.parse(readFileSync10(path, "utf8"));
+    const lock = JSON.parse(readFileSync11(path, "utf8"));
     if (lock && typeof lock === "object" && lock.icons && lock.packs)
       return lock;
   } catch {}
@@ -172759,13 +173033,13 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
 `);
 }, vendorIcons = async (designDir, ids, opts = {}) => {
   const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
-  const lockPath = join11(designDir, "icons.lock.json");
+  const lockPath = join14(designDir, "icons.lock.json");
   const lock = readLock2(lockPath) ?? { registry, icons: {}, packs: {} };
   const svgById = new Map;
   const missing = [];
   for (const id of ids) {
     const li = lock.icons[id];
-    const cached = li && safeRead(join11(designDir, li.path));
+    const cached = li && safeRead(join14(designDir, li.path));
     if (cached)
       svgById.set(id, cached);
     else
@@ -172781,9 +173055,9 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
         throw new Error(`assetIcon: unknown icon pack "${pack}" (in "${id}"). Available packs: ${Object.keys(licenses).sort().join(", ")}.`);
       const svg = await fetchIcon(registry, pack, name);
       const rel = `assets/icons/${pack}/${name}.svg`;
-      const abs = join11(designDir, rel);
-      mkdirSync5(dirname7(abs), { recursive: true });
-      writeFileSync6(abs, svg);
+      const abs = join14(designDir, rel);
+      mkdirSync7(dirname7(abs), { recursive: true });
+      writeFileSync8(abs, svg);
       lock.icons[id] = { pack, name, hash: sha122(svg), spdx: lic.spdx, path: rel };
       lock.packs[pack] = { spdx: lic.spdx, title: lic.title, url: lic.url, attribution: lic.attribution, modifiedNotice: lic.modifiedNotice };
       svgById.set(id, svg);
@@ -172792,25 +173066,25 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
     writeIfChanged2(lockPath, serializeLock2(lock));
   }
   if (Object.keys(lock.icons).length)
-    writeIfChanged2(join11(designDir, "ICON-NOTICES.md"), renderNotices2(lock));
+    writeIfChanged2(join14(designDir, "ICON-NOTICES.md"), renderNotices2(lock));
   return svgById;
 }, applyAssetIcons = async (entries, designDir, opts = {}) => {
   await applyAssetIconMacro(entries, (ids) => vendorIcons(designDir, ids, opts));
-}, defaultCacheDir = () => join11(homedir2(), ".lecodes", "cache", "icons"), cacheIcons = async (ids, opts = {}) => {
+}, defaultCacheDir = () => join14(homedir3(), ".lecodes", "cache", "icons"), cacheIcons = async (ids, opts = {}) => {
   const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
   const cacheDir = opts.cacheDir ?? defaultCacheDir();
   const svgById = new Map;
   for (const id of ids) {
     const [, pack, name] = ICON_ID.exec(id);
-    const cachePath = join11(cacheDir, pack, `${name}.svg`);
+    const cachePath = join14(cacheDir, pack, `${name}.svg`);
     const cached = safeRead(cachePath);
     if (cached) {
       svgById.set(id, cached);
       continue;
     }
     const svg = await fetchIcon(registry, pack, name);
-    mkdirSync5(dirname7(cachePath), { recursive: true });
-    writeFileSync6(cachePath, svg);
+    mkdirSync7(dirname7(cachePath), { recursive: true });
+    writeFileSync8(cachePath, svg);
     svgById.set(id, svg);
   }
   return svgById;
@@ -177889,7 +178163,7 @@ var require_image_q = __commonJS((exports, module) => {
     colors,
     onProgress
   } = {}) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
       const paletteQuantizer = paletteQuantizationToPaletteQuantizer(distanceCalculator, paletteQuantization, colors);
       images.forEach((image2) => paletteQuantizer.sample(image2));
@@ -177899,7 +178173,7 @@ var require_image_q = __commonJS((exports, module) => {
         try {
           const result = iterator.next();
           if (result.done) {
-            resolve3(palette2);
+            resolve4(palette2);
           } else {
             if (result.value.palette)
               palette2 = result.value.palette;
@@ -177924,7 +178198,7 @@ var require_image_q = __commonJS((exports, module) => {
     imageQuantization,
     onProgress
   } = {}) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
       const imageQuantizer = imageQuantizationToImageQuantizer(distanceCalculator, imageQuantization);
       let outPointContainer;
@@ -177933,7 +178207,7 @@ var require_image_q = __commonJS((exports, module) => {
         try {
           const result = iterator.next();
           if (result.done) {
-            resolve3(outPointContainer);
+            resolve4(outPointContainer);
           } else {
             if (result.value.pointContainer) {
               outPointContainer = result.value.pointContainer;
@@ -178267,22 +178541,22 @@ var require_gifutil = __commonJS((exports) => {
     }
   }
   function _readBinary(path) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs.readFile(path, (err, buffer) => {
         if (err) {
           return reject(err);
         }
-        return resolve3(buffer);
+        return resolve4(buffer);
       });
     });
   }
   function _writeBinary(path, buffer) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       fs.writeFile(path, buffer, (err) => {
         if (err) {
           return reject(err);
         }
-        return resolve3();
+        return resolve4();
       });
     });
   }
@@ -195848,7 +196122,7 @@ var require_await_to_js_umd = __commonJS((exports, module) => {
 
 // ../../node_modules/.bun/@jimp+file-ops@1.6.1/node_modules/@jimp/file-ops/dist/esm/index.js
 import { promises as fs } from "fs";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 var readFile, writeFile;
 var init_esm13 = __esm(() => {
   readFile = fs.readFile;
@@ -197515,9 +197789,9 @@ class Deferred {
   constructor() {
     this.resolve = () => null;
     this.reject = () => null;
-    this.promise = new Promise((resolve3, reject) => {
+    this.promise = new Promise((resolve4, reject) => {
       this.reject = reject;
-      this.resolve = resolve3;
+      this.resolve = resolve4;
     });
   }
 }
@@ -200209,7 +200483,7 @@ function readByobReaderWithSignal(reader, buffer, signal) {
     return reader.read(buffer);
   }
   signal.throwIfAborted();
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const cleanup = () => {
       signal.removeEventListener("abort", onAbort);
     };
@@ -200228,7 +200502,7 @@ function readByobReaderWithSignal(reader, buffer, signal) {
       try {
         const result = await reader.read(buffer);
         cleanup();
-        resolve3(result);
+        resolve4(result);
       } catch (error) {
         cleanup();
         reject(error);
@@ -202120,7 +202394,7 @@ var init_file_type = __esm(() => {
       const { signal } = this.options;
       const normalizedSampleSize = normalizeSampleSize(sampleSize);
       signal?.throwIfAborted();
-      return new Promise((resolve3, reject) => {
+      return new Promise((resolve4, reject) => {
         let isSettled = false;
         const cleanup = () => {
           readableStream.off("error", onError);
@@ -202159,7 +202433,7 @@ var init_file_type = __esm(() => {
                   settle(reject, error);
                 }
               }
-              settle(resolve3, outputStream);
+              settle(resolve4, outputStream);
             } catch (error) {
               settle(reject, error);
             }
@@ -202228,7 +202502,7 @@ function createJimp({ plugins: pluginsArg, formats: formatsArg } = {}) {
       if (Buffer.isBuffer(url) || url instanceof ArrayBuffer) {
         return this.fromBuffer(url);
       }
-      if (existsSync11(url)) {
+      if (existsSync14(url)) {
         return this.fromBuffer(await readFile(url));
       }
       const [fetchErr, response] = await import_await_to_js.to(fetch(url));
@@ -212491,12 +212765,12 @@ var require_parser3 = __commonJS((exports) => {
       };
       Parser.prototype.parseStringPromise = function(str) {
         return new Promise(function(_this) {
-          return function(resolve3, reject) {
+          return function(resolve4, reject) {
             return _this.parseString(str, function(err, value) {
               if (err) {
                 return reject(err);
               } else {
-                return resolve3(value);
+                return resolve4(value);
               }
             });
           };
@@ -213129,8 +213403,8 @@ var init_load_bitmap_font = __esm(() => {
 async function loadFont(file) {
   let fileOrBuffer = file;
   if (typeof window === "undefined" && !isWebWorker) {
-    const { existsSync: existsSync12, promises: fs3 } = await import("fs");
-    if (existsSync12(file)) {
+    const { existsSync: existsSync15, promises: fs3 } = await import("fs");
+    if (existsSync15(file)) {
       fileOrBuffer = await fs3.readFile(file);
     }
   }
@@ -213453,65 +213727,65 @@ var init_esm30 = __esm(() => {
 });
 
 // src/types.ts
-import { dirname as dirname13, join as join18, relative as relative3, sep } from "node:path";
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readdirSync as readdirSync8, readFileSync as readFileSync16, rmSync as rmSync5, statSync as statSync6, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname13, join as join21, relative as relative3, sep } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync14, readdirSync as readdirSync9, readFileSync as readFileSync17, rmSync as rmSync7, statSync as statSync7, writeFileSync as writeFileSync16 } from "node:fs";
 var TSCONFIG, listBundleFiles = (dir, base = dir) => {
-  if (!existsSync17(dir))
+  if (!existsSync20(dir))
     return [];
   const out = [];
-  for (const name of readdirSync8(dir)) {
-    const path2 = join18(dir, name);
-    if (statSync6(path2).isDirectory())
+  for (const name of readdirSync9(dir)) {
+    const path2 = join21(dir, name);
+    if (statSync7(path2).isDirectory())
       out.push(...listBundleFiles(path2, base));
     else
       out.push(relative3(base, path2).split(sep).join("/"));
   }
   return out;
 }, pruneEmptyDirs = (dir, root) => {
-  if (!existsSync17(dir) || !statSync6(dir).isDirectory())
+  if (!existsSync20(dir) || !statSync7(dir).isDirectory())
     return;
-  for (const name of readdirSync8(dir))
-    pruneEmptyDirs(join18(dir, name), root);
-  if (dir !== root && readdirSync8(dir).length === 0)
-    rmSync5(dir, { recursive: true });
+  for (const name of readdirSync9(dir))
+    pruneEmptyDirs(join21(dir, name), root);
+  if (dir !== root && readdirSync9(dir).length === 0)
+    rmSync7(dir, { recursive: true });
 }, writeTypeBundle = (root, bundle) => {
-  const typesDir = join18(root, LECODES_DIR, "types");
+  const typesDir = join21(root, LECODES_DIR, "types");
   const before = new Set(listBundleFiles(typesDir));
   const stats = { added: 0, updated: 0, removed: 0, total: Object.keys(bundle).length };
   for (const [path2, text] of Object.entries(bundle)) {
-    const dest = join18(typesDir, path2);
+    const dest = join21(typesDir, path2);
     if (!before.has(path2))
       stats.added++;
-    else if (readFileSync16(dest, "utf8") !== text)
+    else if (readFileSync17(dest, "utf8") !== text)
       stats.updated++;
     else
       continue;
-    mkdirSync12(dirname13(dest), { recursive: true });
-    writeFileSync14(dest, text);
+    mkdirSync14(dirname13(dest), { recursive: true });
+    writeFileSync16(dest, text);
   }
   for (const path2 of before) {
     if (path2 in bundle)
       continue;
-    rmSync5(join18(typesDir, path2));
+    rmSync7(join21(typesDir, path2));
     stats.removed++;
   }
   pruneEmptyDirs(typesDir, typesDir);
   return stats;
 }, bundleHash = (bundle) => sha256(Object.keys(bundle).sort().map((k) => `${k}\x00${bundle[k]}`).join("\x00")), readProjectTypeBundle = (root) => {
-  const typesDir = join18(root, LECODES_DIR, "types");
+  const typesDir = join21(root, LECODES_DIR, "types");
   const bundle = {};
   for (const path2 of listBundleFiles(typesDir))
-    bundle[path2] = readFileSync16(join18(typesDir, path2), "utf8");
+    bundle[path2] = readFileSync17(join21(typesDir, path2), "utf8");
   return bundle;
 }, materializeTypes = async (root, apiUrl) => writeTypeBundle(root, await getTypes(apiUrl)), readLocalTypeBundle = () => {
   const candidates = [
-    join18(distRoot, "runtime", "sdk-types.json"),
-    join18(distRoot, "..", "sdk", "dist", "types.json")
+    join21(distRoot, "runtime", "sdk-types.json"),
+    join21(distRoot, "..", "sdk", "dist", "types.json")
   ];
   for (const path2 of candidates) {
-    if (existsSync17(path2)) {
+    if (existsSync20(path2)) {
       try {
-        return JSON.parse(readFileSync16(path2, "utf8"));
+        return JSON.parse(readFileSync17(path2, "utf8"));
       } catch {}
     }
   }
@@ -213523,7 +213797,7 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   writeTypeBundle(root, bundle);
   return true;
 }, writeTsconfig = (root) => {
-  writeFileSync14(join18(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+  writeFileSync16(join21(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
 };
 var init_types4 = __esm(() => {
   init_api();
@@ -213549,14 +213823,14 @@ var init_types4 = __esm(() => {
 });
 
 // src/compile/designCompile.ts
-import { readFileSync as readFileSync17 } from "node:fs";
-import { basename as basename7 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { basename as basename8 } from "node:path";
 var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) => {
   const { root, manifest, designDir, designKey, screenId, state } = opts;
   const entries = [];
   const scan2 = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
   for (const file of scan2.files) {
-    const type = manifest?.files[file.path]?.type ?? classifyKind(basename7(file.path));
+    const type = manifest?.files[file.path]?.type ?? classifyKind(basename8(file.path));
     if (type === "resource") {
       entries.push({
         path: file.path,
@@ -213567,7 +213841,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: readFileSync17(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync18(file.absPath, "utf8") });
     }
   }
   const invoke = state !== undefined ? `screen(${JSON.stringify(state)})` : "screen()";
@@ -213613,7 +213887,7 @@ var init_designCompile = __esm(() => {
 // src/browserAuth.ts
 import { createServer } from "node:http";
 import { spawn as spawn4 } from "node:child_process";
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 import { hostname } from "node:os";
 var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
 <body style="font-family:system-ui,sans-serif;background:#0f1115;color:#e6e6e6;display:grid;place-items:center;height:100vh;margin:0">
@@ -213642,11 +213916,11 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     child.unref();
   } catch {}
 }, browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser) => {
-  const state = randomBytes(16).toString("hex");
-  let resolve9;
+  const state = randomBytes2(16).toString("hex");
+  let resolve10;
   let reject;
   const tokenPromise = new Promise((res, rej) => {
-    resolve9 = res;
+    resolve10 = res;
     reject = rej;
   });
   const server2 = createServer((req, res) => {
@@ -213664,7 +213938,7 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     }
     res.writeHead(200, { "content-type": "text/html" });
     res.end(SUCCESS_HTML);
-    resolve9(token);
+    resolve10(token);
   });
   await new Promise((res, rej) => {
     server2.once("error", rej);
@@ -214165,8 +214439,8 @@ __export(exports_design, {
   flushDesignComments: () => flushDesignComments,
   design: () => design
 });
-import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync18, readdirSync as readdirSync11, writeFileSync as writeFileSync16, appendFileSync } from "node:fs";
-import { basename as basename8, join as join20 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync17, readFileSync as readFileSync19, readdirSync as readdirSync12, writeFileSync as writeFileSync18, appendFileSync } from "node:fs";
+import { basename as basename9, join as join23 } from "node:path";
 var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   let root;
   let manifest;
@@ -214181,13 +214455,13 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   return {
     root,
     manifest,
-    name: manifest?.name ?? basename8(root),
+    name: manifest?.name ?? basename9(root),
     dirName,
-    designDir: join20(root, dirName),
+    designDir: join23(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 }, loadDesignServer = async (ctx, needs = []) => {
-  if (!existsSync20(ctx.designDir)) {
+  if (!existsSync23(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let mod;
@@ -214219,13 +214493,13 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
 `).find((l2) => l2.trim())?.trim() ?? "";
   return line.length > max ? line.slice(0, max - 1) + "…" : line;
 }, listScreens = (designDir) => {
-  const dir = join20(designDir, "screens");
-  if (!existsSync20(dir))
+  const dir = join23(designDir, "screens");
+  if (!existsSync23(dir))
     return [];
-  return readdirSync11(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
+  return readdirSync12(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
 }, PHONE_SIZE, readMetaFrames = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync18(join20(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync19(join23(designDir, "meta.json"), "utf8"));
     const d = meta?.defaultSize;
     const valid = Array.isArray(d) && d.length === 2 && d.every((n2) => typeof n2 === "number" && Number.isFinite(n2) && n2 >= 64 && n2 <= 8192);
     return {
@@ -214236,12 +214510,12 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     return { screens: {}, defaultSize: PHONE_SIZE };
   }
 }, writeMcpConfig = (ctx, port) => {
-  const path2 = join20(ctx.root, ".mcp.json");
+  const path2 = join23(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync20(path2)) {
+  if (existsSync23(path2)) {
     try {
-      config = JSON.parse(readFileSync18(path2, "utf8"));
+      config = JSON.parse(readFileSync19(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-design server by hand.");
       return;
@@ -214254,7 +214528,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     return;
   }
   config.mcpServers["lecodes-design"] = entry;
-  writeFileSync16(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync18(path2, JSON.stringify(config, null, 2) + `
 `);
   log(`${c.green(existing ? "updated" : "created")}   .mcp.json (lecodes-design MCP → ${entry.url})`);
 }, init = async (ctx, args) => {
@@ -214263,26 +214537,26 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join20("shared", "tokens.ts"), TOKENS_TS],
-    [join20("shared", "tabs.ts"), TABS_TS],
-    [join20("screens", "home.ts"), HOME_SCREEN_TS]
+    [join23("shared", "tokens.ts"), TOKENS_TS],
+    [join23("shared", "tabs.ts"), TABS_TS],
+    [join23("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync15(join20(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync15(join20(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync17(join23(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync17(join23(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join20(ctx.designDir, rel);
-    if (existsSync20(abs)) {
+    const abs = join23(ctx.designDir, rel);
+    if (existsSync23(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
     }
-    writeFileSync16(abs, content);
+    writeFileSync18(abs, content);
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join20(ctx.root, ".lecodesignore");
+  const ignorePath = join23(ctx.root, ".lecodesignore");
   const ignoreLines = [`${ctx.dirName}/.snapshots/`, `${ctx.dirName}/comments/`];
-  const current = existsSync20(ignorePath) ? readFileSync18(ignorePath, "utf8") : "";
+  const current = existsSync23(ignorePath) ? readFileSync19(ignorePath, "utf8") : "";
   const present = new Set(current.split(/\r?\n/));
   const missing = ignoreLines.filter((line) => !present.has(line));
   if (missing.length) {
@@ -214297,8 +214571,8 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   writeMcpConfig(ctx, Number(flagStr(args, "port")) || DEFAULT_PORT);
   const wroteTypes = materializeTypesLocal(ctx.designDir);
   writeTsconfig(ctx.designDir);
-  mkdirSync15(join20(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync16(join20(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync17(join23(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync18(join23(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
   log(`${c.green("created")}   ${ctx.dirName}/tsconfig.json${wroteTypes ? ` + ${ctx.dirName}/.lecodes/types/` : ""}  (IDE types)`);
   if (!wroteTypes)
     warnErr("Bundled SDK types not found — tsconfig written, but globals may show unresolved until the CLI is rebuilt with vendored types.");
@@ -214346,16 +214620,16 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   killer.unref?.();
   const png2 = flagBool(args, "png") || flagStr(args, "png") !== undefined;
   const frames = readMetaFrames(ctx.designDir);
-  const outDir = flagStr(args, "out-dir") ?? join20(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join23(ctx.designDir, ".snapshots");
   const single = targets.length === 1 && requested.length === 1 && !png2 && !allStates && !flagStr(args, "out-dir");
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
   if (!single)
-    mkdirSync15(outDir, { recursive: true });
+    mkdirSync17(outDir, { recursive: true });
   for (const id of targets) {
     const [width, height] = frames.screens[id]?.size ?? frames.defaultSize;
     let plan = [{ state: undefined, bases: [id] }];
     if (discover) {
-      const { states, canonical } = discover(readFileSync18(join20(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync19(join23(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -214396,11 +214670,11 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
         for (const w of pngResult.warnings)
           warnErr(`${tag}: ${w}`);
       for (const base of bases) {
-        writeFileSync16(join20(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join20(outDir, `${base}.json`)}`);
+        writeFileSync18(join23(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join23(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync16(join20(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join20(outDir, `${base}.png`)}`);
+          writeFileSync18(join23(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join23(outDir, `${base}.png`)}`);
         }
       }
     }
@@ -214702,7 +214976,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     note("Read them with:  lecodes design comments");
 }, flushDesignComments = async (args) => {
   const ctx = getContext(args);
-  if (!existsSync20(ctx.designDir))
+  if (!existsSync23(ctx.designDir))
     return null;
   const platform = optionalPlatform(ctx);
   if (!platform)
@@ -215844,7 +216118,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.17.1",
+  version: "0.18.0",
   dependencies: {
     "@letary/chisel": "^0.8.0",
     jimp: "^1.6.1"
@@ -215860,8 +216134,8 @@ var package_default = {
   },
   peerDependencies: {
     "lecodes-design": "^0.8.1",
-    "lecodes-renderer": "^0.8.6",
-    "lecodes-3d-editor": "^0.3.0",
+    "lecodes-renderer": "^0.8.8",
+    "lecodes-3d-editor": "^0.4.0",
     "lecodes-assets": "^0.1.0"
   },
   bin: {
@@ -215912,16 +216186,16 @@ var package_default = {
 init_manifest();
 init_config();
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { cpSync as cpSync3, existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync15, readdirSync as readdirSync7, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync13 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename6, dirname as dirname12, join as join17, resolve as resolve6 } from "node:path";
+import { cpSync as cpSync3, existsSync as existsSync19, mkdirSync as mkdirSync13, readFileSync as readFileSync16, readdirSync as readdirSync8, rmSync as rmSync6, statSync as statSync6, writeFileSync as writeFileSync15 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { basename as basename7, dirname as dirname12, join as join20, resolve as resolve7 } from "node:path";
 
 // src/commands/compile.ts
 init_api();
 init_config();
 init_manifest();
-import { writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename3, resolve as resolve2 } from "node:path";
+import { writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename4, resolve as resolve3 } from "node:path";
 
 // src/compile/collect.ts
 init_localFiles();
@@ -216011,7 +216285,7 @@ init_localFiles();
 init_ignore();
 import { readFileSync as readFileSync6 } from "node:fs";
 import { basename as basename2 } from "node:path";
-var collectLocalEntries = (root, manifest, assetBase) => {
+var collectLocalEntries = (root, manifest, assetBase, opts = {}) => {
   const entries = [];
   const warnings = [];
   const scan = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
@@ -216020,8 +216294,10 @@ var collectLocalEntries = (root, manifest, assetBase) => {
     if (type === "resource") {
       entries.push({ path: file.path, type, fileSrc: assetBase + encodeURI(file.path), absPath: file.absPath });
     } else if (type === "shader") {
-      warnings.push(`${file.path}: shaders compile on the server — push the project once for shaders to work in dev mode.`);
-      entries.push({ path: file.path, type, shaders: [] });
+      if (!opts.localShaders) {
+        warnings.push(`${file.path}: shaders compile on the server — push the project once for shaders to work in dev mode.`);
+      }
+      entries.push({ path: file.path, type, shaders: [], absPath: file.absPath });
     } else {
       entries.push({ path: file.path, type, text: readFileSync6(file.absPath, "utf8") });
     }
@@ -216032,6 +216308,266 @@ var collectLocalEntries = (root, manifest, assetBase) => {
 // src/commands/compile.ts
 init_projectCompile();
 init_fonts();
+
+// src/compile/shaders.ts
+init_compile();
+import { execFile } from "node:child_process";
+import { createHash as createHash4, randomBytes } from "node:crypto";
+import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename as basename3, join as join13 } from "node:path";
+
+// src/matcTool.ts
+import { existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join12, resolve } from "node:path";
+
+// src/releases.ts
+init_util();
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, mkdtempSync, renameSync, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join11 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json";
+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 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(join11(opts.cacheRoot, "dl-"));
+  try {
+    const archiveName = file.url.split("/").pop() ?? "archive";
+    const archive = join11(stage, archiveName);
+    writeFileSync6(archive, bytes);
+    const winTar = join11(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+    const tarExe = process.platform === "win32" && existsSync9(winTar) ? winTar : "tar";
+    const tar = spawnSync2(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);
+    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/matcTool.ts
+init_util();
+var matcName = () => process.platform === "win32" ? "matc.exe" : "matc";
+var platformKey = () => {
+  if (process.platform === "win32")
+    return "windows-x64";
+  if (process.platform === "linux")
+    return "linux-x64";
+  throw new CliError(process.platform === "darwin" ? "matc isn't published for macOS yet — push the project once so shaders compile on the server." : `matc isn't published for ${process.platform}.`);
+};
+var cacheRoot = () => join12(homedir2(), ".lecodes", "matc");
+var findMatc = (dir) => {
+  const name = matcName();
+  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    const p = join12(dir, entry.name);
+    if (entry.isFile() && entry.name === name)
+      return p;
+    if (entry.isDirectory()) {
+      const found = findMatc(p);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+};
+var installedMatcVersions = () => {
+  try {
+    return readdirSync4(cacheRoot(), { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("matc-")).map((e) => e.name.slice("matc-".length)).filter((v) => findMatc(join12(cacheRoot(), `matc-${v}`)) !== null).sort(semverNewer);
+  } catch {
+    return [];
+  }
+};
+var fetchMatcManifest = () => fetchReleaseProduct("matc", "matc (shader compiler)");
+var downloadMatc = async (version, versions, dest) => {
+  const key = platformKey();
+  const file = versions.find((v) => v.version === version)?.files[key];
+  if (!file) {
+    throw new CliError(`matc ${version} [${key}] isn't published — push the project once so shaders compile on the ` + `server, or set LECODES_MATC to a locally built matc.`);
+  }
+  note(`Downloading the shader compiler (matc ${version}, ${(file.size / 1024 / 1024).toFixed(1)} MB)…`);
+  await downloadReleaseArchive(file, {
+    cacheRoot: cacheRoot(),
+    dest,
+    validate: (dir) => findMatc(dir) ? null : "The downloaded archive doesn't contain the matc binary."
+  });
+};
+var resolveMatcExeCached = () => {
+  const override = process.env.LECODES_MATC;
+  if (override) {
+    if (!existsSync10(override))
+      throw new CliError(`LECODES_MATC points at "${override}" which doesn't exist.`);
+    return resolve(override);
+  }
+  const cached = installedMatcVersions()[0];
+  return cached ? findMatc(join12(cacheRoot(), `matc-${cached}`)) : null;
+};
+var resolveMatcExe = async () => {
+  const cached = resolveMatcExeCached();
+  if (cached)
+    return cached;
+  const { latest, versions } = await fetchMatcManifest();
+  const dir = join12(cacheRoot(), `matc-${latest}`);
+  await downloadMatc(latest, versions, dir);
+  const exe = findMatc(dir);
+  if (!exe)
+    throw new CliError(`matc cache at ${dir} is broken — delete the folder and retry.`);
+  return exe;
+};
+var updateMatc = async () => {
+  const { latest, versions } = await fetchMatcManifest();
+  const before = installedMatcVersions()[0];
+  const dir = join12(cacheRoot(), `matc-${latest}`);
+  if (existsSync10(dir) && findMatc(dir) !== null) {
+    note(`Already up to date: matc ${latest}.`);
+    return;
+  }
+  await downloadMatc(latest, versions, dir);
+  note(before ? `matc updated to ${latest} (was ${before}).` : `matc ${latest} installed.`);
+};
+
+// src/compile/shaders.ts
+init_manifest();
+init_util();
+var SHADERS_DIR = "shaders";
+var shadersCacheDir = (root) => join13(root, LECODES_DIR, SHADERS_DIR);
+var isShaderArtifactName = (name) => /^[0-9a-f]{16}_[a-z-]+\.filamat$/.test(name);
+var matcIdentity = (exe) => {
+  const stat = statSync2(exe);
+  return `${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+};
+var shaderHash = (text, matcId) => createHash4("sha256").update(matcId + "\x00" + text).digest("hex").slice(0, 16);
+var artifactFamily = (text) => {
+  const matcPlatforms = matcPlatformsFor(text);
+  return [...matcPlatforms, ...matcPlatforms.includes("webgl") ? [] : ["webgl"], "webgl-lite"];
+};
+var shaderIsCompiled = (root, text, matcId) => {
+  const hash = shaderHash(text, matcId);
+  return artifactFamily(text).every((p) => existsSync11(join13(shadersCacheDir(root), `${hash}_${p}.filamat`)));
+};
+var runMatc = (exe, args) => new Promise((resolve2) => {
+  execFile(exe, args, { windowsHide: true }, (error, _stdout, stderr) => {
+    const text = String(stderr ?? "") || (error ? error.message : "");
+    resolve2({ ok: !error, stderr: text });
+  });
+});
+var cleanMatcOutput = (err, tempName, realName) => {
+  const output = err.replaceAll("\r", "").replaceAll(tempName, realName);
+  const cut = output.indexOf(`
+
+`);
+  return (cut >= 0 ? output.slice(0, cut) : output).trim();
+};
+var NATIVE_PLATFORMS = ["opengl", "metal", "desktop"];
+var applyLocalShaders = async (entries, opts) => {
+  const shaderEntries = entries.filter((e) => e.type === "shader" && e.absPath && (opts.local || !e.shaders?.length));
+  if (shaderEntries.length === 0)
+    return { warnings: [], artifacts: [] };
+  let matcExe;
+  try {
+    matcExe = await resolveMatcExe();
+  } catch (e) {
+    const reason = e instanceof CliError ? e.message : String(e);
+    return { warnings: [`Local shader compile unavailable (${reason})
+  Shaders fall back to the server — push the project once for them to work.`], artifacts: [] };
+  }
+  const matcId = matcIdentity(matcExe);
+  const cacheDir = shadersCacheDir(opts.root);
+  mkdirSync6(cacheDir, { recursive: true });
+  const artifacts = [];
+  for (const entry of shaderEntries) {
+    const text = readFileSync10(entry.absPath, "utf8");
+    const hash = shaderHash(text, matcId);
+    const matcPlatforms = matcPlatformsFor(text);
+    const artifact = (platform) => `${hash}_${platform}.filamat`;
+    if (!artifactFamily(text).every((p) => existsSync11(join13(cacheDir, artifact(p))))) {
+      const tempName = `lecodes-matc-${randomBytes(6).toString("hex")}.mat`;
+      const tempFile = join13(tmpdir(), tempName);
+      try {
+        for (const platform of matcPlatforms) {
+          const build = PLATFORM_BUILD[platform];
+          writeFileSync7(tempFile, build.replaceExternal ? text.replace(externalSamplerReg, "type:sampler2d") : text);
+          const out = join13(cacheDir, artifact(platform));
+          const { ok, stderr } = await runMatc(matcExe, matcArgs(platform, out, tempFile));
+          if (!ok) {
+            rmSync2(out, { force: true });
+            throw new CliError(`${entry.path}: shader compile failed [${platform}]
+${cleanMatcOutput(stderr, tempName, basename3(entry.path))}`);
+          }
+        }
+      } finally {
+        rmSync2(tempFile, { force: true });
+      }
+      if (!matcPlatforms.includes("webgl")) {
+        copyFileSync(join13(cacheDir, artifact("opengl")), join13(cacheDir, artifact("webgl")));
+      }
+      writeFileSync7(join13(cacheDir, artifact("webgl-lite")), JSON.stringify(buildLiteMaterialArtifact(text)));
+    }
+    if (opts.local) {
+      entry.shaders = NATIVE_PLATFORMS.map((platform) => ({ platform, src: artifact(platform) }));
+      entry.shadersLocal = true;
+      for (const platform of NATIVE_PLATFORMS) {
+        artifacts.push({ name: artifact(platform), absPath: join13(cacheDir, artifact(platform)) });
+      }
+    } else {
+      const order = ["opengl", "metal", "desktop", "webgl", "webgl-lite"];
+      entry.shaders = order.map((platform) => ({ platform, src: `${opts.srcPrefix}/${artifact(platform)}` }));
+    }
+  }
+  return { warnings: [], artifacts };
+};
+
+// src/commands/compile.ts
 init_assetIcons();
 init_ignore();
 
@@ -216040,16 +216576,16 @@ init_manifest();
 init_ignore();
 init_util();
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname8, join as join12, resolve } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname8, join as join15, resolve as resolve2 } from "node:path";
 var FIRST_PARTY_PLUGINS = {
   camera: "letary/lecodes-plugins",
   "qr-scanner": "letary/lecodes-plugins",
   geolocation: "letary/lecodes-plugins",
   push: "letary/lecodes-plugins"
 };
-var readAppConfigAt = (root) => readJson(join12(root, "app.json"));
+var readAppConfigAt = (root) => readJson(join15(root, "app.json"));
 var DESKTOP_DEFAULT_WINDOW = { width: 1280, height: 720 };
 var desktopDefaultViewport = (root) => {
   const cfg = readAppConfigAt(root);
@@ -216061,15 +216597,15 @@ var desktopDefaultViewport = (root) => {
   };
 };
 var readJson = (path) => {
-  if (!existsSync10(path))
+  if (!existsSync13(path))
     return null;
   try {
-    return JSON.parse(readFileSync11(path, "utf8").replace(/^\uFEFF/, ""));
+    return JSON.parse(readFileSync12(path, "utf8").replace(/^\uFEFF/, ""));
   } catch {
     throw new CliError(`Invalid JSON in ${path}`);
   }
 };
-var writeJson = (path, value) => writeFileSync7(path, JSON.stringify(value, null, 2) + `
+var writeJson = (path, value) => writeFileSync9(path, JSON.stringify(value, null, 2) + `
 `);
 var projectRoot = () => {
   try {
@@ -216094,12 +216630,12 @@ ${tail}`);
   }
 };
 var ensureShellIgnored = (root, dir) => {
-  const ignorePath = join12(root, ".lecodesignore");
-  const ignore = existsSync10(ignorePath) ? readFileSync11(ignorePath, "utf8") : DEFAULT_IGNORE_FILE;
+  const ignorePath = join15(root, ".lecodesignore");
+  const ignore = existsSync13(ignorePath) ? readFileSync12(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";
-  writeFileSync7(ignorePath, ignore.replace(/\n*$/, `
+  writeFileSync9(ignorePath, ignore.replace(/\n*$/, `
 `) + `
 ` + comment + `${dir}/
 `);
@@ -216175,12 +216711,12 @@ var ensureRepo = (repo, wantTag, lock) => {
   const override = process.env.LECODES_PLUGINS_DIR;
   if (override) {
     note(`Using local plugin checkout ${override} (LECODES_PLUGINS_DIR)`);
-    return { dir: resolve(override), tag: "local", commit: "local" };
+    return { dir: resolve2(override), tag: "local", commit: "local" };
   }
-  const cache = join12(homedir3(), ".lecodes", "plugins", repo.replace("/", "__"));
+  const cache = join15(homedir4(), ".lecodes", "plugins", repo.replace("/", "__"));
   const url = `https://github.com/${repo}.git`;
-  if (!existsSync10(join12(cache, ".git"))) {
-    mkdirSync6(dirname8(cache), { recursive: true });
+  if (!existsSync13(join15(cache, ".git"))) {
+    mkdirSync8(dirname8(cache), { recursive: true });
     note(`Cloning ${url}…`);
     git(dirname8(cache), "clone", "--quiet", url, cache);
   }
@@ -216222,8 +216758,8 @@ var resolvePlugin = (id, spec, lock, platform) => {
     subdir = `plugins/${id}`;
   }
   const checkout = ensureRepo(repo, wantTag, lock?.repo === repo ? lock : undefined);
-  const dir = subdir ? join12(checkout.dir, subdir) : checkout.dir;
-  const manifest = readJson(join12(dir, "lecodes-plugin.json"));
+  const dir = subdir ? join15(checkout.dir, subdir) : checkout.dir;
+  const manifest = readJson(join15(dir, "lecodes-plugin.json"));
   if (!manifest)
     throw new CliError(`Plugin "${id}": no lecodes-plugin.json in ${dir}`);
   if (manifest.id !== id)
@@ -216265,7 +216801,7 @@ var compileImpl = async (args, shell) => {
   if (out && isNullSink(out)) {
     note(`Discarded output (${out})`);
   } else if (out) {
-    writeFileSync8(resolve2(out), js);
+    writeFileSync10(resolve3(out), js);
     note(`Wrote ${out} (${js.length} bytes)`);
   } else {
     process.stdout.write(js);
@@ -216322,12 +216858,18 @@ var buildBundle = async (args, shell, opts = {}) => {
     if (opts.localAssets && flagBool(args, "remote-assets")) {
       warnErr("This is a local project (no server) — assets always load from the working tree.");
     }
-    ({ entries, warnings } = collectLocalEntries(root, null, ""));
-    name = basename3(root);
+    ({ entries, warnings } = collectLocalEntries(root, null, "", { localShaders: localAssets && (opts.localShaders ?? !shell) }));
+    name = basename4(root);
     if (shell && shell.remotePatterns.length > 0) {
       warnErr("resources.remote needs a server-backed project (a streamed asset needs a server URL) — bundling everything.");
     }
   }
+  let stagedShaders = [];
+  if (localAssets && (opts.localShaders ?? !shell)) {
+    const local = await applyLocalShaders(entries, { root, local: true });
+    warnings.push(...local.warnings);
+    stagedShaders = local.artifacts;
+  }
   const fontsHeader = await applyProjectFonts(entries, manifest && !localAssets ? { mode: "cdn", root, publicUrl } : {
     mode: "vendor",
     root,
@@ -216364,6 +216906,9 @@ var buildBundle = async (args, shell, opts = {}) => {
     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 };
 };
 var previewLegacy = async (args) => {
@@ -217213,17 +217758,17 @@ buildNumber) — edit it there, then re-run \`lecodes app sync\`. Plugins are ma
 
 // src/commands/appAndroid.ts
 init_manifest();
-import { execFileSync as execFileSync2, spawn, spawnSync as spawnSync2 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { chmodSync, cpSync, existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync13, readdirSync as readdirSync4, renameSync, rmSync, statSync as statSync2, writeFileSync as writeFileSync10 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename4, dirname as dirname10, join as join14 } from "node:path";
+import { execFileSync as execFileSync2, spawn, spawnSync as spawnSync3 } from "node:child_process";
+import { createHash as createHash6 } from "node:crypto";
+import { chmodSync, cpSync, existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync5, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync12 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename5, dirname as dirname10, join as join17 } from "node:path";
 init_util();
 
 // src/commands/appIcon.ts
 init_util();
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname9, join as join13, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname9, join as join16, resolve as resolve4 } from "node:path";
 var MASTER_PX = 1024;
 var DENSITIES = [
   { qualifier: "mdpi", scale: 1 },
@@ -217234,8 +217779,8 @@ var DENSITIES = [
 ];
 var loadIconMaster = async (root, config) => {
   const rel = config.icon;
-  const path2 = resolve3(root, rel);
-  if (!existsSync12(path2))
+  const path2 = resolve4(root, rel);
+  if (!existsSync15(path2))
     throw new CliError(`app.json "icon": ${rel} not found`);
   const raw = (config.iconBackground ?? "#FFFFFF").trim();
   const expanded = /^#[0-9a-fA-F]{3}$/.test(raw) ? "#" + [...raw.slice(1)].map((ch) => ch + ch).join("") : raw;
@@ -217299,12 +217844,12 @@ var IOS_CONTENTS_JSON = `{
 `;
 var writeIosAppIcon = async (iosDir, master) => {
   const { Jimp: Jimp2 } = await Promise.resolve().then(() => (init_esm30(), exports_esm2));
-  const dir = join13(iosDir, "App", "Assets.xcassets", "AppIcon.appiconset");
-  mkdirSync7(dir, { recursive: true });
+  const dir = join16(iosDir, "App", "Assets.xcassets", "AppIcon.appiconset");
+  mkdirSync9(dir, { recursive: true });
   const flat = new Jimp2({ width: MASTER_PX, height: MASTER_PX, color: master.background });
   flat.composite(master.image, 0, 0);
-  writeFileSync9(join13(dir, "AppIcon.png"), await flat.getBuffer("image/png", { colorType: 2 }));
-  writeFileSync9(join13(dir, "Contents.json"), IOS_CONTENTS_JSON);
+  writeFileSync11(join16(dir, "AppIcon.png"), await flat.getBuffer("image/png", { colorType: 2 }));
+  writeFileSync11(join16(dir, "Contents.json"), IOS_CONTENTS_JSON);
   log(`${c.green("icon")}      AppIcon.png (${MASTER_PX}×${MASTER_PX}) → ios/App/Assets.xcassets/AppIcon.appiconset/`);
 };
 var ADAPTIVE_ICON_XML = `<?xml version="1.0" encoding="utf-8"?>
@@ -217323,11 +217868,11 @@ var iconColorXml = (hex) => `<?xml version="1.0" encoding="utf-8"?>
 `;
 var writeAndroidIcons = async (androidDir, master) => {
   const { Jimp: Jimp2 } = await Promise.resolve().then(() => (init_esm30(), exports_esm2));
-  const resDir = join13(androidDir, "app", "src", "main", "res");
+  const resDir = join16(androidDir, "app", "src", "main", "res");
   const writeRes = (rel, content) => {
-    const abs = join13(resDir, rel);
-    mkdirSync7(dirname9(abs), { recursive: true });
-    writeFileSync9(abs, content);
+    const abs = join16(resDir, rel);
+    mkdirSync9(dirname9(abs), { recursive: true });
+    writeFileSync11(abs, content);
   };
   const legacy = new Jimp2({ width: MASTER_PX, height: MASTER_PX, color: master.background });
   legacy.composite(master.image, 0, 0);
@@ -217349,17 +217894,17 @@ var writeAndroidIcons = async (androidDir, master) => {
   log(`${c.green("icon")}      adaptive + legacy launcher icons → android/app/src/main/res/mipmap-*/`);
 };
 var restampManifestIcon = (androidDir) => {
-  const path2 = join13(androidDir, "app", "src", "main", "AndroidManifest.xml");
-  if (!existsSync12(path2))
+  const path2 = join16(androidDir, "app", "src", "main", "AndroidManifest.xml");
+  if (!existsSync15(path2))
     return;
-  const content = readFileSync12(path2, "utf8");
+  const content = readFileSync13(path2, "utf8");
   if (content.includes(`android:icon="@mipmap/ic_launcher"`))
     return;
   if (!/android:icon="[^"]*"/.test(content)) {
     warn(`couldn't find android:icon in app/src/main/AndroidManifest.xml — set it to "@mipmap/ic_launcher" yourself.`);
     return;
   }
-  writeFileSync9(path2, content.replace(/android:icon="[^"]*"/, `android:icon="@mipmap/ic_launcher"`));
+  writeFileSync11(path2, content.replace(/android:icon="[^"]*"/, `android:icon="@mipmap/ic_launcher"`));
   log(`${c.green("updated")}   android/app/src/main/AndroidManifest.xml: android:icon → @mipmap/ic_launcher`);
 };
 
@@ -218269,42 +218814,42 @@ var ANDROID_SDK_URL_DEFAULT = `https://github.com/${ANDROID_SDK_REPO}/releases/d
 var sdkRepoUrl = () => process.env.LECODES_ANDROID_SDK_URL ?? ANDROID_SDK_URL_DEFAULT;
 var ANDROID_SDK_OPTS = { repo: ANDROID_SDK_REPO, minVersion: ANDROID_SDK_MIN_VERSION, configKey: "android.sdk" };
 var shellSdkVersionAndroid = (androidDir) => {
-  const path2 = join14(androidDir, "lecodes-runtime", "build.gradle.kts");
-  if (!existsSync13(path2))
+  const path2 = join17(androidDir, "lecodes-runtime", "build.gradle.kts");
+  if (!existsSync16(path2))
     return null;
-  const m = /io\.letary:lecodes-sdk(?:-(?:core|2d|3d))?:(\d+\.\d+\.\d+)@aar/.exec(readFileSync13(path2, "utf8"));
+  const m = /io\.letary:lecodes-sdk(?:-(?:core|2d|3d))?:(\d+\.\d+\.\d+)@aar/.exec(readFileSync14(path2, "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";
 var GRADLE_WRAPPER_JAR_SHA256 = "81a82aaea5abcc8ff68b3dfcb58b3c3c429378efd98e7433460610fecd7ae45f";
 var ensureGradleWrapperJar = async () => {
-  const cached = join14(homedir4(), ".lecodes", "gradle-wrapper", GRADLE_VERSION, "gradle-wrapper.jar");
-  if (existsSync13(cached))
-    return new Uint8Array(readFileSync13(cached));
+  const cached = join17(homedir5(), ".lecodes", "gradle-wrapper", GRADLE_VERSION, "gradle-wrapper.jar");
+  if (existsSync16(cached))
+    return new Uint8Array(readFileSync14(cached));
   try {
     const res = await fetch(GRADLE_WRAPPER_JAR_URL);
     if (!res.ok)
       throw new Error(`HTTP ${res.status}`);
     const bytes = new Uint8Array(await res.arrayBuffer());
-    const hash = createHash4("sha256").update(bytes).digest("hex");
+    const hash = createHash6("sha256").update(bytes).digest("hex");
     if (hash !== GRADLE_WRAPPER_JAR_SHA256)
       throw new Error(`sha256 mismatch (${hash})`);
-    mkdirSync8(dirname10(cached), { recursive: true });
-    writeFileSync10(cached, bytes);
+    mkdirSync10(dirname10(cached), { recursive: true });
+    writeFileSync12(cached, bytes);
     return bytes;
   } catch (e2) {
     warn(`Could not fetch gradle-wrapper.jar (${e2.message}) — run \`gradle wrapper --gradle-version ${GRADLE_VERSION}\` inside android/, or open the project in Android Studio (it offers to repair the wrapper).`);
     return null;
   }
 };
-var rmrf = (path2) => rmSync(path2, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+var rmrf = (path2) => rmSync3(path2, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
 var initAndroid = async (args) => {
   const root = projectRoot();
-  const androidDir = join14(root, "android");
-  if (existsSync13(androidDir)) {
+  const androidDir = join17(root, "android");
+  if (existsSync16(androidDir)) {
     throw new CliError("android/ already exists — run `lecodes app sync` to update it.");
   }
-  const existing = readJson(join14(root, "app.json")) ?? {};
+  const existing = readJson(join17(root, "app.json")) ?? {};
   const variant = flagStr(args, "variant") ?? existing.android?.variant ?? "auto";
   if (variant !== "auto" && !SDK_VARIANTS.includes(variant)) {
     throw new CliError(`--variant must be auto, ${SDK_VARIANTS.join(", ")} (got "${variant}")`);
@@ -218312,7 +218857,7 @@ var initAndroid = async (args) => {
   const sdkFlag = flagStr(args, "sdk") ?? existing.android?.sdk;
   const sdkVersion = await resolveSdkVersion(process.env.LECODES_ANDROID_SDK ?? sdkFlag ?? "latest", null, ANDROID_SDK_OPTS);
   const sdk = sdkFlag === "latest" ? "latest" : sdkVersion;
-  const name = flagStr(args, "name") ?? existing.name ?? basename4(root);
+  const name = flagStr(args, "name") ?? existing.name ?? basename5(root);
   const defaultAppId = `com.example.${slugify(name).replace(/-/g, "")}`;
   const config = {
     ...existing,
@@ -218327,7 +218872,7 @@ var initAndroid = async (args) => {
       ...existing.android?.signing ? { signing: existing.android.signing } : {}
     }
   };
-  writeJson(join14(root, "app.json"), config);
+  writeJson(join17(root, "app.json"), config);
   log(`${c.green("written")}   app.json`);
   ensureShellIgnored(root, "android");
   const identity = {
@@ -218338,9 +218883,9 @@ var initAndroid = async (args) => {
   };
   const pkgPath = identity.applicationId.replace(/\./g, "/");
   const write = (rel, content) => {
-    const abs = join14(androidDir, rel);
-    mkdirSync8(dirname10(abs), { recursive: true });
-    writeFileSync10(abs, content);
+    const abs = join17(androidDir, rel);
+    mkdirSync10(dirname10(abs), { recursive: true });
+    writeFileSync12(abs, content);
     log(`${c.green("created")}   android/${rel}`);
   };
   write("README.md", ANDROID_README);
@@ -218353,7 +218898,7 @@ var initAndroid = async (args) => {
   write("gradlew.bat", GRADLEW_BAT.replace(/\n/g, `\r
 `));
   if (process.platform !== "win32")
-    chmodSync(join14(androidDir, "gradlew"), 493);
+    chmodSync(join17(androidDir, "gradlew"), 493);
   const wrapperJar = await ensureGradleWrapperJar();
   if (wrapperJar)
     write("gradle/wrapper/gradle-wrapper.jar", wrapperJar);
@@ -218388,7 +218933,7 @@ var resolveGradlePlugin = (pluginId, entry) => {
   return { id: entry, version };
 };
 var syncAndroid = async (root, config, prior) => {
-  const androidDir = join14(root, "android");
+  const androidDir = join17(root, "android");
   const linkedSdk = shellSdkVersionAndroid(androidDir);
   const sdkPin = process.env.LECODES_ANDROID_SDK ?? config.android?.sdk ?? linkedSdk ?? "latest";
   const sdkVersion = await resolveSdkVersion(sdkPin, linkedSdk, ANDROID_SDK_OPTS);
@@ -218396,18 +218941,18 @@ var syncAndroid = async (root, config, prior) => {
   if (!Array.isArray(remotePatterns) || remotePatterns.some((p2) => typeof p2 !== "string")) {
     throw new CliError('app.json "resources.remote" must be an array of glob strings (e.g. ["videos/**"]).');
   }
-  const assetsDir = join14(androidDir, "app", "src", "main", "assets");
+  const assetsDir = join17(androidDir, "app", "src", "main", "assets");
   rmrf(assetsDir);
-  mkdirSync8(assetsDir, { recursive: true });
+  mkdirSync10(assetsDir, { recursive: true });
   let bundleJs;
   let resources;
   if (prior) {
-    writeFileSync10(join14(assetsDir, "app.js"), prior.bundleJs);
+    writeFileSync12(join17(assetsDir, "app.js"), prior.bundleJs);
     bundleJs = prior.bundleJs;
     resources = prior.resources;
   } else {
-    resources = await compileShell({ _: [], flags: { o: join14(assetsDir, "app.js") } }, { remotePatterns });
-    bundleJs = readFileSync13(join14(assetsDir, "app.js"), "utf8");
+    resources = await compileShell({ _: [], flags: { o: join17(assetsDir, "app.js") } }, { remotePatterns });
+    bundleJs = readFileSync14(join17(assetsDir, "app.js"), "utf8");
   }
   const requestedVariant = config.android?.variant ?? "auto";
   if (requestedVariant !== "auto" && !SDK_VARIANTS.includes(requestedVariant)) {
@@ -218426,14 +218971,14 @@ var syncAndroid = async (root, config, prior) => {
     core: "no 3D/2D engine use detected"
   };
   log(`${c.green("variant")}   ${variant} → ${sdkArtifact}${requestedVariant === "auto" ? c.dim(`  (auto: ${WHY[detected]})`) : c.dim("  (forced by android.variant)")}`);
-  const lockPath = join14(root, "plugins.lock.json");
+  const lockPath = join17(root, "plugins.lock.json");
   const oldLock = readJson(lockPath)?.plugins ?? {};
   const pluginSpecs = Object.entries(config.plugins ?? {});
   const runtimePlugins = [];
   const gradlePlugins = new Map;
   const aarWrapperPaths = [];
   const newLock = {};
-  const pluginsDir = join14(androidDir, "plugins");
+  const pluginsDir = join17(androidDir, "plugins");
   for (const [id, spec] of pluginSpecs) {
     const plugin = resolvePlugin(id, spec, oldLock[id], "android");
     const android = plugin.manifest.android;
@@ -218441,10 +218986,10 @@ var syncAndroid = async (root, config, prior) => {
     const register = android.register;
     if (!module || !register)
       throw new CliError(`Plugin "${id}": manifest android.module / android.register missing`);
-    const src = join14(plugin.dir, android.sources ?? "android");
-    if (!existsSync13(src))
+    const src = join17(plugin.dir, android.sources ?? "android");
+    if (!existsSync16(src))
       throw new CliError(`Plugin "${id}": sources dir ${src} missing`);
-    const dest = join14(pluginsDir, module);
+    const dest = join17(pluginsDir, module);
     rmrf(dest);
     cpSync(src, dest, { recursive: true });
     if (android.minSdk && VERSION_RE.test(android.minSdk) && cmpVersion(sdkVersion, android.minSdk) < 0) {
@@ -218455,26 +219000,26 @@ var syncAndroid = async (root, config, prior) => {
       gradlePlugins.set(resolved.id, resolved.version);
     }
     const namespace = register.split(".").slice(0, -1).join(".");
-    const libsDir = join14(dest, "libs");
-    const aarNames = existsSync13(libsDir) ? readdirSync4(libsDir).filter((f3) => f3.endsWith(".aar")) : [];
+    const libsDir = join17(dest, "libs");
+    const aarNames = existsSync16(libsDir) ? readdirSync5(libsDir).filter((f3) => f3.endsWith(".aar")) : [];
     for (const aar of aarNames) {
       const base = aar.replace(/\.aar$/, "");
-      const wrapDir = join14(libsDir, base);
-      mkdirSync8(wrapDir, { recursive: true });
-      renameSync(join14(libsDir, aar), join14(wrapDir, aar));
-      writeFileSync10(join14(wrapDir, "build.gradle.kts"), aarWrapperBuildGradle(aar));
+      const wrapDir = join17(libsDir, base);
+      mkdirSync10(wrapDir, { recursive: true });
+      renameSync2(join17(libsDir, aar), join17(wrapDir, aar));
+      writeFileSync12(join17(wrapDir, "build.gradle.kts"), aarWrapperBuildGradle(aar));
       aarWrapperPaths.push(`:plugins:${module}:libs:${base}`);
     }
-    const hasConsumerRules = existsSync13(join14(dest, "consumer-rules.pro"));
-    writeFileSync10(join14(dest, "build.gradle.kts"), pluginBuildGradleTemplate(id, module, namespace, sdkVersion, android.dependencies ?? [], aarNames, hasConsumerRules, sdkArtifact));
+    const hasConsumerRules = existsSync16(join17(dest, "consumer-rules.pro"));
+    writeFileSync12(join17(dest, "build.gradle.kts"), pluginBuildGradleTemplate(id, module, namespace, sdkVersion, android.dependencies ?? [], aarNames, hasConsumerRules, sdkArtifact));
     runtimePlugins.push({ id, module, register });
     newLock[id] = plugin.lock;
     log(`${c.green("plugin")}    ${id}@${plugin.lock.version} (${plugin.lock.tag} → plugins/${module})`);
   }
   const keep = new Set(runtimePlugins.map((p2) => p2.module));
-  for (const entry of existsSync13(pluginsDir) ? readdirSync4(pluginsDir) : []) {
-    if (!keep.has(entry) && statSync2(join14(pluginsDir, entry)).isDirectory()) {
-      rmrf(join14(pluginsDir, entry));
+  for (const entry of existsSync16(pluginsDir) ? readdirSync5(pluginsDir) : []) {
+    if (!keep.has(entry) && statSync3(join17(pluginsDir, entry)).isDirectory()) {
+      rmrf(join17(pluginsDir, entry));
       log(`${c.yellow("removed")}   android/plugins/${entry}  (plugin uninstalled)`);
     }
   }
@@ -218501,7 +219046,7 @@ var syncAndroid = async (root, config, prior) => {
     }
     if (candidates.length > 1)
       warn(`asset name collision: ${name} (${candidates.map((r2) => r2.path).join(", ")}) — embedding ${candidates[0].path}`);
-    cpSync(candidates[0].absPath, join14(assetsDir, name));
+    cpSync(candidates[0].absPath, join17(assetsDir, name));
     embedded++;
   }
   if (embedded > 0)
@@ -218516,15 +219061,15 @@ var syncAndroid = async (root, config, prior) => {
   if (shellUuid)
     log(`${c.green("identity")}  project ${shellUuid} baked into the shell (world identity)`);
   const modules = runtimePlugins.map((p2) => p2.module);
-  writeFileSync10(join14(androidDir, "README.md"), ANDROID_README);
-  writeFileSync10(join14(androidDir, "settings.gradle.kts"), settingsGradleTemplate(slugify(config.name ?? basename4(root)), modules, aarWrapperPaths, sdkRepoUrl()));
-  writeFileSync10(join14(androidDir, "build.gradle.kts"), rootBuildGradleTemplate([...gradlePlugins].map(([id, version]) => ({ id, version }))));
-  writeFileSync10(join14(androidDir, "gradle.properties"), GRADLE_PROPERTIES);
-  writeFileSync10(join14(androidDir, "lecodes-runtime", "build.gradle.kts"), runtimeBuildGradleTemplate(sdkVersion, modules, sdkArtifact));
-  const runtimeKt = join14(androidDir, "lecodes-runtime", "src", "main", "kotlin", "io", "letary", "lecodes", "runtime", "LeCodesRuntime.kt");
-  mkdirSync8(dirname10(runtimeKt), { recursive: true });
-  writeFileSync10(runtimeKt, runtimeKotlinTemplate(runtimePlugins, shellUuid));
-  if (pluginSpecs.length > 0 || existsSync13(lockPath))
+  writeFileSync12(join17(androidDir, "README.md"), ANDROID_README);
+  writeFileSync12(join17(androidDir, "settings.gradle.kts"), settingsGradleTemplate(slugify(config.name ?? basename5(root)), modules, aarWrapperPaths, sdkRepoUrl()));
+  writeFileSync12(join17(androidDir, "build.gradle.kts"), rootBuildGradleTemplate([...gradlePlugins].map(([id, version]) => ({ id, version }))));
+  writeFileSync12(join17(androidDir, "gradle.properties"), GRADLE_PROPERTIES);
+  writeFileSync12(join17(androidDir, "lecodes-runtime", "build.gradle.kts"), runtimeBuildGradleTemplate(sdkVersion, modules, sdkArtifact));
+  const runtimeKt = join17(androidDir, "lecodes-runtime", "src", "main", "kotlin", "io", "letary", "lecodes", "runtime", "LeCodesRuntime.kt");
+  mkdirSync10(dirname10(runtimeKt), { recursive: true });
+  writeFileSync12(runtimeKt, runtimeKotlinTemplate(runtimePlugins, shellUuid));
+  if (pluginSpecs.length > 0 || existsSync16(lockPath))
     writeJson(lockPath, { plugins: newLock });
   restampAppBuildGradle(androidDir, config, gradlePlugins);
   if (config.icon) {
@@ -218539,12 +219084,12 @@ var syncAndroid = async (root, config, prior) => {
   note("Build & run from Android Studio (`lecodes app open android`) — user files in android/app/ were not touched.");
 };
 var restampAppBuildGradle = (androidDir, config, gradlePlugins) => {
-  const path2 = join14(androidDir, "app", "build.gradle.kts");
-  if (!existsSync13(path2)) {
+  const path2 = join17(androidDir, "app", "build.gradle.kts");
+  if (!existsSync16(path2)) {
     warn("android/app/build.gradle.kts is missing — run `lecodes app init android` on a clean tree to regenerate the shell.");
     return;
   }
-  let content = readFileSync13(path2, "utf8");
+  let content = readFileSync14(path2, "utf8");
   const before = content;
   const versionName = config.version ?? "1.0.0";
   const versionCode = config.android?.versionCode ?? 1;
@@ -218560,7 +219105,7 @@ var restampAppBuildGradle = (androidDir, config, gradlePlugins) => {
   }
   const applied = new Set;
   for (const id of gradlePlugins.keys()) {
-    if (id === "com.google.gms.google-services" && !existsSync13(join14(androidDir, "app", "google-services.json"))) {
+    if (id === "com.google.gms.google-services" && !existsSync16(join17(androidDir, "app", "google-services.json"))) {
       warn(`push needs android/app/google-services.json (download it from the le.codes Firebase project — the app's package name must be registered there). The google-services Gradle plugin stays un-applied until the file exists, so FCM registration will fail.`);
       continue;
     }
@@ -218587,13 +219132,13 @@ var restampAppBuildGradle = (androidDir, config, gradlePlugins) => {
     log(`${c.green("updated")}   android/app/build.gradle.kts: + id("${id}")`);
   }
   if (content !== before)
-    writeFileSync10(path2, content);
+    writeFileSync12(path2, content);
 };
 var gradlew = (androidDir, tasks) => {
   if (process.platform !== "win32")
     return runTool(androidDir, "sh", ["gradlew", ...tasks]);
-  const line = `""${join14(androidDir, "gradlew.bat")}" ${tasks.join(" ")}"`;
-  const r2 = spawnSync2("cmd.exe", ["/d", "/s", "/c", line], {
+  const line = `""${join17(androidDir, "gradlew.bat")}" ${tasks.join(" ")}"`;
+  const r2 = spawnSync3("cmd.exe", ["/d", "/s", "/c", line], {
     cwd: androidDir,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -218612,19 +219157,19 @@ ${tail}`);
 };
 var buildAndroid = async (args) => {
   const root = projectRoot();
-  const config = readJson(join14(root, "app.json"));
-  const androidDir = join14(root, "android");
-  if (!config?.android || !existsSync13(androidDir)) {
+  const config = readJson(join17(root, "app.json"));
+  const androidDir = join17(root, "android");
+  if (!config?.android || !existsSync16(androidDir)) {
     throw new CliError("No Android shell here — run `lecodes app init android` first.");
   }
   if (!flagBool(args, "no-sync"))
     await syncAndroid(root, config, null);
-  if (!existsSync13(join14(androidDir, "local.properties"))) {
+  if (!existsSync16(join17(androidDir, "local.properties"))) {
     const sdkHome = process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT;
     if (!sdkHome) {
       throw new CliError("Android SDK not found — set ANDROID_HOME, or create android/local.properties with sdk.dir=…");
     }
-    writeFileSync10(join14(androidDir, "local.properties"), `sdk.dir=${sdkHome.replace(/\\/g, "\\\\")}
+    writeFileSync12(join17(androidDir, "local.properties"), `sdk.dir=${sdkHome.replace(/\\/g, "\\\\")}
 `);
     note("Wrote android/local.properties (sdk.dir from the environment).");
   }
@@ -218633,27 +219178,27 @@ var buildAndroid = async (args) => {
   note(`Building (${tasks.join(" ")})… the first run downloads Gradle + dependencies`);
   gradlew(androidDir, tasks);
   const outputs = [];
-  const apkDir = join14(androidDir, "app", "build", "outputs", "apk", configuration);
-  const aabDir = join14(androidDir, "app", "build", "outputs", "bundle", configuration);
+  const apkDir = join17(androidDir, "app", "build", "outputs", "apk", configuration);
+  const aabDir = join17(androidDir, "app", "build", "outputs", "bundle", configuration);
   for (const dir of [apkDir, aabDir]) {
-    if (!existsSync13(dir))
+    if (!existsSync16(dir))
       continue;
-    for (const f3 of readdirSync4(dir)) {
+    for (const f3 of readdirSync5(dir)) {
       if (f3.endsWith(".apk") || f3.endsWith(".aab"))
-        outputs.push(join14(dir, f3));
+        outputs.push(join17(dir, f3));
     }
   }
   for (const out of outputs)
     log(`${c.green("output")}    ${out}`);
-  if (outputs.some((o2) => basename4(o2).includes("unsigned"))) {
+  if (outputs.some((o2) => basename5(o2).includes("unsigned"))) {
     note("The APK is UNSIGNED — create android/keystore.properties (see android/README.md) and rebuild to ship it.");
   }
   success(configuration === "debug" ? "Debug build done — `adb install` the APK to test." : "Release build done — upload the .aab in the Play Console (the .apk side-loads for testing).");
 };
 var openAndroid = async () => {
   const root = projectRoot();
-  const androidDir = join14(root, "android");
-  if (!existsSync13(join14(androidDir, "settings.gradle.kts"))) {
+  const androidDir = join17(root, "android");
+  if (!existsSync16(join17(androidDir, "settings.gradle.kts"))) {
     throw new CliError("No Android shell here — run `lecodes app init android` first.");
   }
   if (process.platform === "darwin") {
@@ -218664,11 +219209,11 @@ var openAndroid = async () => {
     } catch {}
   } else if (process.platform === "win32") {
     const candidates = [
-      join14(process.env.LOCALAPPDATA ?? "", "Programs", "Android Studio", "bin", "studio64.exe"),
+      join17(process.env.LOCALAPPDATA ?? "", "Programs", "Android Studio", "bin", "studio64.exe"),
       "C:\\Program Files\\Android\\Android Studio\\bin\\studio64.exe"
     ];
     for (const exe of candidates) {
-      if (!existsSync13(exe))
+      if (!existsSync16(exe))
         continue;
       spawn(exe, [androidDir], { detached: true, stdio: "ignore" }).unref();
       success("Opened android/ in Android Studio.");
@@ -218684,19 +219229,19 @@ var openAndroid = async () => {
   note("Open the android/ folder in Android Studio.");
 };
 var doctorAndroidChecks = async (root, config, check) => {
-  const androidDir = join14(root, "android");
-  const java = spawnSync2("java", ["-version"], { encoding: "utf8" });
+  const androidDir = join17(root, "android");
+  const java = spawnSync3("java", ["-version"], { encoding: "utf8" });
   const javaOut = `${java.stderr ?? ""}${java.stdout ?? ""}`;
   const javaMajor = Number(/version "(\d+)/.exec(javaOut)?.[1] ?? 0);
   check(javaMajor >= 17, `JDK ${javaMajor || "not found"}`, "install JDK 17+ (Android Studio ships one)");
-  const hasSdkHome = !!(process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT) || existsSync13(join14(androidDir, "local.properties"));
+  const hasSdkHome = !!(process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT) || existsSync16(join17(androidDir, "local.properties"));
   check(hasSdkHome, "Android SDK location", "set ANDROID_HOME or create android/local.properties");
   const requestedVariant = config.android?.variant ?? "auto";
   const validVariant = requestedVariant === "auto" || SDK_VARIANTS.includes(requestedVariant);
   check(validVariant, `android.variant "${requestedVariant}"`, `use "auto" or one of ${SDK_VARIANTS.join(", ")}`);
-  const wrapperJar = join14(androidDir, "gradle", "wrapper", "gradle-wrapper.jar");
-  check(existsSync13(wrapperJar) && statSync2(wrapperJar).size > 0, "Gradle wrapper jar", `run \`gradle wrapper --gradle-version ${GRADLE_VERSION}\` in android/ (or let Android Studio repair it)`);
-  check(existsSync13(join14(androidDir, "app", "src", "main", "assets", "app.js")), "Bundled app.js", "run `lecodes app sync`");
+  const wrapperJar = join17(androidDir, "gradle", "wrapper", "gradle-wrapper.jar");
+  check(existsSync16(wrapperJar) && statSync3(wrapperJar).size > 0, "Gradle wrapper jar", `run \`gradle wrapper --gradle-version ${GRADLE_VERSION}\` in android/ (or let Android Studio repair it)`);
+  check(existsSync16(join17(androidDir, "app", "src", "main", "assets", "app.js")), "Bundled app.js", "run `lecodes app sync`");
   const linked = shellSdkVersionAndroid(androidDir);
   const pin = config.android?.sdk ?? "latest";
   check(!!linked, `SDK ${linked ?? "version unreadable"}`, "run `lecodes app sync`");
@@ -218709,25 +219254,24 @@ var doctorAndroidChecks = async (root, config, check) => {
       check(cmpVersion(linked, latest) >= 0, `SDK is the latest release (${latest})`, "run `lecodes app update`", false);
     } catch {}
   }
-  const hasKeystore = existsSync13(join14(androidDir, "keystore.properties")) || !!process.env.LECODES_ANDROID_KEYSTORE_FILE;
+  const hasKeystore = existsSync16(join17(androidDir, "keystore.properties")) || !!process.env.LECODES_ANDROID_KEYSTORE_FILE;
   check(hasKeystore, "Release signing configured", "android/keystore.properties or LECODES_ANDROID_* env (release builds come out unsigned without it)", false);
   if (Object.keys(config.plugins ?? {}).includes("push")) {
-    check(existsSync13(join14(androidDir, "app", "google-services.json")), "google-services.json present (push)", "download it from the le.codes Firebase project — FCM registration fails without it", false);
+    check(existsSync16(join17(androidDir, "app", "google-services.json")), "google-services.json present (push)", "download it from the le.codes Firebase project — FCM registration fails without it", false);
   }
 };
 
 // src/commands/appDesktop.ts
 import { execFileSync as execFileSync3, spawn as spawn3 } from "node:child_process";
-import { cpSync as cpSync2, existsSync as existsSync15, mkdirSync as mkdirSync10, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
-import { basename as basename5, dirname as dirname11, join as join16, resolve as resolve5 } from "node:path";
+import { cpSync as cpSync2, existsSync as existsSync18, mkdirSync as mkdirSync12, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync5, writeFileSync as writeFileSync14 } from "node:fs";
+import { basename as basename6, dirname as dirname11, join as join19, resolve as resolve6 } from "node:path";
 
 // src/desktopRenderer.ts
+import { spawn as spawn2 } from "node:child_process";
+import { copyFileSync as copyFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync2, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir6, tmpdir as tmpdir2 } from "node:os";
+import { join as join18, resolve as resolve5 } from "node:path";
 init_util();
-import { createHash as createHash5 } from "node:crypto";
-import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync9, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync14, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir5, tmpdir } from "node:os";
-import { join as join15, resolve as resolve4 } from "node:path";
 
 // ../viewer-lite/src/sourcemapError.ts
 var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -218828,16 +219372,8 @@ var makeStackDemangler = (bundleJs) => {
 };
 
 // src/desktopRenderer.ts
-var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json";
 var DESKTOP_RENDERER_VERSION = "1.1.0";
-var semverNewer = (a2, b) => {
-  const pa = a2.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
-  for (let i2 = 0;i2 < 3; i2++)
-    if ((pb[i2] ?? 0) !== (pa[i2] ?? 0))
-      return (pb[i2] ?? 0) - (pa[i2] ?? 0);
-  return 0;
-};
-var platformKey = () => {
+var platformKey2 = () => {
   if (process.platform === "win32")
     return "windows-x64";
   if (process.platform === "linux")
@@ -218847,8 +219383,8 @@ var platformKey = () => {
 var exeName = () => process.platform === "win32" ? "lecodes-desktop.exe" : "lecodes-desktop";
 var findExe = (dir) => {
   const name = exeName();
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const p2 = join15(dir, entry.name);
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const p2 = join18(dir, entry.name);
     if (entry.isFile() && entry.name === name)
       return p2;
     if (entry.isDirectory()) {
@@ -218859,40 +219395,26 @@ var findExe = (dir) => {
   }
   return null;
 };
-var cacheRoot = () => join15(homedir5(), ".lecodes", "renderer");
-var currentFile = () => join15(cacheRoot(), "current.json");
+var cacheRoot2 = () => join18(homedir6(), ".lecodes", "renderer");
+var currentFile = () => join18(cacheRoot2(), "current.json");
 var installedDesktopVersions = () => {
   try {
-    return readdirSync5(cacheRoot(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("desktop-")).map((e2) => e2.name.slice("desktop-".length)).filter((v) => findExe(join15(cacheRoot(), `desktop-${v}`)) !== null).sort(semverNewer);
+    return readdirSync6(cacheRoot2(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("desktop-")).map((e2) => e2.name.slice("desktop-".length)).filter((v) => findExe(join18(cacheRoot2(), `desktop-${v}`)) !== null).sort(semverNewer);
   } catch {
     return [];
   }
 };
 var selectedDesktopVersion = () => {
   try {
-    const saved = JSON.parse(readFileSync14(currentFile(), "utf8")).version;
+    const saved = JSON.parse(readFileSync15(currentFile(), "utf8")).version;
     if (saved && /^\d+\.\d+\.\d+/.test(saved) && semverNewer(DESKTOP_RENDERER_VERSION, saved) > 0)
       return saved;
   } catch {}
   return DESKTOP_RENDERER_VERSION;
 };
-var fetchDesktopManifest = async () => {
-  let manifest;
-  try {
-    const res = await fetch(MANIFEST_URL);
-    if (!res.ok)
-      throw new Error(`HTTP ${res.status}`);
-    manifest = await res.json();
-  } catch (e2) {
-    throw new CliError(`Can't fetch the release manifest (${MANIFEST_URL}): ${e2 instanceof Error ? e2.message : String(e2)}`);
-  }
-  const desktop = manifest.products?.desktop;
-  if (!desktop)
-    throw new CliError("The release manifest has no desktop product.");
-  return desktop;
-};
+var fetchDesktopManifest = () => fetchReleaseProduct("desktop", "desktop");
 var downloadDesktop = async (version, dest) => {
-  const key = platformKey();
+  const key = platformKey2();
   const entry = (await fetchDesktopManifest()).versions.find((v) => v.version === version);
   const file = entry?.files[key];
   if (!file) {
@@ -218900,49 +219422,22 @@ var downloadDesktop = async (version, dest) => {
 Set LECODES_DESKTOP_EXE to a locally built host, or update lecodes-cli.`);
   }
   note(`Downloading the native renderer (LeCodes Desktop ${version}, ${(file.size / 1024 / 1024).toFixed(1)} MB)…`);
-  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 (e2) {
-    throw new CliError(`Download failed (${file.url}): ${e2 instanceof Error ? e2.message : String(e2)}`);
-  }
-  const sha = createHash5("sha256").update(bytes).digest("hex");
-  if (sha !== file.sha256)
-    throw new CliError(`Downloaded archive is corrupt (sha256 mismatch) — try again.`);
-  mkdirSync9(cacheRoot(), { recursive: true });
-  const stage = mkdtempSync(join15(cacheRoot(), "dl-"));
-  try {
-    const archive = join15(stage, file.url.split("/").pop() ?? "archive");
-    writeFileSync11(archive, bytes);
-    const tar = spawnSync3("tar", ["-xf", archive, "-C", stage], { stdio: ["ignore", "ignore", "pipe"] });
-    if (tar.status !== 0)
-      throw new CliError(`Couldn't extract the renderer archive: ${tar.stderr?.toString() ?? "tar failed"}`);
-    rmSync2(archive);
-    if (!findExe(stage))
-      throw new CliError("The downloaded archive doesn't contain the desktop host binary.");
-    try {
-      renameSync2(stage, dest);
-    } catch {
-      if (!findExe(dest))
-        throw new CliError(`Couldn't move the renderer into ${dest}.`);
-    }
-  } finally {
-    rmSync2(stage, { recursive: true, force: true });
-  }
+  await downloadReleaseArchive(file, {
+    cacheRoot: cacheRoot2(),
+    dest,
+    validate: (dir) => findExe(dir) ? null : "The downloaded archive doesn't contain the desktop host binary."
+  });
 };
 var resolveDesktopExe = async () => {
   const override = process.env.LECODES_DESKTOP_EXE;
   if (override) {
-    if (!existsSync14(override))
+    if (!existsSync17(override))
       throw new CliError(`LECODES_DESKTOP_EXE points at "${override}" which doesn't exist.`);
-    return resolve4(override);
+    return resolve5(override);
   }
   const version = selectedDesktopVersion();
-  const dir = join15(cacheRoot(), `desktop-${version}`);
-  let exe = existsSync14(dir) ? findExe(dir) : null;
+  const dir = join18(cacheRoot2(), `desktop-${version}`);
+  let exe = existsSync17(dir) ? findExe(dir) : null;
   if (!exe) {
     await downloadDesktop(version, dir);
     exe = findExe(dir);
@@ -218957,12 +219452,12 @@ var updateDesktop = async () => {
     throw new CliError(`The newest published LeCodes Desktop is ${latest}, but this CLI needs ≥ ${DESKTOP_RENDERER_VERSION} ` + `for the render contract. Publish the desktop release first.`);
   }
   const before = selectedDesktopVersion();
-  const dir = join15(cacheRoot(), `desktop-${latest}`);
-  const hadIt = existsSync14(dir) && findExe(dir) !== null;
+  const dir = join18(cacheRoot2(), `desktop-${latest}`);
+  const hadIt = existsSync17(dir) && findExe(dir) !== null;
   if (!hadIt)
     await downloadDesktop(latest, dir);
-  mkdirSync9(cacheRoot(), { recursive: true });
-  writeFileSync11(currentFile(), JSON.stringify({ version: latest }, null, 2));
+  mkdirSync11(cacheRoot2(), { recursive: true });
+  writeFileSync13(currentFile(), JSON.stringify({ version: latest }, null, 2));
   if (latest === before && hadIt)
     note(`Already up to date: LeCodes Desktop ${latest}.`);
   else if (latest === before)
@@ -218988,14 +219483,19 @@ var windowEnv = (opts) => {
     env.CREATOR_UI_SCALE = "fit";
   else if (typeof opts.scale === "number")
     env.CREATOR_UI_SCALE = String(opts.scale);
+  if (typeof opts.renderScale === "number")
+    env.CREATOR_RENDER_SCALE = String(opts.renderScale);
+  if (opts.maxRenderSize && opts.maxRenderSize[0] > 0 && opts.maxRenderSize[1] > 0) {
+    env.CREATOR_RENDER_MAX = `${Math.round(opts.maxRenderSize[0])}x${Math.round(opts.maxRenderSize[1])}`;
+  }
   return env;
 };
 var stageBundle = (js, resources) => {
-  const runDir = mkdtempSync(join15(tmpdir(), "lecodes-render-"));
-  writeFileSync11(join15(runDir, "app.js"), js);
+  const runDir = mkdtempSync2(join18(tmpdir2(), "lecodes-render-"));
+  writeFileSync13(join18(runDir, "app.js"), js);
   for (const r2 of resources) {
-    if (r2.absPath && existsSync14(r2.absPath) && statSync3(r2.absPath).isFile()) {
-      copyFileSync(r2.absPath, join15(runDir, r2.name));
+    if (r2.absPath && existsSync17(r2.absPath) && statSync4(r2.absPath).isFile()) {
+      copyFileSync2(r2.absPath, join18(runDir, r2.name));
     }
   }
   return runDir;
@@ -219023,7 +219523,7 @@ var runDesktopApp = async (js, resources, opts = {}) => {
     const env = { ...process.env, ...windowEnv(opts) };
     const demangle = makeStackDemangler(js);
     await new Promise((done, fail) => {
-      const child = demangle ? spawn2(exe, [join15(runDir, "app.js")], { cwd: runDir, env, stdio: ["ignore", "pipe", "pipe"] }) : spawn2(exe, [join15(runDir, "app.js")], { cwd: runDir, env, stdio: ["ignore", "inherit", "inherit"] });
+      const child = demangle ? spawn2(exe, [join18(runDir, "app.js")], { cwd: runDir, env, stdio: ["ignore", "pipe", "pipe"] }) : spawn2(exe, [join18(runDir, "app.js")], { cwd: runDir, env, stdio: ["ignore", "inherit", "inherit"] });
       if (demangle) {
         pipeThroughDemangler(child.stdout, process.stdout, demangle);
         pipeThroughDemangler(child.stderr, process.stderr, demangle);
@@ -219037,7 +219537,7 @@ var runDesktopApp = async (js, resources, opts = {}) => {
       });
     });
   } finally {
-    rmSync2(runDir, { recursive: true, force: true });
+    rmSync4(runDir, { recursive: true, force: true });
   }
 };
 var runDesktopDev = async (url, opts = {}) => {
@@ -219053,8 +219553,8 @@ var runDesktopRender = async (js, resources, opts) => {
   const exe = await resolveDesktopExe();
   const runDir = stageBundle(js, resources);
   try {
-    const appJs = join15(runDir, "app.js");
-    const outAbs = resolve4(opts.outPng);
+    const appJs = join18(runDir, "app.js");
+    const outAbs = resolve5(opts.outPng);
     const env = {
       ...process.env,
       CREATOR_DUMP_PNG: outAbs,
@@ -219063,8 +219563,8 @@ var runDesktopRender = async (js, resources, opts) => {
       CREATOR_HIDDEN: "1"
     };
     if (opts.script !== undefined) {
-      const scriptPath = join15(runDir, "script.txt");
-      writeFileSync11(scriptPath, opts.script);
+      const scriptPath = join18(runDir, "script.txt");
+      writeFileSync13(scriptPath, opts.script);
       env.CREATOR_SCRIPT = scriptPath;
     }
     if (opts.fixedDtMs)
@@ -219096,7 +219596,7 @@ var runDesktopRender = async (js, resources, opts) => {
       child.on("exit", (code) => {
         clearTimeout(killer);
         const output = demangle(chunks.join(""));
-        if (code === 0 && existsSync14(outAbs))
+        if (code === 0 && existsSync17(outAbs))
           return done({ output, exitCode: code });
         const tail = demangle(chunks.slice(-80).join("")).trimEnd();
         const detail = tail.length > 0 ? `
@@ -219105,21 +219605,21 @@ ${tail}` : "";
       });
     });
   } finally {
-    rmSync2(runDir, { recursive: true, force: true });
+    rmSync4(runDir, { recursive: true, force: true });
   }
 };
 
 // src/commands/appDesktop.ts
 init_util();
 var mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-var dirSize = (dir) => readdirSync6(dir, { withFileTypes: true }).reduce((sum, e2) => {
-  const p2 = join16(dir, e2.name);
-  return sum + (e2.isDirectory() ? dirSize(p2) : statSync4(p2).size);
+var dirSize = (dir) => readdirSync7(dir, { withFileTypes: true }).reduce((sum, e2) => {
+  const p2 = join19(dir, e2.name);
+  return sum + (e2.isDirectory() ? dirSize(p2) : statSync5(p2).size);
 }, 0);
 var initDesktop = async (args) => {
   const root = projectRoot();
-  const existing = readJson(join16(root, "app.json")) ?? {};
-  const name = flagStr(args, "name") ?? existing.name ?? basename5(root);
+  const existing = readJson(join19(root, "app.json")) ?? {};
+  const name = flagStr(args, "name") ?? existing.name ?? basename6(root);
   const window2 = {
     width: 1280,
     height: 800,
@@ -219129,19 +219629,19 @@ var initDesktop = async (args) => {
     ...flagBool(args, "fullscreen") ? { fullscreen: true } : {}
   };
   const config = { ...existing, name, desktop: { ...existing.desktop, window: window2 } };
-  writeJson(join16(root, "app.json"), config);
+  writeJson(join19(root, "app.json"), config);
   log(`${c.green("written")}   app.json  (desktop.window ${window2.width}×${window2.height}${window2.fullscreen ? ", fullscreen" : ""})`);
   log(`Next: ${c.bold("lecodes dev --desktop")} to develop, ${c.bold("lecodes app build desktop")} to package.`);
 };
 var cleanFileName = (name) => name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "").replace(/[. ]+$/, "").trim() || "app";
 var buildDesktop = async (args) => {
   const root = projectRoot();
-  const config = readJson(join16(root, "app.json")) ?? {};
-  const name = (config.name ?? basename5(root)).trim() || "app";
+  const config = readJson(join19(root, "app.json")) ?? {};
+  const name = (config.name ?? basename6(root)).trim() || "app";
   const slug = flagStr(args, "slug") ?? cleanFileName(name);
-  const out = resolve5(root, flagStr(args, "o", "out") ?? join16(root, "dist", slug));
-  if (existsSync15(out)) {
-    const entries = readdirSync6(out);
+  const out = resolve6(root, flagStr(args, "o", "out") ?? join19(root, "dist", slug));
+  if (existsSync18(out)) {
+    const entries = readdirSync7(out);
     const looksLikeBuild = entries.length === 0 || entries.includes("app.js");
     if (!looksLikeBuild) {
       throw new CliError(`${out} exists and doesn't look like a previous desktop build — pick another -o or clear it yourself.`);
@@ -219150,12 +219650,12 @@ var buildDesktop = async (args) => {
   if (config.desktop?.entry && flagStr(args, "entry") === undefined)
     args.flags.entry = config.desktop.entry;
   note(`Building "${name}" for desktop…`);
-  const { js, resources } = await buildBundle(args, { remotePatterns: config.resources?.remote ?? [] });
+  const { js, resources } = await buildBundle(args, { remotePatterns: config.resources?.remote ?? [] }, { localShaders: true });
   const wanted = new Set([...js.matchAll(/fetchLocal\("([^"]+)"\)/g)].map((m) => m[1]));
-  const shipped = resources.filter((r2) => !r2.remote && wanted.has(r2.name));
+  const shipped = resources.filter((r2) => !r2.remote && (r2.shader || wanted.has(r2.name)));
   const byName = new Map;
   for (const r2 of resources) {
-    if (r2.remote || !wanted.has(r2.name))
+    if (r2.remote || r2.shader || !wanted.has(r2.name))
       continue;
     const set = byName.get(r2.name) ?? new Set;
     set.add(r2.path);
@@ -219169,45 +219669,51 @@ var buildDesktop = async (args) => {
 `)).join(`
 `));
   }
+  const exe = await resolveDesktopExe();
+  const hostDir = dirname11(exe);
+  const IMPLICIT_PRELOADS = new Set(["uberarchive", "capture"]);
+  const hostProvided = new Set;
+  try {
+    for (const f3 of readdirSync7(join19(hostDir, "assets")))
+      hostProvided.add(f3);
+  } catch {}
   const shippedNames = new Set(shipped.map((r2) => r2.name));
-  const missing = [...wanted].filter((n2) => !shippedNames.has(n2));
+  const missing = [...wanted].filter((n2) => !shippedNames.has(n2) && !hostProvided.has(n2) && !IMPLICIT_PRELOADS.has(n2));
   if (missing.length > 0) {
     throw new CliError(`The bundle references assets with no local file: ${missing.join(", ")}`);
   }
-  const exe = await resolveDesktopExe();
-  const hostDir = dirname11(exe);
   const version = process.env.LECODES_DESKTOP_EXE ? "local build" : selectedDesktopVersion();
-  rmSync3(out, { recursive: true, force: true });
-  mkdirSync10(out, { recursive: true });
-  for (const entry of readdirSync6(hostDir, { withFileTypes: true })) {
+  rmSync5(out, { recursive: true, force: true });
+  mkdirSync12(out, { recursive: true });
+  for (const entry of readdirSync7(hostDir, { withFileTypes: true })) {
     const keep = entry.isFile() && entry.name.toLowerCase().endsWith(".dll") || entry.isDirectory() && (entry.name === "assets" || entry.name === "fonts");
     if (keep)
-      cpSync2(join16(hostDir, entry.name), join16(out, entry.name), { recursive: true });
+      cpSync2(join19(hostDir, entry.name), join19(out, entry.name), { recursive: true });
   }
-  if (!existsSync15(join16(out, "assets", "initial.js"))) {
+  if (!existsSync18(join19(out, "assets", "initial.js"))) {
     throw new CliError(`The host at ${hostDir} has no assets/initial.js next to it — a staged build can't boot. ` + `(LECODES_DESKTOP_EXE must point at an exe with its runtime assets/ beside it.)`);
   }
   const exeName2 = process.platform === "win32" ? `${cleanFileName(name)}.exe` : cleanFileName(name);
-  cpSync2(exe, join16(out, exeName2));
+  cpSync2(exe, join19(out, exeName2));
   note(`  host: LeCodes Desktop ${version}`);
-  writeFileSync12(join16(out, "app.js"), js);
+  writeFileSync14(join19(out, "app.js"), js);
   let assetBytes = 0, assetCount = 0;
   for (const r2 of shipped) {
-    if (!r2.absPath || !existsSync15(r2.absPath) || !statSync4(r2.absPath).isFile()) {
+    if (!r2.absPath || !existsSync18(r2.absPath) || !statSync5(r2.absPath).isFile()) {
       warn(`asset "${r2.name}" (${r2.path}) has no local file — skipped`);
       continue;
     }
-    cpSync2(r2.absPath, join16(out, r2.name));
-    assetBytes += statSync4(r2.absPath).size;
+    cpSync2(r2.absPath, join19(out, r2.name));
+    assetBytes += statSync5(r2.absPath).size;
     assetCount++;
   }
   note(`  assets: ${assetCount} files, ${mb(assetBytes)}`);
-  writeJson(join16(out, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
+  writeJson(join19(out, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
   if (config.icon) {
-    await writeIco(root, config, join16(out, "app.ico"));
+    await writeIco(root, config, join19(out, "app.ico"));
     note("  app.ico rendered from " + config.icon);
   }
-  writeFileSync12(join16(out, "README.txt"), "\uFEFF" + readmeText(name, exeName2, version));
+  writeFileSync14(join19(out, "README.txt"), "\uFEFF" + readmeText(name, exeName2, version));
   success(`Portable build: ${out}  (${mb(dirSize(out))})`);
   if (flagBool(args, "probe"))
     await probeBuild(out, exeName2, config, args);
@@ -219240,15 +219746,15 @@ var writeIco = async (root, config, dest) => {
     header.writeUInt32LE(offset, e2 + 12);
     offset += pngs[i2].length;
   });
-  writeFileSync12(dest, Buffer.concat([header, ...pngs]));
+  writeFileSync14(dest, Buffer.concat([header, ...pngs]));
 };
 var probeBuild = async (out, exeName2, config, args) => {
   const win = config.desktop?.window;
   const frames = Number(flagStr(args, "frames")) || 90;
-  const shot = join16(dirname11(out), `${basename5(out)}-probe.png`);
+  const shot = join19(dirname11(out), `${basename6(out)}-probe.png`);
   note(`Probe: hidden render of the staged folder (${frames} frames)…`);
   await new Promise((done, fail) => {
-    const child = spawn3(join16(out, exeName2), [], {
+    const child = spawn3(join19(out, exeName2), [], {
       cwd: out,
       env: {
         ...process.env,
@@ -219277,7 +219783,7 @@ var probeBuild = async (out, exeName2, config, args) => {
     });
     child.on("exit", (code) => {
       clearTimeout(killer);
-      if (code === 0 && existsSync15(shot)) {
+      if (code === 0 && existsSync18(shot)) {
         success(`Probe: ${shot}`);
         done();
       } else {
@@ -219290,7 +219796,7 @@ ${tail.join("").trimEnd()}` : "";
 };
 var zipBuild = (out) => {
   const zip = `${out}.zip`;
-  rmSync3(zip, { force: true });
+  rmSync5(zip, { force: true });
   note("Zipping…");
   if (process.platform === "win32") {
     const q = (s2) => s2.replaceAll("'", "''");
@@ -219304,9 +219810,9 @@ var zipBuild = (out) => {
       "$zip.Dispose()"
     ].join(" ")], { stdio: ["ignore", "ignore", "pipe"] });
   } else {
-    execFileSync3("zip", ["-rq", zip, basename5(out)], { cwd: dirname11(out) });
+    execFileSync3("zip", ["-rq", zip, basename6(out)], { cwd: dirname11(out) });
   }
-  success(`Zip: ${zip} (${mb(statSync4(zip).size)})`);
+  success(`Zip: ${zip} (${mb(statSync5(zip).size)})`);
 };
 var readmeText = (name, exeName2, version) => `${name}
 ${"=".repeat(Math.max(name.length, 4))}
@@ -219327,10 +219833,10 @@ var SDK_REPO = "letary/lecodes-ios-sdk";
 var SDK_MIN_VERSION = "1.2.0";
 var SDK_IDENTITY_VERSION = "1.6.0";
 var shellSdkVersion = (iosDir) => {
-  const path2 = join17(iosDir, "LeCodesRuntime", "Package.swift");
-  if (!existsSync16(path2))
+  const path2 = join20(iosDir, "LeCodesRuntime", "Package.swift");
+  if (!existsSync19(path2))
     return null;
-  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync15(path2, "utf8"));
+  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync16(path2, "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" };
@@ -219344,11 +219850,11 @@ var appInit = async (args) => {
     throw new CliError(platform ? `Unsupported platform "${platform}" — use ios, android or desktop.` : "Usage: lecodes app init <ios|android|desktop> [--name <display name>] [--bundle-id <id>] [--team <team id>] [--variant auto|core|2d|3d|full] [--app-id <application id>] [--sdk <version|latest>]");
   }
   const root = projectRoot();
-  const iosDir = join17(root, "ios");
-  if (existsSync16(iosDir)) {
+  const iosDir = join20(root, "ios");
+  if (existsSync19(iosDir)) {
     throw new CliError("ios/ already exists — run `lecodes app sync` to update it.");
   }
-  const existing = readJson(join17(root, "app.json")) ?? {};
+  const existing = readJson(join20(root, "app.json")) ?? {};
   const variant = flagStr(args, "variant") ?? existing.ios?.variant ?? "auto";
   if (variant !== "auto" && !SDK_VARIANTS.includes(variant)) {
     throw new CliError(`--variant must be auto, ${SDK_VARIANTS.join(", ")} (got "${variant}")`);
@@ -219356,7 +219862,7 @@ var appInit = async (args) => {
   const sdkFlag = flagStr(args, "sdk") ?? existing.ios?.sdk;
   const sdkVersion = await resolveSdkVersion(process.env.LECODES_IOS_SDK ?? sdkFlag ?? "latest", null, IOS_SDK_OPTS);
   const sdk = sdkFlag === "latest" ? "latest" : sdkVersion;
-  const name = flagStr(args, "name") ?? existing.name ?? basename6(root);
+  const name = flagStr(args, "name") ?? existing.name ?? basename7(root);
   const config = {
     ...existing,
     name,
@@ -219370,7 +219876,7 @@ var appInit = async (args) => {
       buildNumber: existing.ios?.buildNumber ?? 1
     }
   };
-  writeJson(join17(root, "app.json"), config);
+  writeJson(join20(root, "app.json"), config);
   log(`${c.green("written")}   app.json`);
   ensureShellIgnored(root, "ios");
   const identity = {
@@ -219381,9 +219887,9 @@ var appInit = async (args) => {
     buildNumber: config.ios.buildNumber
   };
   const write = (rel, content) => {
-    const abs = join17(iosDir, rel);
-    mkdirSync11(dirname12(abs), { recursive: true });
-    writeFileSync13(abs, content);
+    const abs = join20(iosDir, rel);
+    mkdirSync13(dirname12(abs), { recursive: true });
+    writeFileSync15(abs, content);
     log(`${c.green("created")}   ios/${rel}`);
   };
   write("README.md", IOS_README);
@@ -219411,23 +219917,23 @@ var ensureSdkResourcesBundle = async (sdkVersion) => {
   const override = process.env.LECODES_SDK_RESOURCES;
   if (override) {
     note(`Using local resources bundle ${override} (LECODES_SDK_RESOURCES)`);
-    return resolve6(override);
+    return resolve7(override);
   }
-  const dir = join17(homedir6(), ".lecodes", "sdk-resources", sdkVersion);
-  const bundle = join17(dir, "LeCodesSDKResources.bundle");
-  if (existsSync16(bundle))
+  const dir = join20(homedir7(), ".lecodes", "sdk-resources", sdkVersion);
+  const bundle = join20(dir, "LeCodesSDKResources.bundle");
+  if (existsSync19(bundle))
     return bundle;
   const url = `https://github.com/${SDK_REPO}/releases/download/${sdkVersion}/LeCodesSDKResources.bundle.zip`;
   note(`Downloading LeCodesSDKResources.bundle (SDK ${sdkVersion})…`);
   const res = await fetch(url);
   if (!res.ok)
     throw new CliError(`Resources bundle download failed (HTTP ${res.status}) — ${url}`);
-  mkdirSync11(dir, { recursive: true });
-  const zip = join17(dir, "LeCodesSDKResources.bundle.zip");
-  writeFileSync13(zip, new Uint8Array(await res.arrayBuffer()));
+  mkdirSync13(dir, { recursive: true });
+  const zip = join20(dir, "LeCodesSDKResources.bundle.zip");
+  writeFileSync15(zip, new Uint8Array(await res.arrayBuffer()));
   execFileSync4("ditto", ["-x", "-k", zip, dir]);
-  rmSync4(zip);
-  if (!existsSync16(bundle))
+  rmSync6(zip);
+  if (!existsSync19(bundle))
     throw new CliError(`No LeCodesSDKResources.bundle inside the release asset ${url}`);
   return bundle;
 };
@@ -219452,13 +219958,13 @@ var resolveUpdateUrl = (update, root) => {
 };
 var appSync = async (args) => {
   const root = projectRoot();
-  const config = readJson(join17(root, "app.json"));
+  const config = readJson(join20(root, "app.json"));
   const platform = args._[1];
   if (platform !== undefined && platform !== "ios" && platform !== "android") {
     throw new CliError(`Unknown platform "${platform}" — use ios or android.`);
   }
-  const hasIos = !!config?.ios && existsSync16(join17(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync16(join17(root, "android"));
+  const hasIos = !!config?.ios && existsSync19(join20(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync19(join20(root, "android"));
   if (platform === "ios" && !hasIos)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   if (platform === "android" && !hasAndroid)
@@ -219473,7 +219979,7 @@ var appSync = async (args) => {
     await syncAndroid(root, config, iosArtifacts);
 };
 var syncIos = async (root, config) => {
-  const iosDir = join17(root, "ios");
+  const iosDir = join20(root, "ios");
   if (!config.ios)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   const requestedVariant = config.ios.variant ?? "auto";
@@ -219483,14 +219989,14 @@ var syncIos = async (root, config) => {
   const linkedSdk = shellSdkVersion(iosDir);
   const sdkPin = process.env.LECODES_IOS_SDK ?? config.ios.sdk ?? linkedSdk ?? "latest";
   const sdkVersion = await resolveSdkVersion(sdkPin, linkedSdk, IOS_SDK_OPTS);
-  const lockPath = join17(root, "plugins.lock.json");
+  const lockPath = join20(root, "plugins.lock.json");
   const oldLock = readJson(lockPath)?.plugins ?? {};
   const pluginSpecs = Object.entries(config.plugins ?? {});
   const runtimePlugins = [];
   const infoValues = {};
   const entitlementValues = {};
   const newLock = {};
-  const sourcesDir = join17(iosDir, "LeCodesRuntime", "Sources");
+  const sourcesDir = join20(iosDir, "LeCodesRuntime", "Sources");
   for (const [id, spec] of pluginSpecs) {
     const plugin = resolvePlugin(id, spec, oldLock[id], "ios");
     const ios = plugin.manifest.ios;
@@ -219498,11 +220004,11 @@ var syncIos = async (root, config) => {
     const register = ios.register;
     if (!module || !register)
       throw new CliError(`Plugin "${id}": manifest ios.module / ios.register missing`);
-    const src = join17(plugin.dir, ios.sources ?? "ios");
-    if (!existsSync16(src))
+    const src = join20(plugin.dir, ios.sources ?? "ios");
+    if (!existsSync19(src))
       throw new CliError(`Plugin "${id}": sources dir ${src} missing`);
-    const dest = join17(sourcesDir, module);
-    rmSync4(dest, { recursive: true, force: true });
+    const dest = join20(sourcesDir, module);
+    rmSync6(dest, { recursive: true, force: true });
     cpSync3(src, dest, { recursive: true });
     if (ios.minSdk && VERSION_RE.test(ios.minSdk) && cmpVersion(sdkVersion, ios.minSdk) < 0) {
       throw new CliError(`Plugin "${id}" needs lecodes-ios-sdk ${ios.minSdk} but the shell links ${sdkVersion} — run \`lecodes app update\` (or set app.json ios.sdk).`);
@@ -219518,9 +220024,9 @@ var syncIos = async (root, config) => {
     log(`${c.green("plugin")}    ${id}@${plugin.lock.version} (${plugin.lock.tag} → Sources/${module})`);
   }
   const keep = new Set(["LeCodesRuntime", ...runtimePlugins.map((p2) => p2.module)]);
-  for (const entry of existsSync16(sourcesDir) ? readdirSync7(sourcesDir) : []) {
-    if (!keep.has(entry) && statSync5(join17(sourcesDir, entry)).isDirectory()) {
-      rmSync4(join17(sourcesDir, entry), { recursive: true });
+  for (const entry of existsSync19(sourcesDir) ? readdirSync8(sourcesDir) : []) {
+    if (!keep.has(entry) && statSync6(join20(sourcesDir, entry)).isDirectory()) {
+      rmSync6(join20(sourcesDir, entry), { recursive: true });
       log(`${c.yellow("removed")}   ios/LeCodesRuntime/Sources/${entry}  (plugin uninstalled)`);
     }
   }
@@ -219528,11 +220034,11 @@ var syncIos = async (root, config) => {
   if (!Array.isArray(remotePatterns) || remotePatterns.some((p2) => typeof p2 !== "string")) {
     throw new CliError('app.json "resources.remote" must be an array of glob strings (e.g. ["videos/**"]).');
   }
-  const resourcesDir = join17(iosDir, "App", "Resources");
-  rmSync4(resourcesDir, { recursive: true, force: true });
-  mkdirSync11(resourcesDir, { recursive: true });
-  const resources = await compileShell({ _: [], flags: { o: join17(resourcesDir, "app.js") } }, { remotePatterns });
-  const bundleJs = readFileSync15(join17(resourcesDir, "app.js"), "utf8");
+  const resourcesDir = join20(iosDir, "App", "Resources");
+  rmSync6(resourcesDir, { recursive: true, force: true });
+  mkdirSync13(resourcesDir, { recursive: true });
+  const resources = await compileShell({ _: [], flags: { o: join20(resourcesDir, "app.js") } }, { remotePatterns });
+  const bundleJs = readFileSync16(join20(resourcesDir, "app.js"), "utf8");
   const { variant, detected } = resolveVariant(requestedVariant, bundleJs);
   const WHY = {
     core: "UI only",
@@ -219546,8 +220052,8 @@ var syncIos = async (root, config) => {
   const sdkProvided = new Set;
   if (variant === "3d" || variant === "full") {
     const sdkResources = await ensureSdkResourcesBundle(sdkVersion);
-    cpSync3(sdkResources, join17(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
-    for (const f3 of readdirSync7(sdkResources))
+    cpSync3(sdkResources, join20(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
+    for (const f3 of readdirSync8(sdkResources))
       if (f3 !== "Info.plist")
         sdkProvided.add(f3);
     log(`${c.green("resources")} LeCodesSDKResources.bundle (filament) → ios/App/Resources/`);
@@ -219574,7 +220080,7 @@ var syncIos = async (root, config) => {
     }
     if (candidates.length > 1)
       warn(`asset name collision: ${name} (${candidates.map((r2) => r2.path).join(", ")}) — embedding ${candidates[0].path}`);
-    cpSync3(candidates[0].absPath, join17(resourcesDir, name));
+    cpSync3(candidates[0].absPath, join20(resourcesDir, name));
     embedded++;
   }
   if (embedded > 0)
@@ -219594,14 +220100,14 @@ var syncIos = async (root, config) => {
   }
   if (shellUuid)
     log(`${c.green("identity")}  project ${shellUuid} baked into the shell (world identity)`);
-  writeFileSync13(join17(iosDir, "README.md"), IOS_README);
-  writeFileSync13(join17(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
-  writeFileSync13(join17(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins, shellUuid));
+  writeFileSync15(join20(iosDir, "README.md"), IOS_README);
+  writeFileSync15(join20(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
+  writeFileSync15(join20(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins, shellUuid));
   const mergedKeys = {};
   for (const [key, values] of Object.entries(infoValues))
     mergedKeys[key] = [...new Set(values)].join(" ");
   const updateUrl = resolveUpdateUrl(config.update, root);
-  writeFileSync13(join17(iosDir, "App", "Info.plist"), infoPlistTemplate(mergedKeys, updateUrl));
+  writeFileSync15(join20(iosDir, "App", "Info.plist"), infoPlistTemplate(mergedKeys, updateUrl));
   if (updateUrl)
     log(`${c.green("update")}    OTA source ${updateUrl} — checked natively at launch, new code applies next launch`);
   else if (!config.update) {
@@ -219612,10 +220118,10 @@ var syncIos = async (root, config) => {
     if (manifest)
       note(`tip: add "update": true to app.json for over-the-air JS updates — ship with \`lecodes push --publish\`, no store release`);
   }
-  if (pluginSpecs.length > 0 || existsSync16(lockPath))
+  if (pluginSpecs.length > 0 || existsSync19(lockPath))
     writeJson(lockPath, { plugins: newLock });
-  const pbxPath = join17(iosDir, "App.xcodeproj", "project.pbxproj");
-  let pbx = readFileSync15(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 pbxPath = join20(iosDir, "App.xcodeproj", "project.pbxproj");
+  let pbx = readFileSync16(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 = {};
   for (const [key, values] of Object.entries(entitlementValues)) {
     if (values.every((v) => Array.isArray(v))) {
@@ -219636,7 +220142,7 @@ var syncIos = async (root, config) => {
   }
   const hasEntitlements = Object.keys(mergedEntitlements).length > 0;
   if (pbx.includes("CODE_SIGN_ENTITLEMENTS") || hasEntitlements) {
-    writeFileSync13(join17(iosDir, "App", "App.entitlements"), entitlementsTemplate(mergedEntitlements));
+    writeFileSync15(join20(iosDir, "App", "App.entitlements"), entitlementsTemplate(mergedEntitlements));
     if (hasEntitlements)
       log(`${c.green("caps")}      App/App.entitlements: ${Object.keys(mergedEntitlements).sort().join(", ")}`);
     if (!pbx.includes("CODE_SIGN_ENTITLEMENTS")) {
@@ -219652,7 +220158,7 @@ $2Info.plist,`);
       }
     }
   }
-  writeFileSync13(pbxPath, pbx);
+  writeFileSync15(pbxPath, pbx);
   if (config.icon) {
     await writeIosAppIcon(iosDir, await loadIconMaster(root, config));
   }
@@ -219664,7 +220170,7 @@ $2Info.plist,`);
 var appPlugin = async (args) => {
   const sub = args._[1];
   const root = projectRoot();
-  const configPath = join17(root, "app.json");
+  const configPath = join20(root, "app.json");
   const config = readJson(configPath);
   if (!config)
     throw new CliError("No app.json here — run `lecodes app init <ios|android>` first.");
@@ -219675,7 +220181,7 @@ var appPlugin = async (args) => {
       log("No plugins installed.");
       return;
     }
-    const lock = readJson(join17(root, "plugins.lock.json"))?.plugins ?? {};
+    const lock = readJson(join20(root, "plugins.lock.json"))?.plugins ?? {};
     for (const [id2, spec] of entries) {
       const pin = lock[id2] ? c.dim(`  ${lock[id2].repo} ${lock[id2].tag} (${lock[id2].commit.slice(0, 7)})`) : c.dim("  (not synced)");
       log(`${c.bold(id2)} ${spec}${pin}`);
@@ -219728,14 +220234,14 @@ var exportOptionsPlist = (method, teamId, destination) => `<?xml version="1.0" e
 `;
 var requireShell = () => {
   const root = projectRoot();
-  const config = readJson(join17(root, "app.json"));
-  if (!config?.ios || !existsSync16(join17(root, "ios"))) {
+  const config = readJson(join20(root, "app.json"));
+  if (!config?.ios || !existsSync19(join20(root, "ios"))) {
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   }
   return { root, config };
 };
 var updateSdkPin = async (root, config, args, checkOnly, platform) => {
-  const [label, repo, minVersion, shellVersion] = platform === "ios" ? ["lecodes-ios-sdk", SDK_REPO, SDK_MIN_VERSION, () => shellSdkVersion(join17(root, "ios"))] : ["lecodes-android-sdk", ANDROID_SDK_REPO, ANDROID_SDK_MIN_VERSION, () => shellSdkVersionAndroid(join17(root, "android"))];
+  const [label, repo, minVersion, shellVersion] = platform === "ios" ? ["lecodes-ios-sdk", SDK_REPO, SDK_MIN_VERSION, () => shellSdkVersion(join20(root, "ios"))] : ["lecodes-android-sdk", ANDROID_SDK_REPO, ANDROID_SDK_MIN_VERSION, () => shellSdkVersionAndroid(join20(root, "android"))];
   const section = config[platform];
   const wanted = flagStr(args, "sdk");
   let changed = false;
@@ -219766,19 +220272,19 @@ var updateSdkPin = async (root, config, args, checkOnly, platform) => {
   }
   if (!checkOnly && nextPin !== pin) {
     section.sdk = nextPin;
-    writeJson(join17(root, "app.json"), config);
+    writeJson(join20(root, "app.json"), config);
   }
   return changed;
 };
 var appUpdate = async (args) => {
   const root = projectRoot();
-  const config = readJson(join17(root, "app.json"));
+  const config = readJson(join20(root, "app.json"));
   const platform = args._[1];
   if (platform !== undefined && platform !== "ios" && platform !== "android") {
     throw new CliError(`Unknown platform "${platform}" — use ios or android.`);
   }
-  const hasIos = !!config?.ios && existsSync16(join17(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync16(join17(root, "android"));
+  const hasIos = !!config?.ios && existsSync19(join20(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync19(join20(root, "android"));
   if (platform === "ios" && !hasIos)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   if (platform === "android" && !hasAndroid)
@@ -219796,7 +220302,7 @@ var appUpdate = async (args) => {
     changed = await updateSdkPin(root, config, args, checkOnly, "ios") || changed;
   if (doAndroid)
     changed = await updateSdkPin(root, config, args, checkOnly, "android") || changed;
-  const lockPath = join17(root, "plugins.lock.json");
+  const lockPath = join20(root, "plugins.lock.json");
   const lock = readJson(lockPath)?.plugins ?? {};
   const specs = Object.entries(config.plugins ?? {});
   if (specs.length > 0 && !flagBool(args, "no-plugins")) {
@@ -219825,7 +220331,7 @@ var appUpdate = async (args) => {
       log(`${c.green("plugin")}    ${id} ${entry?.tag ?? "—"} → ${c.bold(tag)}`);
       changed = true;
     }
-    if (!checkOnly && existsSync16(lockPath))
+    if (!checkOnly && existsSync19(lockPath))
       writeJson(lockPath, { plugins: kept });
   }
   log("");
@@ -219845,9 +220351,9 @@ var appUpdate = async (args) => {
 };
 var appDoctor = async (_args) => {
   const root = projectRoot();
-  const config = readJson(join17(root, "app.json"));
-  const hasIos = !!config?.ios && existsSync16(join17(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync16(join17(root, "android"));
+  const config = readJson(join20(root, "app.json"));
+  const hasIos = !!config?.ios && existsSync19(join20(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync19(join20(root, "android"));
   if (!hasIos && !hasAndroid) {
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   }
@@ -219858,14 +220364,14 @@ var appDoctor = async (_args) => {
       failed++;
   };
   if (config?.icon) {
-    check(existsSync16(join17(root, config.icon)), `Icon master ${config.icon}`, `app.json "icon" points at a missing file — sync will fail`);
+    check(existsSync19(join20(root, config.icon)), `Icon master ${config.icon}`, `app.json "icon" points at a missing file — sync will fail`);
   }
   if (hasIos)
     await doctorIosChecks(root, config, check);
   if (hasAndroid) {
     await doctorAndroidChecks(root, config, check);
     if (!hasIos) {
-      const lock = readJson(join17(root, "plugins.lock.json"))?.plugins ?? {};
+      const lock = readJson(join20(root, "plugins.lock.json"))?.plugins ?? {};
       const wanted = Object.keys(config.plugins ?? {});
       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`");
@@ -219884,22 +220390,22 @@ var doctorIosChecks = async (root, config, check) => {
   } catch {}
   check(xcodeVersion !== "", `Xcode CLI (${xcodeVersion || "not found"})`, "install Xcode + command line tools");
   check(!!config.ios.teamId, "Development team set", "lecodes app init wrote app.json — fill ios.teamId", false);
-  const iconDir = join17(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
-  const hasIcon = existsSync16(iconDir) && readdirSync7(iconDir).some((f3) => f3.endsWith(".png"));
+  const iconDir = join20(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
+  const hasIcon = existsSync19(iconDir) && readdirSync8(iconDir).some((f3) => f3.endsWith(".png"));
   check(hasIcon, "App icon present", "drop a 1024×1024 PNG into ios/App/Assets.xcassets/AppIcon.appiconset/ (App Store requires it)", false);
-  const bundle = join17(root, "ios", "App", "Resources", "app.js");
-  check(existsSync16(bundle), "Bundled app.js", "run `lecodes app sync`");
+  const bundle = join20(root, "ios", "App", "Resources", "app.js");
+  check(existsSync19(bundle), "Bundled app.js", "run `lecodes app sync`");
   const requestedVariant = config.ios.variant ?? "auto";
   const validVariant = requestedVariant === "auto" || SDK_VARIANTS.includes(requestedVariant);
   check(validVariant, `ios.variant "${requestedVariant}"`, `use "auto" or one of ${SDK_VARIANTS.join(", ")}`);
-  if (existsSync16(bundle) && validVariant) {
-    const { variant } = resolveVariant(requestedVariant, readFileSync15(bundle, "utf8"));
-    const pkg = readFileSync15(join17(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
+  if (existsSync19(bundle) && validVariant) {
+    const { variant } = resolveVariant(requestedVariant, readFileSync16(bundle, "utf8"));
+    const pkg = readFileSync16(join20(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
     const needsResources = variant === "3d" || variant === "full";
-    const hasResources = existsSync16(join17(root, "ios", "App", "Resources", "LeCodesSDKResources.bundle"));
+    const hasResources = existsSync19(join20(root, "ios", "App", "Resources", "LeCodesSDKResources.bundle"));
     check(pkg.includes(`"LeCodesSDK-${variant}"`) && (!needsResources || hasResources), `SDK variant ${variant}${needsResources ? " (+ filament resources)" : ""}`, "run `lecodes app sync`");
   }
-  const linked = shellSdkVersion(join17(root, "ios"));
+  const linked = shellSdkVersion(join20(root, "ios"));
   const pin = config.ios.sdk ?? "latest";
   check(!!linked, `SDK ${linked ?? "version unreadable"}`, "run `lecodes app sync`");
   if (linked && pin !== "latest") {
@@ -219911,27 +220417,27 @@ var doctorIosChecks = async (root, config, check) => {
       check(cmpVersion(linked, latest) >= 0, `SDK is the latest release (${latest})`, "run `lecodes app update`", false);
     } catch {}
   }
-  const lock = readJson(join17(root, "plugins.lock.json"))?.plugins ?? {};
+  const lock = readJson(join20(root, "plugins.lock.json"))?.plugins ?? {};
   const wanted = Object.keys(config.plugins ?? {});
   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 = join17(root, "ios", "App.xcodeproj", "project.pbxproj");
-  if (existsSync16(pbxFile) && readFileSync15(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
-    check(existsSync16(join17(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
+  const pbxFile = join20(root, "ios", "App.xcodeproj", "project.pbxproj");
+  if (existsSync19(pbxFile) && readFileSync16(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
+    check(existsSync19(join20(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
   }
   if (wanted.includes("push")) {
-    const runtimeSwift = join17(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
-    const baked = existsSync16(runtimeSwift) && readFileSync15(runtimeSwift, "utf8").includes("bootProjectUuid");
+    const runtimeSwift = join20(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
+    const baked = existsSync19(runtimeSwift) && readFileSync16(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 = readFileSync15(join17(root, "ios", "App", "Info.plist"), "utf8");
+    const plist = readFileSync16(join20(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 = join17(root, "ios", "App");
-    const callsUpdater = readdirSync7(appDir).some((f3) => f3.endsWith(".swift") && readFileSync15(join17(appDir, f3), "utf8").includes("LeCodesUpdater.activeBundle"));
+    const appDir = join20(root, "ios", "App");
+    const callsUpdater = readdirSync8(appDir).some((f3) => f3.endsWith(".swift") && readFileSync16(join20(appDir, f3), "utf8").includes("LeCodesUpdater.activeBundle"));
     check(callsUpdater, "App code launches via LeCodesUpdater", `no App/*.swift calls LeCodesUpdater.activeBundle() — downloaded updates would never run; see "Over-the-air updates" in ios/README.md for the ViewController snippet`, false);
   }
-  const asc = readJson(join17(homedir6(), ".lecodes", "asc.json"));
+  const asc = readJson(join20(homedir7(), ".lecodes", "asc.json"));
   check(!!asc?.keyPath, "App Store Connect API key configured", "pass --key-path/--key-id/--issuer-id to `lecodes app upload` once to store it", false);
 };
 var ARCHIVE_PATH = "ios/build/App.xcarchive";
@@ -219967,8 +220473,8 @@ var appBuild = async (args) => {
   success(`Archive: ios/build/App.xcarchive`);
   if (flagBool(args, "no-export"))
     return;
-  const optionsPath = join17(root, "ios", "build", "ExportOptions.plist");
-  writeFileSync13(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
+  const optionsPath = join20(root, "ios", "build", "ExportOptions.plist");
+  writeFileSync15(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
   note(`Exporting (.ipa, method ${method})…`);
   runTool(root, "xcodebuild", [
     "-exportArchive",
@@ -219987,10 +220493,10 @@ var appUpload = async (args) => {
     throw new CliError("Play upload isn't wired yet — upload android/app/build/outputs/bundle/release/*.aab in the Play Console (`lecodes app build android` produces it).");
   }
   const { root, config } = requireShell();
-  if (!existsSync16(join17(root, ARCHIVE_PATH))) {
+  if (!existsSync19(join20(root, ARCHIVE_PATH))) {
     throw new CliError("No archive at ios/build/App.xcarchive — run `lecodes app build ios` first.");
   }
-  const ascPath = join17(homedir6(), ".lecodes", "asc.json");
+  const ascPath = join20(homedir7(), ".lecodes", "asc.json");
   const stored = readJson(ascPath) ?? {};
   const keyPath = flagStr(args, "key-path") ?? stored.keyPath;
   const keyId = flagStr(args, "key-id") ?? stored.keyId;
@@ -219999,15 +220505,15 @@ var appUpload = async (args) => {
     throw new CliError(`App Store Connect API key needed: --key-path <AuthKey.p8> --key-id <id> --issuer-id <id>
 (create one at appstoreconnect.apple.com → Users and Access → Integrations; stored in ~/.lecodes/asc.json after first use)`);
   }
-  if (!existsSync16(keyPath))
+  if (!existsSync19(keyPath))
     throw new CliError(`API key file not found: ${keyPath}`);
   if (flagStr(args, "key-path")) {
-    mkdirSync11(dirname12(ascPath), { recursive: true });
+    mkdirSync13(dirname12(ascPath), { recursive: true });
     writeJson(ascPath, { keyPath, keyId, issuerId });
     note("Stored the key reference in ~/.lecodes/asc.json");
   }
-  const optionsPath = join17(root, "ios", "build", "UploadOptions.plist");
-  writeFileSync13(optionsPath, exportOptionsPlist("app-store-connect", config.ios.teamId ?? "", "upload"));
+  const optionsPath = join20(root, "ios", "build", "UploadOptions.plist");
+  writeFileSync15(optionsPath, exportOptionsPlist("app-store-connect", config.ios.teamId ?? "", "upload"));
   note("Uploading to App Store Connect… (processing continues on Apple's side)");
   runTool(root, "xcodebuild", [
     "-exportArchive",
@@ -220018,14 +220524,14 @@ var appUpload = async (args) => {
     "-exportPath",
     "ios/build/upload",
     "-authenticationKeyPath",
-    resolve6(keyPath),
+    resolve7(keyPath),
     "-authenticationKeyID",
     keyId,
     "-authenticationKeyIssuerID",
     issuerId,
     "-allowProvisioningUpdates"
   ]);
-  const configPath = join17(root, "app.json");
+  const configPath = join20(root, "app.json");
   const fresh = readJson(configPath);
   fresh.ios.buildNumber = (fresh.ios.buildNumber ?? 1) + 1;
   writeJson(configPath, fresh);
@@ -220036,15 +220542,15 @@ var appOpen = async (args) => {
   const root = projectRoot();
   let platform = args._[1];
   if (!platform) {
-    const hasIos = existsSync16(join17(root, "ios"));
-    const hasAndroid = existsSync16(join17(root, "android"));
+    const hasIos = existsSync19(join20(root, "ios"));
+    const hasAndroid = existsSync19(join20(root, "android"));
     if (hasIos && hasAndroid)
       throw new CliError("Both shells exist — `lecodes app open ios` or `lecodes app open android`.");
     platform = hasAndroid ? "android" : "ios";
   }
   if (platform === "ios") {
-    const proj = join17(root, "ios", "App.xcodeproj");
-    if (!existsSync16(proj))
+    const proj = join20(root, "ios", "App.xcodeproj");
+    if (!existsSync19(proj))
       throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
     if (process.platform !== "darwin")
       throw new CliError("Opening Xcode requires macOS.");
@@ -220081,8 +220587,8 @@ var app = async (args) => {
 init_api();
 init_config();
 init_manifest();
-import { existsSync as existsSync18, mkdirSync as mkdirSync13, readdirSync as readdirSync9 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync10 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
 init_types4();
 init_ignore();
 init_util();
@@ -220103,11 +220609,11 @@ var clone3 = async (args) => {
   const uuid = parseUuid(args._[0]);
   const project = await getProject(apiUrl, token, uuid);
   const dir = args._[1] ?? slug(project.name);
-  const root = resolve7(dir);
-  if (existsSync18(root) && readdirSync9(root).length > 0) {
+  const root = resolve8(dir);
+  if (existsSync21(root) && readdirSync10(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync13(root, { recursive: true });
+  mkdirSync15(root, { recursive: true });
   info(c.dim(`Fetching project ${c.bold(project.name)}…`));
   const files = await materializeAssets(root, project, apiUrl, token, progress);
   endProgress();
@@ -220130,8 +220636,8 @@ init_config();
 init_manifest();
 init_types4();
 init_ignore();
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readdirSync as readdirSync10, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join19, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync16, readdirSync as readdirSync11, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join22, resolve as resolve9 } from "node:path";
 
 // src/commands/projectTemplates.ts
 var appClaudeMd = (name) => `# ${name} — LeCodes app
@@ -220173,7 +220679,11 @@ are the regression suite. A failing step dumps the failing frame (JSON + PNG) un
 
 One action per step (\`tap\`, \`type\`+\`text\`, \`fill\`, \`scroll\` [+\`by\`], \`wait\`, and for
 games: \`frames\` (advance N fixed 1/60 steps, no sleeping), \`drag\`+\`to\` [+\`ms\`], \`hold\`+\`ms\`,
-\`key\`+\`ms\` / \`keyDown\` / \`keyUp\` (KeyboardEvent.code: "ArrowRight", "KeyW", "Space")), then an
+\`key\`+\`ms\` / \`keyDown\` / \`keyUp\` (KeyboardEvent.code: "ArrowRight", "KeyW", "Space" — mouse
+buttons are keys too: "MouseLeft"/"MouseRight"), \`look: [dx, dy]\` [+\`ms\`] (mouse motion for
+\`Input.mouse.delta\`), \`mouseTo: [x, y]\` (cursor position), \`wheel: [dx, dy]\`, gamepad:
+\`stick: { left: [x, y], right: [x, y], triggers: [l, r] }\` (values persist; \`index\` = pad),
+\`gamepad: "connect" | "disconnect"\`, pad buttons as keys: \`keyDown: "GamepadSouth"\`), then an
 optional \`expect\` (\`screen\`, \`node\`/\`notNode\`, \`text\`/\`notText\`,
 \`value: { target, equals }\`, \`log\` — a \`console.log\` line contains it), then outputs
 (\`screenshot\` [+\`clip\`: a node name or \`{ x, y, width, height }\`], \`json\`). Targets resolve by
@@ -220192,7 +220702,9 @@ the 2D scene (sprite \`click\`/\`touchstart\`, \`ev.track()\`). Envelope keys: \
 
 Game time is deterministic headless: \`setLoop\`, 2D physics/animation and aspect \`update(dt)\`
 advance in fixed 1/60 steps driven by \`wait\`/\`frames\`/\`drag\`/\`key\` — never by a wall clock —
-so a flow that passes once passes every time. \`Input.key(code)\` reads the keys a flow holds.
+so a flow that passes once passes every time. \`Input.key(code)\` reads the keys a flow holds and
+\`Input.on('keydown' | 'keyup', e => e.code)\` fires for each \`key\`/\`keyDown\`/\`keyUp\` step
+(events land before the next loop tick); \`stick\` values are what \`Input.gamepad(0).axis()\` reads.
 Headless draws UI + the 2D scene (sprites, tilemaps, Box2D); 3D is captured as JSON and Jolt does
 not simulate — use \`--desktop\` for 3D pixels. \`console.log\` + \`expect.log\` is the assertion
 channel for game state that has no UI.
@@ -220262,21 +220774,21 @@ var create = async (args) => {
   if (!name)
     throw new CliError("Usage: lecodes create <name> [directory]");
   const dir = args._[1] ?? slug2(name);
-  const root = resolve8(dir);
-  if (existsSync19(root) && readdirSync10(root).length > 0) {
+  const root = resolve9(dir);
+  if (existsSync22(root) && readdirSync11(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync14(root, { recursive: true });
+  mkdirSync16(root, { recursive: true });
   info(c.dim(`Creating project ${c.bold(name)}…`));
   const { uuid } = await createProject(apiUrl, token, name, flagStr(args, "team"));
   info(c.dim("Fetching type definitions…"));
   await materializeTypes(root, apiUrl);
   writeTsconfig(root);
   writeDefaultIgnore(root);
-  writeFileSync15(join19(root, "main.ts"), STARTER);
-  writeFileSync15(join19(root, "CLAUDE.md"), appClaudeMd(name));
-  mkdirSync14(join19(root, ".claude"), { recursive: true });
-  writeFileSync15(join19(root, ".claude", "settings.json"), CLAUDE_SETTINGS);
+  writeFileSync17(join22(root, "main.ts"), STARTER);
+  writeFileSync17(join22(root, "CLAUDE.md"), appClaudeMd(name));
+  mkdirSync16(join22(root, ".claude"), { recursive: true });
+  writeFileSync17(join22(root, ".claude", "settings.json"), CLAUDE_SETTINGS);
   const commits = await getCommits(apiUrl, token, uuid);
   writeManifest(root, { uuid, apiUrl, name, baseHeadId: commits.headId, files: {} });
   success(`Created ${c.bold(name)} in ${c.bold(dir)}/`);
@@ -220298,6 +220810,15 @@ var resolveScale = (flag, cfg) => {
   }
   return n2;
 };
+var resolveRenderScale = (flag, cfg) => {
+  const raw = flag ?? cfg;
+  if (raw === undefined)
+    return;
+  const n2 = Number(raw);
+  if (!Number.isFinite(n2) || n2 < 0.25 || n2 > 1)
+    throw new CliError(`render-scale must be a number 0.25..1 (got "${raw}")`);
+  return n2;
+};
 var run = async (args) => {
   let root;
   try {
@@ -220317,7 +220838,9 @@ var run = async (args) => {
     resizable: win?.resizable,
     title: flagStr(args, "title") ?? win?.title ?? appCfg?.name,
     fullscreen: flagBool(args, "fullscreen") ? true : flagBool(args, "windowed") ? false : win?.fullscreen,
-    scale: resolveScale(flagStr(args, "scale"), win?.scale)
+    scale: resolveScale(flagStr(args, "scale"), win?.scale),
+    renderScale: resolveRenderScale(flagStr(args, "render-scale"), appCfg?.desktop?.renderScale),
+    maxRenderSize: appCfg?.desktop?.maxRenderSize
   });
 };
 var status = async () => {
@@ -220353,15 +220876,16 @@ init_design();
 // src/commands/dev.ts
 init_manifest();
 init_ignore();
-import { existsSync as existsSync21, mkdirSync as mkdirSync16, readFileSync as readFileSync19, watch, writeFileSync as writeFileSync17 } from "node:fs";
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync24, mkdirSync as mkdirSync18, readFileSync as readFileSync20, watch, writeFileSync as writeFileSync19 } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { basename as basename9, join as join21 } from "node:path";
+import { basename as basename10, join as join25 } from "node:path";
 
 // src/dev/devServer.ts
 init_localFiles();
 import { createServer as createServer2 } from "node:http";
-import { createReadStream, statSync as statSync7 } from "node:fs";
+import { createReadStream, statSync as statSync8 } from "node:fs";
+import { join as join24 } from "node:path";
 init_projectCompile();
 init_fonts();
 init_assetIcons();
@@ -220485,9 +221009,9 @@ var renderPrelude = (p2) => DEV_PRELUDE_JS.split("__DEV_ORIGIN__").join(p2.origi
 var renderDevScreen = (name) => DEV_SCREEN_TS.split("__DEV_NAME__").join(JSON.stringify(name));
 
 // src/dev/wsServer.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-var acceptKey = (key) => createHash6("sha1").update(key + WS_GUID).digest("base64");
+var acceptKey = (key) => createHash7("sha1").update(key + WS_GUID).digest("base64");
 var encodeTextFrame = (text) => {
   const payload = Buffer.from(text, "utf8");
   const len = payload.length;
@@ -220635,14 +221159,14 @@ var sendText = (res, status2, type, body) => {
   res.end(body);
 };
 var sendJson = (res, status2, body) => sendText(res, status2, "application/json", JSON.stringify(body));
-var readBody = (req) => new Promise((resolve9) => {
+var readBody = (req) => new Promise((resolve10) => {
   let body = "";
   req.on("data", (c4) => {
     if (body.length < 256 * 1024)
       body += c4.toString("utf8");
   });
-  req.on("end", () => resolve9(body));
-  req.on("error", () => resolve9(body));
+  req.on("end", () => resolve10(body));
+  req.on("error", () => resolve10(body));
 });
 var startDevServer = async (options) => {
   const { root, manifest, name, origin, token, entryOverride } = options;
@@ -220654,7 +221178,8 @@ var startDevServer = async (options) => {
   const stripVolatile = (js) => js.replace(/^\/\/ last-updated: .*$/m, "");
   const compileOnce = async () => {
     try {
-      const { entries, warnings } = collectLocalEntries(root, manifest, `${base}/assets`);
+      const { entries, warnings } = collectLocalEntries(root, manifest, `${base}/assets`, { localShaders: true });
+      warnings.push(...(await applyLocalShaders(entries, { root, srcPrefix: `${base}/shaders` })).warnings);
       const fontsHeader = await applyProjectFonts(entries, {
         mode: "vendor",
         root,
@@ -220742,6 +221267,21 @@ var startDevServer = async (options) => {
       printDeviceMessage(await readBody(req));
       return sendJson(res, 200, { ok: true });
     }
+    if (route.startsWith("/shaders/")) {
+      const name2 = route.slice("/shaders/".length);
+      if (!isShaderArtifactName(name2))
+        return sendText(res, 400, "text/plain", "Bad path");
+      const abs = join24(shadersCacheDir(root), name2);
+      try {
+        if (!statSync8(abs).isFile())
+          throw new Error("not a file");
+      } catch {
+        return sendText(res, 404, "text/plain", "Not found");
+      }
+      res.writeHead(200, { "content-type": "application/octet-stream", "cache-control": "no-store" });
+      createReadStream(abs).pipe(res);
+      return;
+    }
     if (route.startsWith("/assets/")) {
       let key;
       try {
@@ -220750,7 +221290,7 @@ var startDevServer = async (options) => {
         return sendText(res, 400, "text/plain", "Bad path");
       }
       const abs = resolveLocalPath(root, key);
-      if (!abs || !statSync7(abs).isFile())
+      if (!abs || !statSync8(abs).isFile())
         return sendText(res, 404, "text/plain", "Not found");
       res.writeHead(200, { "content-type": contentType(key), "cache-control": "no-store" });
       createReadStream(abs).pipe(res);
@@ -220793,11 +221333,11 @@ var startDevServer = async (options) => {
     if (conn)
       clients.add(conn);
   });
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve10, reject) => {
     server2.once("error", reject);
     server2.listen(options.port, options.bind ?? "0.0.0.0", () => {
       server2.removeListener("error", reject);
-      resolve9();
+      resolve10();
     });
   });
   const address = server2.address();
@@ -220845,24 +221385,24 @@ var lanCandidates = () => {
   return out.sort((x2, y2) => x2.rank - y2.rank).map(({ address, iface }) => ({ address, iface }));
 };
 var loadDevToken = (root) => {
-  const path2 = join21(root, LECODES_DIR, "dev.json");
+  const path2 = join25(root, LECODES_DIR, "dev.json");
   try {
-    const token2 = JSON.parse(readFileSync19(path2, "utf8")).token;
+    const token2 = JSON.parse(readFileSync20(path2, "utf8")).token;
     if (token2 && /^[a-z0-9]{8,}$/.test(token2))
       return token2;
   } catch {}
-  const token = randomBytes2(6).toString("hex");
-  mkdirSync16(join21(root, LECODES_DIR), { recursive: true });
-  writeFileSync17(path2, JSON.stringify({ token }, null, 2) + `
+  const token = randomBytes3(6).toString("hex");
+  mkdirSync18(join25(root, LECODES_DIR), { recursive: true });
+  writeFileSync19(path2, JSON.stringify({ token }, null, 2) + `
 `);
   return token;
 };
 var printQr = async (url) => {
   try {
     const qrcode = (await Promise.resolve().then(() => __toESM(require_main(), 1))).default;
-    await new Promise((resolve9) => qrcode.generate(url, { small: true }, (out) => {
+    await new Promise((resolve10) => qrcode.generate(url, { small: true }, (out) => {
       log(out);
-      resolve9();
+      resolve10();
     }));
   } catch {
     note("(couldn't render a QR code — open the URL below on the device)");
@@ -220878,7 +221418,7 @@ var dev = async (args) => {
     root = process.cwd();
     manifest = null;
   }
-  const name = manifest?.name ?? basename9(root);
+  const name = manifest?.name ?? basename10(root);
   if (typeof globalThis.Bun !== "undefined") {
     warnErr("Running under Bun: the websocket reload channel doesn't work here — run `lecodes dev` with Node (or use ?t=poll on the device URL).");
   }
@@ -220970,7 +221510,7 @@ ${result.error}`);
   if (alternatives.length > 0) {
     note(`Device can't reach it? This machine also has ${alternatives.map((a2) => `${a2.address} (${a2.iface})`).join(", ")} — retry with --host <ip>.`);
   }
-  if (existsSync21(join21(root, LECODES_DIR, "manifest.json")))
+  if (existsSync24(join25(root, LECODES_DIR, "manifest.json")))
     note(`Token stored in ${LECODES_DIR}/dev.json (delete it to rotate the URL).`);
   log("");
   log(`Watching ${root} — save a file to hot-reload. Ctrl+C to stop.`);
@@ -220998,8 +221538,8 @@ init_localFiles();
 
 // src/serverDiff.ts
 init_localFiles();
-import { readFileSync as readFileSync20 } from "node:fs";
-import { basename as basename10 } from "node:path";
+import { readFileSync as readFileSync21 } from "node:fs";
+import { basename as basename11 } from "node:path";
 var isTextAsset = (t2) => t2 === "text" || t2 === "shader" || t2 === "scene";
 var computeServerDiff = (project, scan2) => {
   const pathById = buildPaths(project.assets);
@@ -221016,8 +221556,8 @@ var computeServerDiff = (project, scan2) => {
     const server2 = serverByPath.get(path2);
     const local = localByPath.get(path2);
     if (local && !server2) {
-      const text = isTextKind(classifyKind(basename10(path2)));
-      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync20(local.absPath, "utf8") : undefined });
+      const text = isTextKind(classifyKind(basename11(path2)));
+      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync21(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server2 && !local) {
@@ -221028,12 +221568,12 @@ var computeServerDiff = (project, scan2) => {
     if (server2 && local) {
       if (isTextAsset(server2.type)) {
         const serverText = server2.text ?? "";
-        const localText = readFileSync20(local.absPath, "utf8");
+        const localText = readFileSync21(local.absPath, "utf8");
         if (serverText !== localText)
           entries.push({ path: path2, status: "modified", binary: false, serverText, localText });
       } else {
         const serverSize = server2.file?.size;
-        const localSize = Buffer.byteLength(readFileSync20(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync21(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path: path2, status: "modified", binary: true });
         }
@@ -221191,8 +221731,8 @@ var statusLabel = (e2) => e2.status === "added" ? c.green("  added    ") : e2.st
 init_manifest();
 init_types4();
 init_ignore();
-import { existsSync as existsSync22, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18 } from "node:fs";
-import { basename as basename11, dirname as dirname14, join as join22, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync19, writeFileSync as writeFileSync20 } from "node:fs";
+import { basename as basename12, dirname as dirname14, join as join26, resolve as resolve10 } from "node:path";
 init_util();
 var STARTER2 = `// Welcome to LeCodes — the whole SDK is available as globals, no imports needed.
 // Run it live on a device with \`lecodes dev\`, or bundle it with \`lecodes compile -o app.js\`.
@@ -221300,18 +221840,18 @@ Full command list: \`lecodes --help\`.
 `;
 var init2 = async (args) => {
   const dirArg = (args._[0] ?? ".").replace(/[/\\]+$/, "") || ".";
-  const root = resolve9(dirArg);
-  const name = basename11(root);
-  mkdirSync17(root, { recursive: true });
+  const root = resolve10(dirArg);
+  const name = basename12(root);
+  mkdirSync19(root, { recursive: true });
   let created = 0;
   const write = (rel, content) => {
-    const abs = join22(root, rel);
-    if (existsSync22(abs)) {
+    const abs = join26(root, rel);
+    if (existsSync25(abs)) {
       note(`kept      ${rel}`);
       return;
     }
-    mkdirSync17(dirname14(abs), { recursive: true });
-    writeFileSync18(abs, content);
+    mkdirSync19(dirname14(abs), { recursive: true });
+    writeFileSync20(abs, content);
     log(`${c.green("created")}   ${rel}`);
     created++;
   };
@@ -221358,8 +221898,8 @@ init_config();
 init_ignore();
 init_localFiles();
 init_manifest();
-import { existsSync as existsSync23 } from "node:fs";
-import { basename as basename13, join as join23, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { basename as basename14, join as join27, resolve as resolve11 } from "node:path";
 init_types4();
 init_util();
 
@@ -221368,8 +221908,8 @@ init_api();
 init_config();
 init_manifest();
 init_localFiles();
-import { basename as basename12 } from "node:path";
-import { readFileSync as readFileSync21 } from "node:fs";
+import { basename as basename13 } from "node:path";
+import { readFileSync as readFileSync22 } from "node:fs";
 init_util();
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
@@ -221425,14 +221965,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan2.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename12(file.path));
+    const kind = source?.type ?? classifyKind(basename13(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync21(file.absPath, "utf8");
+      entry.text = readFileSync22(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename12(file.path), readFileSync21(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename13(file.path), readFileSync22(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -221539,10 +222079,10 @@ var link = async (args) => {
   const apiUrl = requireApiUrl(config);
   const token = requireToken(config);
   const dirArg = args._[0];
-  const root = dirArg ? resolve10(dirArg) : process.cwd();
-  if (!existsSync23(root))
+  const root = dirArg ? resolve11(dirArg) : process.cwd();
+  if (!existsSync26(root))
     throw new CliError(`No such directory: ${root}`);
-  if (existsSync23(join23(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
+  if (existsSync26(join27(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
     throw new CliError("This folder is already linked (.lecodes/manifest.json exists) — use `lecodes push`, or `lecodes link --force` to re-link it to another project.");
   }
   let enclosing = null;
@@ -221569,7 +222109,7 @@ var link = async (args) => {
     }
     name = project.name;
   } else {
-    name = flagStr(args, "name") ?? basename13(root);
+    name = flagStr(args, "name") ?? basename14(root);
     info(c.dim(`Creating project ${c.bold(name)}…`));
     uuid = (await createProject(apiUrl, token, name, flagStr(args, "team"))).uuid;
     files = {};
@@ -221619,9 +222159,91 @@ var login = async (args) => {
   success(`Logged in as ${c.bold(account.email)} on ${apiUrl}`);
 };
 
+// src/commands/shaders.ts
+init_manifest();
+import { readFileSync as readFileSync23 } from "node:fs";
+init_util();
+var collectShaders = () => {
+  let root;
+  let manifest;
+  try {
+    root = findProjectRoot(process.cwd());
+    manifest = readManifest(root);
+  } catch {
+    root = process.cwd();
+    manifest = null;
+  }
+  const { entries } = collectLocalEntries(root, manifest, "", { localShaders: true });
+  return { root, entries, shaders: entries.filter((e2) => e2.type === "shader" && e2.absPath) };
+};
+var status2 = async () => {
+  const { root, shaders } = collectShaders();
+  const installed = installedMatcVersions();
+  const matcExe = resolveMatcExeCached();
+  log(`matc            ${matcExe ? process.env.LECODES_MATC ? `LECODES_MATC=${process.env.LECODES_MATC}` : `${installed[0]}   ${c.dim("(~/.lecodes/matc)")}` : c.dim("not downloaded — fetched by `lecodes shaders compile` / `lecodes dev`")}`);
+  if (shaders.length === 0) {
+    log(c.dim("No .mat shaders in this project."));
+  } else {
+    const matcId = matcExe ? matcIdentity(matcExe) : null;
+    log(`shaders         ${c.dim(`(compiled = up-to-date artifacts in ${shadersCacheDir(root)})`)}`);
+    const width = Math.max(...shaders.map((s2) => s2.path.length));
+    for (const shader of shaders) {
+      const state = matcId === null ? c.dim("unknown (matc not downloaded)") : shaderIsCompiled(root, readFileSync23(shader.absPath, "utf8"), matcId) ? "compiled" : c.yellow("not compiled — run `lecodes shaders compile`");
+      log(`  ${shader.path.padEnd(width)}  ${state}`);
+    }
+  }
+  try {
+    const { latest } = await fetchMatcManifest();
+    const newest = installed[0];
+    const hint = !newest ? "" : semverNewer(newest, latest) > 0 ? `   ${c.yellow("(newer — run `lecodes shaders update`)")}` : latest === newest ? `   ${c.dim("(up to date)")}` : "";
+    log(`published       ${latest}${hint}`);
+  } catch (e2) {
+    log(`published       ${c.dim(e2 instanceof CliError ? e2.message : "unknown (couldn't reach the release manifest)")}`);
+  }
+};
+var compile3 = async () => {
+  const { root, entries, shaders } = collectShaders();
+  if (shaders.length === 0) {
+    note("No .mat shaders in this project.");
+    return;
+  }
+  const matcExe = await resolveMatcExe();
+  const matcId = matcIdentity(matcExe);
+  const wasCompiled = new Map(shaders.map((s2) => [s2.path, shaderIsCompiled(root, readFileSync23(s2.absPath, "utf8"), matcId)]));
+  const errors2 = [];
+  for (const shader of shaders) {
+    try {
+      const { warnings } = await applyLocalShaders([shader], { root, local: true });
+      for (const w of warnings)
+        warnErr(w);
+      log(`  ${shader.path}  ${wasCompiled.get(shader.path) ? c.dim("compiled (cached)") : "compiled"}`);
+    } catch (e2) {
+      const message = e2 instanceof CliError ? e2.message : String(e2);
+      log(`  ${shader.path}  ${c.red("FAILED")}`);
+      errors2.push(message);
+    }
+  }
+  for (const e2 of errors2)
+    log(`
+${c.red("✗")} ${e2}`);
+  if (errors2.length > 0)
+    throw new CliError(`${errors2.length} of ${shaders.length} shader${shaders.length === 1 ? "" : "s"} failed to compile.`);
+  note(`${shaders.length} shader${shaders.length === 1 ? "" : "s"} compiled → ${shadersCacheDir(root)}`);
+};
+var shaders = async (args) => {
+  const sub = args._[0];
+  if (sub === undefined)
+    return status2();
+  if (sub === "compile")
+    return compile3();
+  if (sub === "update")
+    return updateMatc();
+  throw new CliError(`Unknown subcommand "shaders ${sub}". Use \`lecodes shaders\` (status), \`lecodes shaders compile\` or \`lecodes shaders update\`.`);
+};
+
 // src/commands/render.ts
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "node:fs";
-import { dirname as dirname15, resolve as resolve12 } from "node:path";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync24, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname15, resolve as resolve13 } from "node:path";
 
 // src/compile/headlessBundle.ts
 init_api();
@@ -221705,10 +222327,10 @@ init_manifest();
 
 // src/desktopScript.ts
 init_util();
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 var isPoint = (v) => typeof v === "object" && v !== null && typeof v.x === "number" && typeof v.y === "number";
 var FRAME_MS = 16;
-var ACTIONS = ["tap", "type", "fill", "scroll", "wait", "frames", "drag", "hold", "key", "keyDown", "keyUp", "camera", "view"];
+var ACTIONS = ["tap", "type", "fill", "scroll", "wait", "frames", "drag", "hold", "key", "keyDown", "keyUp", "look", "mouseTo", "wheel", "stick", "gamepad", "camera", "view"];
 var SEMANTIC_EXPECT = ["text", "notText", "node", "notNode", "screen", "value"];
 var VIEW_NAMES = ["iso", "top", "front", "side", "back"];
 var isVec3 = (v) => Array.isArray(v) && v.length === 3 && v.every((n2) => typeof n2 === "number");
@@ -221821,6 +222443,55 @@ var translateScenario = (rawSteps, opts) => {
       plan.lines.push(emit(`${action.toLowerCase()} ${code}`));
       budgetMs += 2 * FRAME_MS;
       parts.push(`${action} ${code}`);
+    } else if (action === "look") {
+      const v = s2.look;
+      if (!Array.isArray(v) || v.length !== 2 || !v.every((n2) => typeof n2 === "number"))
+        throw new CliError(`${at}: "look" must be [dx, dy] (logical px of mouse motion).`);
+      const ms = num(at, "ms", s2.ms, FRAME_MS);
+      plan.lines.push(emit(`look ${v[0]} ${v[1]} ${Math.round(ms)}`));
+      budgetMs += ms + 2 * FRAME_MS;
+      parts.push(`look ${v[0]},${v[1]} over ${ms}ms`);
+    } else if (action === "mouseTo") {
+      const v = s2.mouseTo;
+      if (!Array.isArray(v) || v.length !== 2 || !v.every((n2) => typeof n2 === "number"))
+        throw new CliError(`${at}: "mouseTo" must be [x, y] (logical px).`);
+      plan.lines.push(emit(`mouseto ${v[0]} ${v[1]}`));
+      budgetMs += FRAME_MS;
+      parts.push(`mouseTo ${v[0]},${v[1]}`);
+    } else if (action === "wheel") {
+      const v = s2.wheel;
+      if (!Array.isArray(v) || v.length !== 2 || !v.every((n2) => typeof n2 === "number"))
+        throw new CliError(`${at}: "wheel" must be [dx, dy] (notches).`);
+      plan.lines.push(emit(`wheel ${v[0]} ${v[1]}`));
+      budgetMs += 2 * FRAME_MS;
+      parts.push(`wheel ${v[0]},${v[1]}`);
+    } else if (action === "stick") {
+      const st = s2.stick;
+      if (typeof st !== "object" || st === null)
+        throw new CliError(`${at}: "stick" must be { left?: [x, y], right?: [x, y], triggers?: [l, r] }.`);
+      const pad = typeof s2.index === "number" ? s2.index : 0;
+      const parts2 = [];
+      for (const k of ["left", "right", "triggers"]) {
+        const v = st[k];
+        if (v === undefined)
+          continue;
+        if (!Array.isArray(v) || v.length !== 2 || !v.every((n2) => typeof n2 === "number"))
+          throw new CliError(`${at}: "stick.${k}" must be a pair of numbers.`);
+        plan.lines.push(emit(`stick ${pad} ${k} ${v[0]} ${v[1]}`));
+        parts2.push(`${k}=${v[0]},${v[1]}`);
+      }
+      for (const k of Object.keys(st))
+        if (!["left", "right", "triggers"].includes(k))
+          throw new CliError(`${at}: "stick" knows left, right, triggers — not "${k}".`);
+      budgetMs += 2 * FRAME_MS;
+      parts.push(`stick #${pad} ${parts2.join(" ")}`);
+    } else if (action === "gamepad") {
+      if (s2.gamepad !== "connect" && s2.gamepad !== "disconnect")
+        throw new CliError(`${at}: "gamepad" must be "connect" or "disconnect".`);
+      const pad = typeof s2.index === "number" ? s2.index : 0;
+      plan.lines.push(emit(`gamepad ${pad} ${s2.gamepad}`));
+      budgetMs += 2 * FRAME_MS;
+      parts.push(`gamepad ${s2.gamepad} #${pad}`);
     } else if (action === "wait") {
       const ms = num(at, "wait", s2.wait);
       plan.lines.push(emit(`wait ${Math.round(ms)}`));
@@ -221857,7 +222528,7 @@ var translateScenario = (rawSteps, opts) => {
     if (s2.screenshot !== undefined) {
       if (typeof s2.screenshot !== "string")
         throw new CliError(`${at}: "screenshot" must be a path.`);
-      plan.screenshot = resolve11(opts.outDir, s2.screenshot);
+      plan.screenshot = resolve12(opts.outDir, s2.screenshot);
       plan.lines.push(emit(`frames 2`));
       plan.lines.push(emit(`shot ${plan.screenshot}`));
       budgetMs += 3 * FRAME_MS;
@@ -221966,9 +222637,9 @@ var requireRenderer = async () => {
 };
 var fileScenarioIO = (dir) => ({
   write: (relPath, data) => {
-    const abs = resolve12(dir, relPath);
-    mkdirSync18(dirname15(abs), { recursive: true });
-    writeFileSync19(abs, data);
+    const abs = resolve13(dir, relPath);
+    mkdirSync20(dirname15(abs), { recursive: true });
+    writeFileSync21(abs, data);
   }
 });
 var resolveFixtures = (value, baseDir) => {
@@ -221976,9 +222647,9 @@ var resolveFixtures = (value, baseDir) => {
     return;
   let map = value;
   if (typeof value === "string") {
-    const abs = resolve12(baseDir, value);
+    const abs = resolve13(baseDir, value);
     try {
-      map = JSON.parse(readFileSync22(abs, "utf8"));
+      map = JSON.parse(readFileSync24(abs, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read fixtures "${value}": ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -221991,7 +222662,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path2) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync22(resolve12(path2), "utf8"));
+    raw = JSON.parse(readFileSync24(resolve13(path2), "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read scenario "${path2}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -222041,13 +222712,13 @@ var renderDesktop = async (args) => {
   if ((camera || view) && scenario)
     throw new CliError('--camera/--view apply to a plain render; in a --script run use a { "view": "iso" } or { "camera": { "at", "lookAt" } } step before the screenshot.');
   const { js, resources } = await buildBundle(args, undefined, { localAssets: true });
-  mkdirSync18(dirname15(resolve12(pngFlag)), { recursive: true });
+  mkdirSync20(dirname15(resolve13(pngFlag)), { recursive: true });
   if (scenario) {
     const outDir = flagStr(args, "out-dir") ?? ".";
     const plan = translateScenario(scenario.steps, { outDir, headroomFrames: frames });
     for (const st of plan.steps)
       if (st.screenshot)
-        mkdirSync18(dirname15(st.screenshot), { recursive: true });
+        mkdirSync20(dirname15(st.screenshot), { recursive: true });
     const timeoutMs2 = Number(flagStr(args, "timeout")) || 60000 + plan.steps.length * 5000;
     note(`Running ${plan.steps.length} step${plan.steps.length === 1 ? "" : "s"} (native)…`);
     const { output } = await runDesktopRender(js, resources, {
@@ -222142,7 +222813,7 @@ var render = async (args) => {
   const settleStr = flagStr(args, "settle") ?? (scenario?.settle !== undefined ? String(scenario.settle) : undefined);
   const timeStr = flagStr(args, "time");
   const onConsole = flagBool(args, "logs") ? (level, text2) => logErr(`${c.dim(`[${level}]`)} ${text2}`) : undefined;
-  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname15(resolve12(scriptFlag)) : ".");
+  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname15(resolve13(scriptFlag)) : ".");
   const flagFixtures = resolveFixtures(flagStr(args, "fixtures"), ".");
   const fixtures = envelopeFixtures || flagFixtures ? { ...envelopeFixtures, ...flagFixtures } : undefined;
   if (fixtures) {
@@ -222181,7 +222852,7 @@ var render = async (args) => {
   ${c.red(st.error ?? "failed")}`);
       }
       if (!result2.ok && result2.failureArtifacts.length > 0) {
-        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p2) => resolve12(outDir, p2)).join(", ")}`));
+        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p2) => resolve13(outDir, p2)).join(", ")}`));
       }
       logErr(result2.ok ? c.green(`✓ ${result2.steps.length}/${steps.length} steps passed`) : c.red(`✗ failed at step ${result2.steps.length} of ${steps.length}`));
       return done((cb) => cb(), result2.ok ? 0 : 1);
@@ -222205,7 +222876,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync19(resolve12(pngFlag), png2);
+      writeFileSync21(resolve13(pngFlag), png2);
       note(`Wrote ${pngFlag} (${png2.length} bytes, ${outW}x${outH}${clip !== undefined ? ", clipped" : ""})`);
     }
     return done((cb) => cb());
@@ -222220,7 +222891,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync19(resolve12(out), result.text);
+    writeFileSync21(resolve13(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -222235,8 +222906,8 @@ init_api();
 init_config();
 init_manifest();
 init_util();
-import { appendFileSync as appendFileSync2, existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join24 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync27, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "node:fs";
+import { join as join28 } from "node:path";
 var ENV_VAR = "LECODES_PUSH_KEY";
 var context = () => {
   const root = findProjectRoot(process.cwd());
@@ -222380,11 +223051,11 @@ var pnKeysList = async (ctx) => {
 };
 var writeEnv = (root, key) => {
   const touched = [];
-  const envPath = join24(root, ".env");
+  const envPath = join28(root, ".env");
   const line = `${ENV_VAR}=${key}`;
-  const existing = existsSync24(envPath) ? readFileSync23(envPath, "utf8") : "";
+  const existing = existsSync27(envPath) ? readFileSync25(envPath, "utf8") : "";
   if (new RegExp(`^${ENV_VAR}=`, "m").test(existing)) {
-    writeFileSync20(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
+    writeFileSync22(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
   } else {
     const separator = !existing || existing.endsWith(`
 `) ? "" : `
@@ -222393,8 +223064,8 @@ var writeEnv = (root, key) => {
 `);
   }
   touched.push(".env");
-  const ignorePath = join24(root, ".gitignore");
-  const ignore = existsSync24(ignorePath) ? readFileSync23(ignorePath, "utf8") : "";
+  const ignorePath = join28(root, ".gitignore");
+  const ignore = existsSync27(ignorePath) ? readFileSync25(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l2) => l2.trim() === ".env")) {
     const separator = !ignore || ignore.endsWith(`
@@ -222493,8 +223164,8 @@ var pn = async (args) => {
 init_api();
 init_config();
 init_manifest();
-import { existsSync as existsSync25, mkdirSync as mkdirSync19, rmSync as rmSync6, writeFileSync as writeFileSync21 } from "node:fs";
-import { dirname as dirname16, join as join25 } from "node:path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync21, rmSync as rmSync8, writeFileSync as writeFileSync23 } from "node:fs";
+import { dirname as dirname16, join as join29 } from "node:path";
 init_types4();
 init_localFiles();
 init_util();
@@ -222517,9 +223188,9 @@ var pull = async (args) => {
   const remotePaths = new Set([...buildPaths(project.assets).entries()].filter(([id]) => project.assets.find((a2) => a2.id === id)?.type !== "folder").map(([, path2]) => path2));
   for (const path2 of Object.keys(manifest.files)) {
     if (!remotePaths.has(path2)) {
-      const abs = join25(root, ...path2.replace(/^\//, "").split("/"));
-      if (existsSync25(abs))
-        rmSync6(abs);
+      const abs = join29(root, ...path2.replace(/^\//, "").split("/"));
+      if (existsSync28(abs))
+        rmSync8(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -222556,18 +223227,18 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
   const files = { ...manifest.files };
   for (const asset of targets) {
     const key = pathById.get(asset.id);
-    const abs = join25(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync19(dirname16(abs), { recursive: true });
+    const abs = join29(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync21(dirname16(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync21(abs, bytes);
+      writeFileSync23(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync21(abs, text);
+      writeFileSync23(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf3(asset.type), sha };
@@ -222580,8 +223251,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/scene.ts
 init_manifest();
-import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync12, statSync as statSync8, writeFileSync as writeFileSync22 } from "node:fs";
-import { basename as basename14, dirname as dirname17, join as join27, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync27, readdirSync as readdirSync13, statSync as statSync9, writeFileSync as writeFileSync24 } from "node:fs";
+import { basename as basename15, dirname as dirname17, join as join31, resolve as resolve14 } from "node:path";
 
 // src/compile/sceneCompile.ts
 init_localFiles();
@@ -222589,18 +223260,18 @@ init_ignore();
 init_distRoot();
 init_util();
 init_projectCompile();
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync26 } from "node:fs";
+import { join as join30 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join26(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join30(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync26(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync29(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join26(distRoot, "runtime", "scene-harness.json");
-    if (existsSync26(vendored))
-      return JSON.parse(readFileSync24(vendored, "utf8"));
+    const vendored = join30(distRoot, "runtime", "scene-harness.json");
+    if (existsSync29(vendored))
+      return JSON.parse(readFileSync26(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
 };
@@ -222612,7 +223283,7 @@ var compileSceneEditor = async (opts) => {
   for (const file of scan2.files) {
     const path2 = "./" + rel(file.path);
     if (TEXT_EXT.test(path2)) {
-      entries.push({ path: path2, type: "text", text: readFileSync24(file.absPath, "utf8") });
+      entries.push({ path: path2, type: "text", text: readFileSync26(file.absPath, "utf8") });
     } else {
       entries.push({ path: path2, type: "resource", fileSrc: "/project/" + rel(file.path) });
     }
@@ -222643,6 +223314,17 @@ var compileSceneEditor = async (opts) => {
 init_browserAuth();
 init_util();
 var DEFAULT_PORT3 = 4488;
+var findAppRoot = (start) => {
+  let dir = start;
+  while (true) {
+    if (existsSync30(join31(dir, "app.json")))
+      return dir;
+    const parent = dirname17(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+};
 var getContext2 = (args) => {
   let root;
   let manifest;
@@ -222654,24 +223336,26 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve13(process.cwd(), pathArg);
-      if (existsSync27(abs) && statSync8(abs).isDirectory())
+      const abs = resolve14(process.cwd(), pathArg);
+      if (existsSync30(abs) && statSync9(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync27(abs))
-        root = dirname17(abs);
+      else if (abs.endsWith(".scene.ts") && existsSync30(abs))
+        root = findAppRoot(dirname17(abs)) ?? dirname17(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
+    } else {
+      root = findAppRoot(root) ?? root;
     }
   }
-  return { root, manifest, name: manifest?.name ?? basename14(root) };
+  return { root, manifest, name: manifest?.name ?? basename15(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path2 = join27(root, ".mcp.json");
+  const path2 = join31(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync27(path2)) {
+  if (existsSync30(path2)) {
     try {
-      config = JSON.parse(readFileSync25(path2, "utf8"));
+      config = JSON.parse(readFileSync27(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -222684,17 +223368,17 @@ var writeMcpConfig2 = (root, port) => {
     return;
   }
   config.mcpServers["lecodes-scene"] = entry;
-  writeFileSync22(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync24(path2, JSON.stringify(config, null, 2) + `
 `);
   note(`${existing ? "updated" : "created"}   .mcp.json (lecodes-scene MCP → ${entry.url})`);
 };
 var countScenes = (dir) => {
   let n2 = 0;
-  for (const name of readdirSync12(dir)) {
+  for (const name of readdirSync13(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join27(dir, name);
-    if (statSync8(full).isDirectory())
+    const full = join31(dir, name);
+    if (statSync9(full).isDirectory())
       n2 += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n2++;
@@ -222753,7 +223437,7 @@ var assets = async (args) => {
 init_manifest();
 init_localFiles();
 init_util();
-var status2 = async (_args) => {
+var status3 = async (_args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
   const scan2 = scanProject(root, manifest);
@@ -222782,8 +223466,8 @@ var status2 = async (_args) => {
 };
 
 // src/commands/test.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync20, readFileSync as readFileSync26, readdirSync as readdirSync13 } from "node:fs";
-import { dirname as dirname18, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync22, readFileSync as readFileSync28, readdirSync as readdirSync14 } from "node:fs";
+import { dirname as dirname18, resolve as resolve15 } from "node:path";
 init_manifest();
 init_util();
 var deriveDesignFlows = (meta, entryScreen) => {
@@ -222846,7 +223530,7 @@ var slug3 = (s2) => s2.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").
 var readFlowFile = (abs, displayName) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync26(abs, "utf8"));
+    raw = JSON.parse(readFileSync28(abs, "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read "${displayName}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -222894,40 +223578,40 @@ var test = async (args) => {
   if (!Number.isFinite(nativeFixedDt) || nativeFixedDt < 0 || nativeFixedDt > 1000)
     throw new CliError(`--fixed-dt wants a number of ms (0 = wall clock, max 1000), got "${fixedDtFlag}".`);
   const projectViewport = desktopDefaultViewport(root);
-  const testsDir = resolve14(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve14(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve15(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve15(root, flagStr(args, "design-dir") ?? "design", "meta.json");
   const asJson = flagBool(args, "json");
   const out = asJson ? logErr : log;
   const cases = [];
   if (args._.length > 0) {
     for (const given of args._) {
-      const candidates = [resolve14(given), resolve14(testsDir, given), resolve14(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p2) => existsSync28(p2));
+      const candidates = [resolve15(given), resolve15(testsDir, given), resolve15(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p2) => existsSync31(p2));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync28(testsDir)) {
-    for (const f3 of readdirSync13(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve14(testsDir, f3), f3));
+  } else if (existsSync31(testsDir)) {
+    for (const f3 of readdirSync14(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve15(testsDir, f3), f3));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve14(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync28(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve15(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync31(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
   const flowsOnly = flagBool(args, "flows");
   const wantFlows = !flagBool(args, "no-flows") && args._.length === 0;
   if (flowsOnly)
     cases.length = 0;
   let skipped = [];
   let entryScreen = null;
-  if (desktop2 && wantFlows && existsSync28(designMetaPath)) {
+  if (desktop2 && wantFlows && existsSync31(designMetaPath)) {
     note("Design-derived flows skipped with --desktop (they tap by name; run `lecodes test` headless for them).");
   }
-  if (!desktop2 && (wantFlows || flowsOnly) && existsSync28(designMetaPath)) {
+  if (!desktop2 && (wantFlows || flowsOnly) && existsSync31(designMetaPath)) {
     let meta;
     try {
-      meta = JSON.parse(readFileSync26(designMetaPath, "utf8"));
+      meta = JSON.parse(readFileSync28(designMetaPath, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read ${designMetaPath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -222959,16 +223643,16 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve14(root, flagStr(args, "artifacts") ?? resolve14(testsDir, ".artifacts"));
+  const artifactsRoot = resolve15(root, flagStr(args, "artifacts") ?? resolve15(testsDir, ".artifacts"));
   const results = [];
   const runNativeCase = async (kase) => {
-    const caseDir = resolve14(artifactsRoot, slug3(kase.name));
+    const caseDir = resolve15(artifactsRoot, slug3(kase.name));
     const plan = translateScenario(kase.steps, { outDir: caseDir, headroomFrames: nativeFrames });
     for (const st of plan.steps)
       if (st.screenshot)
-        mkdirSync20(dirname18(st.screenshot), { recursive: true });
-    mkdirSync20(caseDir, { recursive: true });
-    const finalPng = resolve14(caseDir, "final.png");
+        mkdirSync22(dirname18(st.screenshot), { recursive: true });
+    mkdirSync22(caseDir, { recursive: true });
+    const finalPng = resolve15(caseDir, "final.png");
     const { output } = await runDesktopRender(native.js, native.resources, {
       width: Number(flagStr(args, "width")) || kase.width || projectViewport?.width || 390,
       height: Number(flagStr(args, "height")) || kase.height || projectViewport?.height || 844,
@@ -223019,14 +223703,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve14(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve15(artifactsRoot, slug3(kase.name)));
         const outcome = await renderer.runScenario(session, steps, io);
         result = {
           name: kase.name,
           kind: kase.kind,
           ok: outcome.ok,
           steps: outcome.steps.map((s2) => ({ desc: s2.desc, ok: s2.ok, error: s2.error })),
-          artifacts: outcome.failureArtifacts.map((p2) => resolve14(artifactsRoot, slug3(kase.name), p2))
+          artifacts: outcome.failureArtifacts.map((p2) => resolve15(artifactsRoot, slug3(kase.name), p2))
         };
       } finally {
         session.dispose();
@@ -223094,11 +223778,11 @@ init_config();
 init_manifest();
 init_types4();
 init_util();
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
 var types4 = async (args) => {
   const dirArg = args._[0];
-  const root = dirArg ? resolve15(dirArg) : (() => {
+  const root = dirArg ? resolve16(dirArg) : (() => {
     try {
       return findProjectRoot(process.cwd());
     } catch {
@@ -223157,23 +223841,23 @@ var types4 = async (args) => {
 };
 
 // src/index.ts
-import { existsSync as existsSync30, readFileSync as readFileSync28, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync33, readFileSync as readFileSync30, realpathSync as realpathSync2 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname20, join as join29 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname20, join as join33 } from "node:path";
 
 // src/commands/install.ts
 init_util();
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync4, existsSync as existsSync29, mkdirSync as mkdirSync21, readFileSync as readFileSync27, realpathSync, rmSync as rmSync7, symlinkSync } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { basename as basename15, delimiter, dirname as dirname19, join as join28, resolve as resolve16, sep as sep2 } from "node:path";
+import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync4, existsSync as existsSync32, mkdirSync as mkdirSync23, readFileSync as readFileSync29, realpathSync, rmSync as rmSync9, symlinkSync } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename16, delimiter, dirname as dirname19, join as join32, resolve as resolve17, sep as sep2 } from "node:path";
 var isWin = process.platform === "win32";
-var HOME = homedir7();
+var HOME = homedir8();
 var safeRealpath = (p2) => {
   try {
     return realpathSync(p2);
   } catch {
-    return resolve16(p2);
+    return resolve17(p2);
   }
 };
 var onPath = (dir) => {
@@ -223190,24 +223874,24 @@ var onPath = (dir) => {
 };
 var install = async (args) => {
   const bundle = dirname19(process.execPath);
-  const exeName2 = basename15(process.execPath);
+  const exeName2 = basename16(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync29(join28(bundle, "runtime")) || !existsSync29(join28(bundle, chiselName))) {
+  if (!existsSync32(join32(bundle, "runtime")) || !existsSync32(join32(bundle, chiselName))) {
     throw new CliError("`lecodes install` only works from the packaged release build (the archive containing lecodes + " + "chisel + runtime/). You appear to be running from source or an npm install — install globally " + "with your package manager there instead.");
   }
-  const companions = [exeName2, chiselName, "runtime", "README.txt"].filter((f3) => existsSync29(join28(bundle, f3)));
+  const companions = [exeName2, chiselName, "runtime", "README.txt"].filter((f3) => existsSync32(join32(bundle, f3)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
 };
 var copyBundle = (bundle, target, companions) => {
-  mkdirSync21(target, { recursive: true });
+  mkdirSync23(target, { recursive: true });
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f3 of companions) {
-    const dest = join28(target, f3);
-    rmSync7(dest, { recursive: true, force: true });
-    cpSync4(join28(bundle, f3), dest, { recursive: true });
+    const dest = join32(target, f3);
+    rmSync9(dest, { recursive: true, force: true });
+    cpSync4(join32(bundle, f3), dest, { recursive: true });
   }
 };
 var permError = (e2, dir, system) => {
@@ -223219,41 +223903,41 @@ var permError = (e2, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  const libDir = resolve16(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join28(HOME, ".local", "lib", "lecodes-cli")));
-  const binDir = resolve16(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join28(HOME, ".local", "bin")));
-  const link2 = join28(binDir, "lecodes");
+  const libDir = resolve17(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join32(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve17(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join32(HOME, ".local", "bin")));
+  const link2 = join32(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync2(join28(libDir, "lecodes"), 493);
-    chmodSync2(join28(libDir, "chisel"), 493);
+    chmodSync2(join32(libDir, "lecodes"), 493);
+    chmodSync2(join32(libDir, "chisel"), 493);
   } catch (e2) {
     throw permError(e2, libDir, system);
   }
   try {
-    mkdirSync21(binDir, { recursive: true });
-    rmSync7(link2, { force: true });
-    symlinkSync(join28(libDir, "lecodes"), link2);
+    mkdirSync23(binDir, { recursive: true });
+    rmSync9(link2, { force: true });
+    symlinkSync(join32(libDir, "lecodes"), link2);
   } catch (e2) {
     throw permError(e2, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link2 + " → " + join28(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join32(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
-  const shell = basename15(process.env.SHELL ?? "");
+  const shell = basename16(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join28(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join32(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join28(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join28(HOME, ".profile"), name: "~/.profile" };
+    return { file: join32(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join32(HOME, ".profile"), name: "~/.profile" };
 };
 var PATH_MARKER = "# Added by `lecodes install`";
 var appendPathToShellRc = (binDir) => {
   const { file, name } = shellRc();
   const line = `export PATH="${binDir}:$PATH"`;
   try {
-    const existing = existsSync29(file) ? readFileSync27(file, "utf8") : "";
+    const existing = existsSync32(file) ? readFileSync29(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -223291,7 +223975,7 @@ var finishPathUnix = (args, binDir) => {
   log(`  • or install system-wide (no PATH edit): ${c.bold("sudo lecodes install --system")}`);
 };
 var installWindows = (args, bundle, companions) => {
-  const target = resolve16(flagStr(args, "dir") ?? join28(process.env.LOCALAPPDATA ?? join28(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve17(flagStr(args, "dir") ?? join32(process.env.LOCALAPPDATA ?? join32(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e2) {
@@ -223331,7 +224015,7 @@ init_util();
 var STANDALONE = (() => {
   const dir = dirname20(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync30(join29(dir, "runtime")) && existsSync30(join29(dir, chisel));
+  return existsSync33(join33(dir, "runtime")) && existsSync33(join33(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -223346,8 +224030,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join29(d, exe);
-      return existsSync30(cand) && realpathSync2(cand) === self2;
+      const cand = join33(d, exe);
+      return existsSync33(cand) && realpathSync2(cand) === self2;
     } catch {
       return false;
     }
@@ -223535,6 +224219,12 @@ ${c.bold("Commands:")}
                                           --public-url <url> uses the server's copies instead)
                                   update  move to the newest published release
                                           (cached in ~/.lecodes/renderer)
+  shaders [compile|update]      The project's custom shaders (.mat) and their local compile:
+                                  no args lists the shaders + their compile state; compile
+                                  compiles them all into .lecodes/shaders (the same pass
+                                  'lecodes dev' runs on the fly — via Filament's matc,
+                                  downloaded on first use to ~/.lecodes/matc); update
+                                  downloads the newest matc (run after an engine upgrade)
   scene [path]                  LeCodes Scene Editor — visually edit a .scene.ts (tree, inspector,
                                   gizmo) on local files (needs the optional 'lecodes-3d-editor' package;
                                   works inside a cloned project or standalone in any folder)
@@ -223633,7 +224323,7 @@ ${c.bold("Commands:")}
                                   — 'new --env' banks it in .env), revoke <id>
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { init: init2, login, create, clone: clone3, link, status: status2, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn, desktop, assets };
+var commands = { init: init2, login, create, clone: clone3, link, status: status3, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn, desktop, shaders, assets };
 if (STANDALONE)
   commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
@@ -223648,9 +224338,9 @@ var peerVersion = (name, probe) => {
     const require2 = createRequire4(import.meta.url);
     let dir = dirname20(require2.resolve(probe));
     for (let depth = 0;depth < 16; depth++) {
-      const manifest = join29(dir, "package.json");
-      if (existsSync30(manifest)) {
-        const parsed = JSON.parse(readFileSync28(manifest, "utf8"));
+      const manifest = join33(dir, "package.json");
+      if (existsSync33(manifest)) {
+        const parsed = JSON.parse(readFileSync30(manifest, "utf8"));
         if (parsed.name === name)
           return parsed.version ?? "unknown";
       }
@@ -223670,6 +224360,8 @@ var printVersion = () => {
   }
   const desktopVersion = selectedDesktopVersion();
   rows.push(["lecodes-desktop", installedDesktopVersions().includes(desktopVersion) ? desktopVersion : `${desktopVersion} ${c.dim("(not downloaded — fetched on first `render --desktop`)")}`]);
+  const matcVersion = installedMatcVersions()[0];
+  rows.push(["matc", matcVersion ?? c.dim("not downloaded — fetched on the first local shader compile")]);
   const width = Math.max(...rows.map(([label2]) => label2.length));
   for (const [label2, value] of rows)
     log(`${label2.padEnd(width)}  ${value}`);