lecodes-cli 0.18.0 → 0.18.1

package/dist/index.js

@@ -418,7 +418,7 @@ node_modules/
   return "updated";
 };
 var init_ignore = __esm(() => {
-  BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/"];
+  BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/"];
 });
 
 // src/localFiles.ts
@@ -564,45 +564,212 @@ var init_distRoot = __esm(() => {
 });
 
 // ../sdk/src/compile/assetMacro.ts
-var ASSET_RE, hasAssetMacro = (src) => src.includes("asset("), desugarAssetMacros = (src, filePath) => {
-  const byPath = new Map;
+var ASSET_RE, ASSET_CALL_RE, hasAssetMacro = (src) => src.includes("asset("), maskNonCode = (src) => {
+  const out = src.split("");
+  const blank = (from, to) => {
+    for (let k = from;k < to && k < out.length; k++)
+      if (out[k] !== `
+`)
+        out[k] = " ";
+  };
+  const tpl = [];
+  let braces = 0;
   let i = 0;
-  const out = src.replace(ASSET_RE, (_match, _quote, path) => {
-    let name = byPath.get(path);
-    if (!name) {
-      name = `__asset_${i++}`;
-      byPath.set(path, name);
+  const scanTemplate = () => {
+    const start = i;
+    while (i < src.length) {
+      const c2 = src[i];
+      if (c2 === "\\") {
+        i += 2;
+        continue;
+      }
+      if (c2 === "`") {
+        blank(start, i);
+        i++;
+        return;
+      }
+      if (c2 === "$" && src[i + 1] === "{") {
+        blank(start, i);
+        tpl.push(braces);
+        i += 2;
+        return;
+      }
+      i++;
     }
-    return name;
-  });
-  if (/(?<![.\w$])asset\(/.test(out)) {
-    throw new Error(`asset() expects a string literal, found a dynamic argument in: ${filePath}`);
+    blank(start, i);
+  };
+  while (i < src.length) {
+    const c2 = src[i], d = src[i + 1];
+    if (c2 === "/" && d === "/") {
+      const e = src.indexOf(`
+`, i);
+      const stop = e === -1 ? src.length : e;
+      blank(i, stop);
+      i = stop;
+      continue;
+    }
+    if (c2 === "/" && d === "*") {
+      const e = src.indexOf("*/", i + 2);
+      const stop = e === -1 ? src.length : e + 2;
+      blank(i, stop);
+      i = stop;
+      continue;
+    }
+    if (c2 === "'" || c2 === '"') {
+      const start = i;
+      i++;
+      while (i < src.length) {
+        const q = src[i];
+        if (q === "\\") {
+          i += 2;
+          continue;
+        }
+        i++;
+        if (q === c2 || q === `
+`)
+          break;
+      }
+      blank(start, i);
+      continue;
+    }
+    if (c2 === "`") {
+      i++;
+      scanTemplate();
+      continue;
+    }
+    if (c2 === "{") {
+      braces++;
+      i++;
+      continue;
+    }
+    if (c2 === "}") {
+      if (tpl.length > 0 && braces === tpl[tpl.length - 1]) {
+        tpl.pop();
+        i++;
+        scanTemplate();
+        continue;
+      }
+      if (braces > 0)
+        braces--;
+      i++;
+      continue;
+    }
+    i++;
   }
-  if (byPath.size === 0)
+  return out.join("");
+}, collectAssetMacros = (src, filePath) => {
+  const mask = maskNonCode(src);
+  const refs = [];
+  const literal = new Set;
+  let scanned = 0;
+  let line = 1;
+  for (const m of src.matchAll(ASSET_RE)) {
+    const index = m.index ?? 0;
+    if (mask[index] !== "a")
+      continue;
+    for (;scanned < index; scanned++)
+      if (src[scanned] === `
+`)
+        line++;
+    refs.push({ path: m[2], index, length: m[0].length, line });
+    literal.add(index);
+  }
+  for (const m of src.matchAll(ASSET_CALL_RE)) {
+    const index = m.index ?? 0;
+    if (mask[index] === "a" && !literal.has(index)) {
+      throw new Error(`asset() expects a string literal, found a dynamic argument in: ${filePath}`);
+    }
+  }
+  return refs;
+}, desugarAssetMacros = (src, filePath, found) => {
+  const refs = found ?? collectAssetMacros(src, filePath);
+  if (refs.length === 0)
     return src;
+  const byPath = new Map;
+  const parts = [];
+  let at = 0;
+  for (const ref of refs) {
+    let name = byPath.get(ref.path);
+    if (!name) {
+      name = `__asset_${byPath.size}`;
+      byPath.set(ref.path, name);
+    }
+    parts.push(src.slice(at, ref.index), name);
+    at = ref.index + ref.length;
+  }
+  parts.push(src.slice(at));
   const imports = [...byPath].map(([path, name]) => `import ${name} from ${JSON.stringify(path)};`).join(`
 `);
-  return out + `
+  return parts.join("") + `
 ` + imports;
 };
 var init_assetMacro = __esm(() => {
   ASSET_RE = /(?<![.\w$])asset\(\s*(["'])((?:[^"'\\]|\\.)*)\1\s*\)/g;
+  ASSET_CALL_RE = /(?<![.\w$])asset\(/g;
 });
 
 // ../sdk/src/compile/aspectMacro.ts
-var ASPECT_RE, hasAspectExtends = (src) => /\bextends\s+Aspect\s*</.test(src), injectAspectNames = (src) => {
+var HEAD_RE, hasAspectExtends = (src) => /\bextends\s+(?:Aspect|System)\s*</.test(src), injectAspectNames = (src) => {
   let out = "";
   let last = 0;
-  ASPECT_RE.lastIndex = 0;
+  HEAD_RE.lastIndex = 0;
   let m;
-  while ((m = ASPECT_RE.exec(src)) !== null) {
-    const braceEnd = m.index + m[0].length;
+  while ((m = HEAD_RE.exec(src)) !== null) {
+    const braceEnd = classBodyStart(src, m.index + m[0].length);
+    if (braceEnd < 0)
+      continue;
+    HEAD_RE.lastIndex = braceEnd;
     if (!classBodyDeclaresAspect(src, braceEnd)) {
       out += src.slice(last, braceEnd) + ` static aspect = ${JSON.stringify(m[2])};`;
       last = braceEnd;
     }
   }
   return last === 0 ? src : out + src.slice(last);
+}, classBodyStart = (src, from) => {
+  let angle = 1;
+  let i = from;
+  for (;i < src.length && angle > 0; i++) {
+    const c2 = src[i];
+    if (c2 === '"' || c2 === "'" || c2 === "`") {
+      i = skipString(src, i) - 1;
+      continue;
+    }
+    if (c2 === "=" && src[i + 1] === ">") {
+      i++;
+      continue;
+    }
+    if (c2 === "<")
+      angle++;
+    else if (c2 === ">")
+      angle--;
+  }
+  if (angle !== 0)
+    return -1;
+  angle = 0;
+  for (;i < src.length; i++) {
+    const c2 = src[i];
+    if (c2 === "<")
+      angle++;
+    else if (c2 === ">")
+      angle--;
+    else if (c2 === "{" && angle === 0)
+      return i + 1;
+    else if (c2 === ";" || c2 === "}")
+      return -1;
+  }
+  return -1;
+}, skipString = (src, at) => {
+  const q = src[at];
+  let i = at + 1;
+  for (;i < src.length; i++) {
+    if (src[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (src[i] === q)
+      return i + 1;
+  }
+  return i;
 }, classBodyDeclaresAspect = (src, from) => {
   let depth = 1;
   let i = from;
@@ -616,7 +783,7 @@ var ASPECT_RE, hasAspectExtends = (src) => /\bextends\s+Aspect\s*</.test(src), i
   return /\bstatic\b[^;{}()=]*\baspect\b/.test(src.slice(from, i));
 };
 var init_aspectMacro = __esm(() => {
-  ASPECT_RE = /\bclass\s+\w+\s+extends\s+Aspect\s*<\s*(["'])((?:[^"'\\]|\\.)*)\1[^{};]*>\s*\{/g;
+  HEAD_RE = /\bclass\s+\w+\s+extends\s+(?:Aspect|System)\s*<\s*(["'])((?:[^"'\\]|\\.)*)\1/g;
 });
 
 // ../sdk/src/compile/libraryImports.ts
@@ -723,18 +890,37 @@ var resolveInject = () => {
   } catch {
     return null;
   }
+}, assertAssetsExist = (refs, files) => {
+  const missing = [];
+  for (const { file, ref } of refs) {
+    if (!ref.path.startsWith("./") && !ref.path.startsWith("../") && !ref.path.startsWith("/"))
+      continue;
+    const dir = file.slice(0, file.lastIndexOf("/"));
+    const base = ref.path.startsWith("/") ? normalize(ref.path) : normalize(`${dir}/${ref.path}`);
+    const found = [base, `${base}.ts`, `${base}.js`, `${base}/index.ts`].some((c2) => files[c2] !== undefined);
+    if (!found)
+      missing.push(`asset not found: ${ref.path} (${file.replace(/^\//, "")}:${ref.line})`);
+  }
+  if (missing.length > 0)
+    throw new Error(missing.join(`
+`));
 }, bundleProjectChisel = async (entrypoint, files, format, sourcemap, minifyOverride, editor, libraries, inject = CLIENT_INJECT) => {
   const entry = normalize(entrypoint);
   const slugs = new Set(Object.keys(libraries ?? {}));
   const projFiles = {};
+  const assetRefs = [];
   for (const [k, v] of Object.entries(files)) {
     const path = normalize(k);
     let src = v;
     if (/\.[tj]sx?$/.test(path)) {
       if (hasImportStatement(src))
         src = rewriteLibraryImports(src, slugs);
-      if (hasAssetMacro(src))
-        src = desugarAssetMacros(src, path);
+      if (hasAssetMacro(src)) {
+        const found = collectAssetMacros(src, path);
+        for (const ref of found)
+          assetRefs.push({ file: path, ref });
+        src = desugarAssetMacros(src, path, found);
+      }
       if (hasAspectExtends(src))
         src = injectAspectNames(src);
     }
@@ -747,14 +933,19 @@ var resolveInject = () => {
       const path = normalize(`/__lib/${slug}/${k}`);
       let src = v;
       if (/\.[tj]sx?$/.test(path)) {
-        if (hasAssetMacro(src))
-          src = desugarAssetMacros(src, path);
+        if (hasAssetMacro(src)) {
+          const found = collectAssetMacros(src, path);
+          for (const ref of found)
+            assetRefs.push({ file: path, ref });
+          src = desugarAssetMacros(src, path, found);
+        }
         if (hasAspectExtends(src))
           src = injectAspectNames(src);
       }
       projFiles[path] = src;
     }
   }
+  assertAssetsExist(assetRefs, projFiles);
   const sdkFiles = collectSdkFiles(resolveSdkSrc());
   const minify = minifyOverride ?? process.env.LECODES_CHISEL_MINIFY !== "0";
   const input = JSON.stringify({
@@ -98214,23 +98405,23 @@ ${lanes.join(`
         const call = cast(aliasAssignment ? skipOuterExpressions(aliasAssignment.right) : initializer, isCallExpression);
         const func = cast(skipOuterExpressions(call.expression), isFunctionExpression);
         const funcStatements = func.body.statements;
-        let classBodyStart = 0;
+        let classBodyStart2 = 0;
         let classBodyEnd = -1;
         const statements = [];
         if (aliasAssignment) {
-          const extendsCall = tryCast(funcStatements[classBodyStart], isExpressionStatement);
+          const extendsCall = tryCast(funcStatements[classBodyStart2], isExpressionStatement);
           if (extendsCall) {
             statements.push(extendsCall);
-            classBodyStart++;
+            classBodyStart2++;
           }
-          statements.push(funcStatements[classBodyStart]);
-          classBodyStart++;
+          statements.push(funcStatements[classBodyStart2]);
+          classBodyStart2++;
           statements.push(factory2.createExpressionStatement(factory2.createAssignment(aliasAssignment.left, cast(variable.name, isIdentifier))));
         }
         while (!isReturnStatement(elementAt(funcStatements, classBodyEnd))) {
           classBodyEnd--;
         }
-        addRange(statements, funcStatements, classBodyStart, classBodyEnd);
+        addRange(statements, funcStatements, classBodyStart2, classBodyEnd);
         if (classBodyEnd < -1) {
           addRange(statements, funcStatements, classBodyEnd + 1);
         }
@@ -171460,11 +171651,11 @@ var init_detectEntry = __esm(() => {
 });
 
 // ../sdk/src/compile/shaderTargets.ts
-var externalSamplerReg, PLATFORM_BUILD, matcPlatformsFor = (text) => {
+var externalSamplerReg, PLATFORM_BUILD, LOCAL_PLATFORM_BUILD, ALL_PLATFORM_BUILD, LOCAL_ONLY_PLATFORMS, TARGET_MATRIX_GENERATION = 1, matcPlatformsFor = (text) => {
   externalSamplerReg.lastIndex = 0;
   return externalSamplerReg.test(text) ? ["opengl", "metal", "webgl", "desktop"] : ["opengl", "metal", "desktop"];
 }, matcArgs = (platform, outPath, inPath) => {
-  const build = PLATFORM_BUILD[platform];
+  const build = ALL_PLATFORM_BUILD[platform];
   return ["-p", build.profile, "--no-essl1", "-a", build.api, "-o", outPath, inPath];
 };
 var init_shaderTargets = __esm(() => {
@@ -171475,6 +171666,11 @@ var init_shaderTargets = __esm(() => {
     webgl: { profile: "mobile", api: "opengl", replaceExternal: true },
     desktop: { profile: "desktop", api: "opengl", replaceExternal: true }
   };
+  LOCAL_PLATFORM_BUILD = {
+    "desktop-vulkan": { profile: "desktop", api: "vulkan", replaceExternal: true }
+  };
+  ALL_PLATFORM_BUILD = { ...PLATFORM_BUILD, ...LOCAL_PLATFORM_BUILD };
+  LOCAL_ONLY_PLATFORMS = ["desktop-vulkan"];
 });
 
 // ../sdk/src/compile/liteMaterial.ts
@@ -171717,6 +171913,191 @@ var init_liteMaterial = __esm(() => {
   SAMPLER_TYPES = new Set(["sampler2d", "samplerExternal"]);
 });
 
+// ../sdk/src/compile/shaderSchema.ts
+var SAMPLER_TYPES2, COLOR_NAME, zeroFor = (type, editor) => {
+  switch (editor) {
+    case "number":
+      return 0;
+    case "int":
+      return 0;
+    case "switch":
+      return false;
+    case "vec2":
+      return [0, 0];
+    case "vec3":
+      return [0, 0, 0];
+    case "vec4":
+      return [0, 0, 0, 0];
+    case "color":
+      return type === "float4" ? "#ffffffff" : "#ffffff";
+    case "texture":
+      return null;
+    default:
+      return null;
+  }
+}, parseDefault = (raw, editor) => {
+  const s = raw.trim();
+  if (s === "true")
+    return true;
+  if (s === "false")
+    return false;
+  if (/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(s))
+    return s.toLowerCase();
+  if (/^-?\d+(\.\d+)?$/.test(s))
+    return editor === "switch" ? Number(s) !== 0 : Number(s);
+  const arr = /^\[(.*)\]$/.exec(s);
+  if (arr) {
+    const nums = arr[1].split(",").map((p) => Number(p.trim()));
+    if (nums.length > 0 && nums.every((n) => Number.isFinite(n)))
+      return nums;
+  }
+  return;
+}, parseAnnotation = (comment) => {
+  const out = { tooltip: "", errors: [] };
+  let rest = comment;
+  rest = rest.replace(/@(color|vec)\b/g, (_m, tag) => {
+    out[tag] = true;
+    return " ";
+  });
+  rest = rest.replace(/@(range|step|default)\s*\(([^)]*)\)/g, (_m, tag, body) => {
+    if (tag === "range") {
+      const parts = body.split(",").map((p) => Number(p.trim()));
+      if (parts.length === 2 && parts.every((n) => Number.isFinite(n)))
+        out.range = [parts[0], parts[1]];
+      else
+        out.errors.push(`@range expects two numbers, got "${body.trim()}"`);
+    } else if (tag === "step") {
+      const n = Number(body.trim());
+      if (Number.isFinite(n) && n > 0)
+        out.step = n;
+      else
+        out.errors.push(`@step expects a positive number, got "${body.trim()}"`);
+    } else {
+      out.default = body;
+    }
+    return " ";
+  });
+  rest = rest.replace(/@\w+(\([^)]*\))?/g, " ");
+  out.tooltip = rest.replace(/\s+/g, " ").trim();
+  return out;
+}, collectComments = (materialBlock) => {
+  const out = new Map;
+  const start = materialBlock.search(/\bparameters\s*[:=]/);
+  if (start < 0)
+    return out;
+  const lines = materialBlock.slice(start).split(`
+`);
+  let above = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const name = /\bname\s*[:=]\s*"?([A-Za-z_]\w*)"?/.exec(line)?.[1];
+    if (name) {
+      const trailing = /\}[^/\n]*\/\/(.*)$/.exec(line)?.[1] ?? /\/\/(.*)$/.exec(line.slice(line.indexOf("}") + 1))?.[1];
+      const text = trailing !== undefined ? trailing : above.join(" ");
+      if (text.trim() !== "")
+        out.set(name, text.trim());
+      above = [];
+    } else if (trimmed.startsWith("//")) {
+      above.push(trimmed.slice(2).trim());
+    } else if (trimmed !== "" && trimmed !== "[" && trimmed !== "],") {
+      above = [];
+    }
+  }
+  return out;
+}, parseShaderSchema = (text) => {
+  const schema = { name: "", shadingModel: "lit", blending: "opaque", params: [], errors: [] };
+  let block;
+  let def;
+  try {
+    block = extractMatBlocks(text).material;
+    if (block === undefined) {
+      schema.errors.push("no material block");
+      return schema;
+    }
+    def = parseJsonish("{" + block + "}");
+  } catch (e) {
+    schema.errors.push(e instanceof Error ? e.message : String(e));
+    return schema;
+  }
+  schema.name = typeof def.name === "string" ? def.name : "";
+  schema.shadingModel = typeof def.shadingModel === "string" ? def.shadingModel : "lit";
+  schema.blending = typeof def.blending === "string" ? def.blending : "opaque";
+  const comments = collectComments(block);
+  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)) {
+      schema.errors.push("malformed parameter entry");
+      continue;
+    }
+    const entry = raw;
+    const name = String(entry.name ?? "");
+    const typeRaw = String(entry.type ?? "");
+    const typeMatch = /^(\w+)(?:\[(\d+)\])?$/.exec(typeRaw);
+    if (!name || !typeMatch) {
+      schema.errors.push(`malformed parameter "${name || typeRaw}"`);
+      continue;
+    }
+    const type = typeMatch[1];
+    const size = typeMatch[2] ? Number(typeMatch[2]) : undefined;
+    const ann = parseAnnotation(comments.get(name) ?? "");
+    for (const e of ann.errors)
+      schema.errors.push(`${name}: ${e}`);
+    let editor;
+    if (size !== undefined)
+      editor = "array";
+    else if (SAMPLER_TYPES2.has(type))
+      editor = "texture";
+    else if (type === "float")
+      editor = "number";
+    else if (type === "int" || type === "uint")
+      editor = "int";
+    else if (type === "bool")
+      editor = "switch";
+    else if (type === "float2")
+      editor = "vec2";
+    else if (type === "float3" || type === "float4") {
+      const isColor = ann.color === true || ann.vec !== true && COLOR_NAME.test(name);
+      editor = isColor ? "color" : type === "float3" ? "vec3" : "vec4";
+    } else if (/^(int|uint|bool)[234]$/.test(type))
+      editor = `vec${type.slice(-1)}`;
+    else if (/^float[234]x[234]$/.test(type))
+      editor = "matrix";
+    else
+      editor = "array";
+    const param = { name, type, editor, default: zeroFor(type, editor) };
+    if (size !== undefined)
+      param.size = size;
+    if (ann.range) {
+      param.min = ann.range[0];
+      param.max = ann.range[1];
+    }
+    if (ann.step !== undefined)
+      param.step = ann.step;
+    if (ann.default !== undefined) {
+      const v = parseDefault(ann.default, editor);
+      if (v === undefined)
+        schema.errors.push(`${name}: unreadable @default(${ann.default.trim()})`);
+      else
+        param.default = v;
+    }
+    if (ann.tooltip)
+      param.tooltip = ann.tooltip;
+    schema.params.push(param);
+  }
+  return schema;
+}, shaderDefaults = (schema) => {
+  const out = {};
+  for (const p of schema.params)
+    if (p.editor !== "texture" && p.default !== null)
+      out[p.name] = p.default;
+  return out;
+};
+var init_shaderSchema = __esm(() => {
+  init_liteMaterial();
+  SAMPLER_TYPES2 = new Set(["sampler2d", "samplerExternal", "sampler2dArray", "samplerCubemap", "sampler3d"]);
+  COLOR_NAME = /colou?r|tint|albedo|emissive|glare|glow/i;
+});
+
 // ../sdk/src/compile/sourcemap.ts
 var offsetSourceMap = (mapJson, lines) => {
   if (lines <= 0)
@@ -171865,13 +172246,18 @@ export {}
   });
   const editorImports = projectPaths.filter((p) => p.endsWith(".editor.ts")).map((p) => `import "${p}"
 `).join("");
+  const materialPaths = projectPaths.filter((p) => p.endsWith(".material.ts"));
+  const materialImports = materialPaths.map((p, i) => `import __mat${i} from "${p}"
+`).join("");
+  const materialRegister = materialPaths.length === 0 ? "" : `;(globalThis as any).__lecodesMaterials = { ${materialPaths.map((p, i) => `${JSON.stringify(p)}: __mat${i}`).join(", ")} }
+`;
   entries.push({
     path: SCENE_ENTRY_PATH,
     type: "text",
     text: `import "${SCENE_HARNESS_DIR}/.edit-mode.ts"
-` + `import "${scenePath}"
+` + materialImports + `import "${scenePath}"
 ` + editorImports + `import "${SCENE_HARNESS_DIR}/main.ts"
-`
+` + materialRegister
   });
   return entries;
 };
@@ -172002,7 +172388,7 @@ var TAG_TTF = 65536, TAG_OTTO = 1330926671, TAG_TTCF = 1953784678, TAG_WOFF = 20
 };
 
 // ../sdk/src/compile/fontMacro.ts
-var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$", isIdentPart = (c2) => isIdentStart(c2) || c2 >= "0" && c2 <= "9", skipString = (src, start) => {
+var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$", isIdentPart = (c2) => isIdentStart(c2) || c2 >= "0" && c2 <= "9", skipString2 = (src, start) => {
   const quote = src[start];
   const n = src.length;
   let i = start + 1;
@@ -172028,7 +172414,7 @@ var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <=
   while (i < n) {
     const c2 = src[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(src, i);
+      i = skipString2(src, i);
       continue;
     }
     if (c2 === "{")
@@ -172048,7 +172434,7 @@ var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <=
   while (i < n) {
     const c2 = src[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(src, i);
+      i = skipString2(src, i);
       continue;
     }
     if (c2 === "/" && src[i + 1] === "/") {
@@ -172084,7 +172470,7 @@ var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <=
   while (i < n) {
     const c2 = text[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(text, i);
+      i = skipString2(text, i);
       continue;
     }
     if (c2 === "(" || c2 === "[" || c2 === "{")
@@ -172124,7 +172510,7 @@ var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <=
   while (i < n) {
     const c2 = source[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(source, i);
+      i = skipString2(source, i);
       continue;
     }
     if (c2 === "/" && source[i + 1] === "/") {
@@ -172412,7 +172798,7 @@ var init_fontMacro = __esm(() => {
 });
 
 // ../sdk/src/compile/assetIconMacro.ts
-var ICON_ID, isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$", isIdentPart2 = (c2) => isIdentStart2(c2) || c2 >= "0" && c2 <= "9", skipString2 = (src, start) => {
+var ICON_ID, isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$", isIdentPart2 = (c2) => isIdentStart2(c2) || c2 >= "0" && c2 <= "9", skipString3 = (src, start) => {
   const quote = src[start];
   const n = src.length;
   let i = start + 1;
@@ -172438,7 +172824,7 @@ var ICON_ID, isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <
   while (i < n) {
     const c2 = src[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString2(src, i);
+      i = skipString3(src, i);
       continue;
     }
     if (c2 === "{")
@@ -172458,7 +172844,7 @@ var ICON_ID, isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <
   while (i < n) {
     const c2 = src[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString2(src, i);
+      i = skipString3(src, i);
       continue;
     }
     if (c2 === "/" && src[i + 1] === "/") {
@@ -172494,7 +172880,7 @@ var ICON_ID, isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <
   while (i < n) {
     const c2 = text[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString2(text, i);
+      i = skipString3(text, i);
       continue;
     }
     if (c2 === "(" || c2 === "[" || c2 === "{")
@@ -172529,7 +172915,7 @@ var ICON_ID, isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <
   while (i < n) {
     const c2 = source[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString2(source, i);
+      i = skipString3(source, i);
       continue;
     }
     if (c2 === "/" && source[i + 1] === "/") {
@@ -172731,6 +173117,7 @@ var exports_compile = {};
 __export(exports_compile, {
   suggestIconNames: () => suggestIconNames,
   stubServerEntries: () => stubServerEntries,
+  shaderDefaults: () => shaderDefaults,
   serverStubSource: () => serverStubSource,
   serverModuleId: () => serverModuleId,
   serverEntrySource: () => serverEntrySource,
@@ -172743,6 +173130,7 @@ __export(exports_compile, {
   scanAssetIconCalls: () => scanAssetIconCalls,
   sanitizeAssetName: () => sanitizeAssetName,
   rewriteAssetIcons: () => rewriteAssetIcons,
+  parseShaderSchema: () => parseShaderSchema,
   parseSfnt: () => parseSfnt,
   parseJsonish: () => parseJsonish,
   offsetSourceMap: () => offsetSourceMap,
@@ -172771,17 +173159,21 @@ __export(exports_compile, {
   buildFontsHeaderValue: () => buildFontsHeaderValue,
   applyFontMacro: () => applyFontMacro,
   applyAssetIconMacro: () => applyAssetIconMacro,
+  TARGET_MATRIX_GENERATION: () => TARGET_MATRIX_GENERATION,
   SERVER_INJECT: () => SERVER_INJECT,
   SERVER_ENTRY_PATH: () => SERVER_ENTRY_PATH,
   SCENE_HARNESS_DIR: () => SCENE_HARNESS_DIR,
   SCENE_ENTRY_PATH: () => SCENE_ENTRY_PATH,
   PLATFORM_BUILD: () => PLATFORM_BUILD,
+  LOCAL_PLATFORM_BUILD: () => LOCAL_PLATFORM_BUILD,
+  LOCAL_ONLY_PLATFORMS: () => LOCAL_ONLY_PLATFORMS,
   ICON_ID: () => ICON_ID,
   FONT_REGISTRY: () => FONT_REGISTRY,
   EndpointTypeError: () => EndpointTypeError,
   ENTRY_CONVENTION: () => ENTRY_CONVENTION,
   DEFAULT_FONT_REGISTRY_BASE: () => DEFAULT_FONT_REGISTRY_BASE,
-  CLIENT_INJECT: () => CLIENT_INJECT
+  CLIENT_INJECT: () => CLIENT_INJECT,
+  ALL_PLATFORM_BUILD: () => ALL_PLATFORM_BUILD
 });
 var init_compile = __esm(() => {
   init_bundler();
@@ -172791,6 +173183,7 @@ var init_compile = __esm(() => {
   init_assetName();
   init_shaderTargets();
   init_liteMaterial();
+  init_shaderSchema();
   init_compileProject();
   init_sceneEditor();
   init_fontMacro();
@@ -214358,6 +214751,10 @@ lecodes design snapshot <id> --state empty  # one state → design/.snapshots/<i
 lecodes design snapshot <id> --all-states   # every state → design/.snapshots/<id>@<state>.png|.json
 lecodes design snapshot                   # all screens → design/.snapshots/
 lecodes design check                      # concept + flow coherence (spec.md links, states, untagged)
+
+lecodes render <id> [--state <s>]         # the same screen through the full render CLI, when you
+lecodes render <id> --png card.png --clip <name>   #   need one element cropped out, a device's
+lecodes render <id> --device iphone --png x.png    #   real safe-area insets, or a --script run
 \`\`\`
 
 Either way: after every screen you create or change, look at it and fix what's wrong (overflow,
@@ -214433,14 +214830,37 @@ var init_designTemplates = __esm(() => {
   init_templates();
 });
 
+// src/designMeta.ts
+import { readFileSync as readFileSync19 } from "node:fs";
+import { join as join23 } from "node:path";
+var PHONE_SIZE, readMetaFrames = (designDir) => {
+  try {
+    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 {
+      screens: meta?.screens ?? {},
+      defaultSize: valid ? [Math.round(d[0]), Math.round(d[1])] : PHONE_SIZE
+    };
+  } catch {
+    return { screens: {}, defaultSize: PHONE_SIZE };
+  }
+}, screenFrame = (designDir, screenId) => {
+  const frames = readMetaFrames(designDir);
+  return frames.screens[screenId]?.size ?? frames.defaultSize;
+};
+var init_designMeta = __esm(() => {
+  PHONE_SIZE = [390, 844];
+});
+
 // src/commands/design.ts
 var exports_design = {};
 __export(exports_design, {
   flushDesignComments: () => flushDesignComments,
   design: () => design
 });
-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";
+import { existsSync as existsSync23, mkdirSync as mkdirSync17, readFileSync as readFileSync20, readdirSync as readdirSync12, writeFileSync as writeFileSync18, appendFileSync } from "node:fs";
+import { basename as basename9, join as join24 } from "node:path";
 var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   let root;
   let manifest;
@@ -214457,7 +214877,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     manifest,
     name: manifest?.name ?? basename9(root),
     dirName,
-    designDir: join23(root, dirName),
+    designDir: join24(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 }, loadDesignServer = async (ctx, needs = []) => {
@@ -214493,29 +214913,17 @@ 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 = join23(designDir, "screens");
+  const dir = join24(designDir, "screens");
   if (!existsSync23(dir))
     return [];
   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(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 {
-      screens: meta?.screens ?? {},
-      defaultSize: valid ? [Math.round(d[0]), Math.round(d[1])] : PHONE_SIZE
-    };
-  } catch {
-    return { screens: {}, defaultSize: PHONE_SIZE };
-  }
 }, writeMcpConfig = (ctx, port) => {
-  const path2 = join23(ctx.root, ".mcp.json");
+  const path2 = join24(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
   if (existsSync23(path2)) {
     try {
-      config = JSON.parse(readFileSync19(path2, "utf8"));
+      config = JSON.parse(readFileSync20(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-design server by hand.");
       return;
@@ -214537,15 +214945,15 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join23("shared", "tokens.ts"), TOKENS_TS],
-    [join23("shared", "tabs.ts"), TABS_TS],
-    [join23("screens", "home.ts"), HOME_SCREEN_TS]
+    [join24("shared", "tokens.ts"), TOKENS_TS],
+    [join24("shared", "tabs.ts"), TABS_TS],
+    [join24("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync17(join23(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync17(join23(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync17(join24(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync17(join24(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join23(ctx.designDir, rel);
+    const abs = join24(ctx.designDir, rel);
     if (existsSync23(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
@@ -214554,9 +214962,9 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join23(ctx.root, ".lecodesignore");
+  const ignorePath = join24(ctx.root, ".lecodesignore");
   const ignoreLines = [`${ctx.dirName}/.snapshots/`, `${ctx.dirName}/comments/`];
-  const current = existsSync23(ignorePath) ? readFileSync19(ignorePath, "utf8") : "";
+  const current = existsSync23(ignorePath) ? readFileSync20(ignorePath, "utf8") : "";
   const present = new Set(current.split(/\r?\n/));
   const missing = ignoreLines.filter((line) => !present.has(line));
   if (missing.length) {
@@ -214571,8 +214979,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);
-  mkdirSync17(join23(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync18(join23(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync17(join24(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync18(join24(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.");
@@ -214620,7 +215028,7 @@ 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") ?? join23(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join24(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)
@@ -214629,7 +215037,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     const [width, height] = frames.screens[id]?.size ?? frames.defaultSize;
     let plan = [{ state: undefined, bases: [id] }];
     if (discover) {
-      const { states, canonical } = discover(readFileSync19(join23(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync20(join24(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -214670,11 +215078,11 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
         for (const w of pngResult.warnings)
           warnErr(`${tag}: ${w}`);
       for (const base of bases) {
-        writeFileSync18(join23(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join23(outDir, `${base}.json`)}`);
+        writeFileSync18(join24(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join24(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync18(join23(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join23(outDir, `${base}.png`)}`);
+          writeFileSync18(join24(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join24(outDir, `${base}.png`)}`);
         }
       }
     }
@@ -215096,7 +215504,7 @@ var init_design = __esm(() => {
   init_config();
   init_api();
   init_types4();
-  PHONE_SIZE = [390, 844];
+  init_designMeta();
 });
 
 // ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
@@ -216118,9 +216526,9 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.18.0",
+  version: "0.18.1",
   dependencies: {
-    "@letary/chisel": "^0.8.0",
+    "@letary/chisel": "^0.10.0",
     jimp: "^1.6.1"
   },
   devDependencies: {
@@ -216134,8 +216542,8 @@ var package_default = {
   },
   peerDependencies: {
     "lecodes-design": "^0.8.1",
-    "lecodes-renderer": "^0.8.8",
-    "lecodes-3d-editor": "^0.4.0",
+    "lecodes-renderer": "^0.8.9",
+    "lecodes-3d-editor": "^0.5.0",
     "lecodes-assets": "^0.1.0"
   },
   bin: {
@@ -216486,15 +216894,27 @@ 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 shaderHash = (text, matcId) => createHash4("sha256").update(`${TARGET_MATRIX_GENERATION}\x00${matcId}\x00${text}`).digest("hex").slice(0, 16);
 var artifactFamily = (text) => {
-  const matcPlatforms = matcPlatformsFor(text);
+  const matcPlatforms = [...matcPlatformsFor(text), ...LOCAL_ONLY_PLATFORMS];
   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 shaderCompiledPlatforms = (root, text, matcId) => {
+  const hash = shaderHash(text, matcId);
+  return artifactFamily(text).filter((p) => existsSync11(join13(shadersCacheDir(root), `${hash}_${p}.filamat`)));
+};
+var localShaderArtifact = (root, text, platform) => {
+  const matcExe = resolveMatcExeCached();
+  if (!matcExe)
+    return null;
+  const file = join13(shadersCacheDir(root), `${shaderHash(text, matcIdentity(matcExe))}_${platform}.filamat`);
+  return existsSync11(file) ? file : null;
+};
+var allShaderPlatforms = () => [...Object.keys(ALL_PLATFORM_BUILD), "webgl-lite"];
 var runMatc = (exe, args) => new Promise((resolve2) => {
   execFile(exe, args, { windowsHide: true }, (error, _stdout, stderr) => {
     const text = String(stderr ?? "") || (error ? error.message : "");
@@ -216509,6 +216929,8 @@ var cleanMatcOutput = (err, tempName, realName) => {
   return (cut >= 0 ? output.slice(0, cut) : output).trim();
 };
 var NATIVE_PLATFORMS = ["opengl", "metal", "desktop"];
+var ALL_NATIVE_PLATFORMS = ["opengl", "metal", "desktop", "desktop-vulkan"];
+var desktopShaderPlatform = (platform, renderer) => platform === "win32" ? renderer === "vulkan" ? "desktop-vulkan" : "desktop" : "opengl";
 var applyLocalShaders = async (entries, opts) => {
   const shaderEntries = entries.filter((e) => e.type === "shader" && e.absPath && (opts.local || !e.shaders?.length));
   if (shaderEntries.length === 0)
@@ -216528,14 +216950,21 @@ var applyLocalShaders = async (entries, opts) => {
   for (const entry of shaderEntries) {
     const text = readFileSync10(entry.absPath, "utf8");
     const hash = shaderHash(text, matcId);
-    const matcPlatforms = matcPlatformsFor(text);
+    const family = artifactFamily(text);
     const artifact = (platform) => `${hash}_${platform}.filamat`;
-    if (!artifactFamily(text).every((p) => existsSync11(join13(cacheDir, artifact(p))))) {
+    const has = (platform) => existsSync11(join13(cacheDir, artifact(platform)));
+    const wanted = opts.platforms ? family.filter((p) => opts.platforms.includes(p)) : family;
+    if (wanted.includes("webgl") && !matcPlatformsFor(text).includes("webgl") && !wanted.includes("opengl")) {
+      wanted.push("opengl");
+    }
+    const missing = wanted.filter((p) => !has(p));
+    const matcMissing = missing.filter((p) => p !== "webgl-lite" && !(p === "webgl" && !matcPlatformsFor(text).includes("webgl")));
+    if (matcMissing.length > 0) {
       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];
+        for (const platform of matcMissing) {
+          const build = ALL_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));
@@ -216548,15 +216977,21 @@ ${cleanMatcOutput(stderr, tempName, basename3(entry.path))}`);
       } finally {
         rmSync2(tempFile, { force: true });
       }
-      if (!matcPlatforms.includes("webgl")) {
-        copyFileSync(join13(cacheDir, artifact("opengl")), join13(cacheDir, artifact("webgl")));
-      }
+    }
+    if (missing.includes("webgl") && !matcPlatformsFor(text).includes("webgl")) {
+      copyFileSync(join13(cacheDir, artifact("opengl")), join13(cacheDir, artifact("webgl")));
+    }
+    if (missing.includes("webgl-lite")) {
       writeFileSync7(join13(cacheDir, artifact("webgl-lite")), JSON.stringify(buildLiteMaterialArtifact(text)));
     }
     if (opts.local) {
-      entry.shaders = NATIVE_PLATFORMS.map((platform) => ({ platform, src: artifact(platform) }));
+      const staged = opts.platforms ? ALL_NATIVE_PLATFORMS.filter((p) => opts.platforms.includes(p)) : NATIVE_PLATFORMS;
+      entry.shaders = [
+        { platform: "opengl", src: artifact("opengl") },
+        ...staged.filter((p) => p !== "opengl").map((platform) => ({ platform, src: artifact(platform) }))
+      ];
       entry.shadersLocal = true;
-      for (const platform of NATIVE_PLATFORMS) {
+      for (const platform of staged) {
         artifacts.push({ name: artifact(platform), absPath: join13(cacheDir, artifact(platform)) });
       }
     } else {
@@ -216587,6 +217022,17 @@ var FIRST_PARTY_PLUGINS = {
 };
 var readAppConfigAt = (root) => readJson(join15(root, "app.json"));
 var DESKTOP_DEFAULT_WINDOW = { width: 1280, height: 720 };
+var resolveDesktopRenderer = (root, args) => {
+  const raw = (args ? flagStr(args, "renderer") : undefined) ?? process.env.LECODES_DESKTOP_RENDERER ?? readAppConfigAt(root)?.desktop?.renderer;
+  if (raw === undefined)
+    return "gl";
+  const value = String(raw).toLowerCase();
+  if (value === "gl" || value === "opengl")
+    return "gl";
+  if (value === "vulkan" || value === "vk")
+    return "vulkan";
+  throw new CliError(`Unknown desktop renderer "${raw}". Use "gl" or "vulkan".`);
+};
 var desktopDefaultViewport = (root) => {
   const cfg = readAppConfigAt(root);
   if (!cfg?.desktop || cfg.ios || cfg.android)
@@ -216654,6 +217100,14 @@ var detectEngines = (bundleJs) => {
 `);
   return { gl: !/^\/\/ gl: disable$/m.test(header), g2: /^\/\/ 2d: enable$/m.test(header) };
 };
+var assertRendererSupportsBundle = (renderer, bundleJs) => {
+  if (renderer !== "vulkan")
+    return;
+  if (!detectEngines(bundleJs).g2)
+    return;
+  throw new CliError("This project uses the 2D engine, which the Vulkan desktop host doesn't include " + `(creator-2d renders through OpenGL and has no Vulkan path yet).
+` + "  Build with the default renderer: drop `desktop.renderer` from app.json, or pass `--renderer gl`.");
+};
 var resolveVariant = (requested, bundleJs, configKey = "ios.variant") => {
   const uses = detectEngines(bundleJs);
   const detected = uses.gl && uses.g2 ? "full" : uses.gl ? "3d" : uses.g2 ? "2d" : "core";
@@ -216866,7 +217320,8 @@ var buildBundle = async (args, shell, opts = {}) => {
   }
   let stagedShaders = [];
   if (localAssets && (opts.localShaders ?? !shell)) {
-    const local = await applyLocalShaders(entries, { root, local: true });
+    const platforms = opts.desktopRenderer ? [desktopShaderPlatform(process.platform, opts.desktopRenderer)] : undefined;
+    const local = await applyLocalShaders(entries, { root, local: true, platforms });
     warnings.push(...local.warnings);
     stagedShaders = local.artifacts;
   }
@@ -216878,9 +217333,11 @@ var buildBundle = async (args, shell, opts = {}) => {
     publicUrl: shell ? "" : publicUrl,
     makeResourceEntry: (path, absPath) => ({ path, type: "resource", fileSrc: encodeURI(path), absPath })
   });
+  if (opts.extraEntries)
+    entries.push(...opts.extraEntries);
   const iconsHeader = await applyAppAssetIcons(entries);
   note("Compiling…");
-  const entryFlag = flagStr(args, "entry");
+  const entryFlag = opts.entryOverride ?? flagStr(args, "entry");
   if (!entryFlag) {
     const ambiguous = ambiguousEntryWarning(entries);
     if (ambiguous)
@@ -219373,9 +219830,13 @@ var makeStackDemangler = (bundleJs) => {
 
 // src/desktopRenderer.ts
 var DESKTOP_RENDERER_VERSION = "1.1.0";
-var platformKey2 = () => {
+var DESKTOP_RENDERER_MIN_VERSION = { gl: "0.0.0", vulkan: "1.4.0" };
+var platformKey2 = (renderer = "gl") => {
   if (process.platform === "win32")
-    return "windows-x64";
+    return renderer === "vulkan" ? "windows-x64-vulkan" : "windows-x64";
+  if (renderer === "vulkan") {
+    throw new CliError(`The Vulkan desktop host is Windows-only (this is ${process.platform}). Use the default renderer.`);
+  }
   if (process.platform === "linux")
     return "ubuntu-linux-x64";
   throw new CliError(process.platform === "darwin" ? "`lecodes render --desktop` isn't available on macOS yet (the macOS host ships separately)." : `\`lecodes render --desktop\` isn't available on ${process.platform}.`);
@@ -219413,11 +219874,15 @@ var selectedDesktopVersion = () => {
   return DESKTOP_RENDERER_VERSION;
 };
 var fetchDesktopManifest = () => fetchReleaseProduct("desktop", "desktop");
-var downloadDesktop = async (version, dest) => {
-  const key = platformKey2();
+var downloadDesktop = async (version, dest, renderer = "gl") => {
+  const key = platformKey2(renderer);
   const entry = (await fetchDesktopManifest()).versions.find((v) => v.version === version);
   const file = entry?.files[key];
   if (!file) {
+    if (renderer === "vulkan") {
+      throw new CliError(`The Vulkan desktop host isn't published for LeCodes Desktop ${version} [${key}].
+` + `  Vulkan needs desktop >= ${DESKTOP_RENDERER_MIN_VERSION.vulkan}; run \`lecodes desktop update\`, ` + `set LECODES_DESKTOP_EXE to a locally built host, or drop desktop.renderer from app.json.`);
+    }
     throw new CliError(`LeCodes Desktop ${version} [${key}] isn't published yet — \`--desktop\` needs it for the ` + `headless render contract.
 Set LECODES_DESKTOP_EXE to a locally built host, or update lecodes-cli.`);
   }
@@ -219428,18 +219893,20 @@ Set LECODES_DESKTOP_EXE to a locally built host, or update lecodes-cli.`);
     validate: (dir) => findExe(dir) ? null : "The downloaded archive doesn't contain the desktop host binary."
   });
 };
-var resolveDesktopExe = async () => {
+var resolveDesktopExe = async (renderer = "gl") => {
   const override = process.env.LECODES_DESKTOP_EXE;
   if (override) {
     if (!existsSync17(override))
       throw new CliError(`LECODES_DESKTOP_EXE points at "${override}" which doesn't exist.`);
     return resolve5(override);
   }
+  if (renderer === "vulkan")
+    platformKey2(renderer);
   const version = selectedDesktopVersion();
-  const dir = join18(cacheRoot2(), `desktop-${version}`);
+  const dir = join18(cacheRoot2(), `desktop-${version}${renderer === "vulkan" ? "-vulkan" : ""}`);
   let exe = existsSync17(dir) ? findExe(dir) : null;
   if (!exe) {
-    await downloadDesktop(version, dir);
+    await downloadDesktop(version, dir, renderer);
     exe = findExe(dir);
     if (!exe)
       throw new CliError(`Renderer cache at ${dir} is broken — delete the folder and retry.`);
@@ -219488,6 +219955,8 @@ var windowEnv = (opts) => {
   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])}`;
   }
+  if (opts.fps)
+    env.CREATOR_FPS = "1";
   return env;
 };
 var stageBundle = (js, resources) => {
@@ -219517,7 +219986,7 @@ var pipeThroughDemangler = (src, dst, map) => {
   });
 };
 var runDesktopApp = async (js, resources, opts = {}) => {
-  const exe = await resolveDesktopExe();
+  const exe = await resolveDesktopExe(opts.renderer);
   const runDir = stageBundle(js, resources);
   try {
     const env = { ...process.env, ...windowEnv(opts) };
@@ -219541,7 +220010,7 @@ var runDesktopApp = async (js, resources, opts = {}) => {
   }
 };
 var runDesktopDev = async (url, opts = {}) => {
-  const exe = await resolveDesktopExe();
+  const exe = await resolveDesktopExe(opts.renderer);
   const env = { ...process.env, ...windowEnv(opts) };
   await new Promise((done, fail) => {
     const child = spawn2(exe, [url], { env, stdio: ["ignore", "ignore", "inherit"] });
@@ -219550,7 +220019,7 @@ var runDesktopDev = async (url, opts = {}) => {
   });
 };
 var runDesktopRender = async (js, resources, opts) => {
-  const exe = await resolveDesktopExe();
+  const exe = await resolveDesktopExe(opts.renderer);
   const runDir = stageBundle(js, resources);
   try {
     const appJs = join18(runDir, "app.js");
@@ -219577,11 +220046,16 @@ var runDesktopRender = async (js, resources, opts) => {
     return await new Promise((done, fail) => {
       const child = spawn2(exe, [appJs], { cwd: runDir, env, stdio: ["ignore", "pipe", "pipe"] });
       const chunks = [];
+      let stopped = false;
       const sink = (d) => {
         const text = String(d);
         chunks.push(text);
         if (opts.logs)
           process.stderr.write(demangle(text));
+        if (!stopped && opts.stopOnLine?.(text)) {
+          stopped = true;
+          child.kill();
+        }
       };
       child.stdout.on("data", sink);
       child.stderr.on("data", sink);
@@ -219596,6 +220070,8 @@ var runDesktopRender = async (js, resources, opts) => {
       child.on("exit", (code) => {
         clearTimeout(killer);
         const output = demangle(chunks.join(""));
+        if (stopped)
+          return done({ output, exitCode: 0 });
         if (code === 0 && existsSync17(outAbs))
           return done({ output, exitCode: code });
         const tail = demangle(chunks.slice(-80).join("")).trimEnd();
@@ -219634,6 +220110,8 @@ var initDesktop = async (args) => {
   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 ASSETS_DIR = "assets";
+var RUNTIME_DIR = "runtime";
 var buildDesktop = async (args) => {
   const root = projectRoot();
   const config = readJson(join19(root, "app.json")) ?? {};
@@ -219649,8 +220127,10 @@ 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 ?? [] }, { localShaders: true });
+  const renderer = resolveDesktopRenderer(root, args);
+  note(`Building "${name}" for desktop${renderer === "vulkan" ? " (Vulkan)" : ""}…`);
+  const { js, resources } = await buildBundle(args, { remotePatterns: config.resources?.remote ?? [] }, { localShaders: true, desktopRenderer: renderer });
+  assertRendererSupportsBundle(renderer, js);
   const wanted = new Set([...js.matchAll(/fetchLocal\("([^"]+)"\)/g)].map((m) => m[1]));
   const shipped = resources.filter((r2) => !r2.remote && (r2.shader || wanted.has(r2.name)));
   const byName = new Map;
@@ -219669,7 +220149,7 @@ var buildDesktop = async (args) => {
 `)).join(`
 `));
   }
-  const exe = await resolveDesktopExe();
+  const exe = await resolveDesktopExe(renderer);
   const hostDir = dirname11(exe);
   const IMPLICIT_PRELOADS = new Set(["uberarchive", "capture"]);
   const hostProvided = new Set;
@@ -219686,11 +220166,15 @@ var buildDesktop = async (args) => {
   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)
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".dll")) {
+      cpSync2(join19(hostDir, entry.name), join19(out, entry.name));
+    } else if (entry.isDirectory() && entry.name === "assets") {
+      cpSync2(join19(hostDir, entry.name), join19(out, RUNTIME_DIR), { recursive: true });
+    } else if (entry.isDirectory() && entry.name === "fonts") {
       cpSync2(join19(hostDir, entry.name), join19(out, entry.name), { recursive: true });
+    }
   }
-  if (!existsSync18(join19(out, "assets", "initial.js"))) {
+  if (!existsSync18(join19(out, RUNTIME_DIR, "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);
@@ -219698,16 +220182,18 @@ var buildDesktop = async (args) => {
   note(`  host: LeCodes Desktop ${version}`);
   writeFileSync14(join19(out, "app.js"), js);
   let assetBytes = 0, assetCount = 0;
+  if (shipped.length > 0)
+    mkdirSync12(join19(out, ASSETS_DIR), { recursive: true });
   for (const r2 of shipped) {
     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, join19(out, r2.name));
+    cpSync2(r2.absPath, join19(out, ASSETS_DIR, r2.name));
     assetBytes += statSync5(r2.absPath).size;
     assetCount++;
   }
-  note(`  assets: ${assetCount} files, ${mb(assetBytes)}`);
+  note(`  assets: ${assetCount} files, ${mb(assetBytes)} → ${ASSETS_DIR}/`);
   writeJson(join19(out, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
   if (config.icon) {
     await writeIco(root, config, join19(out, "app.ico"));
@@ -219818,7 +220304,7 @@ var readmeText = (name, exeName2, version) => `${name}
 ${"=".repeat(Math.max(name.length, 4))}
 
 A LeCodes desktop app. Nothing to install: unpack the WHOLE folder anywhere and run ${exeName2}.
-Keep the files together — the app reads its assets from this folder.
+Keep the files together: assets/ holds the app's own content, runtime/ the engine it needs.
 
 On first run Windows may show a SmartScreen prompt (any unsigned app gets one):
 choose "More info", then "Run anyway".
@@ -220654,6 +221140,9 @@ from \`main.ts\`.
 lecodes render                    # semantic JSON of the launched UI (structure, text, names, values)
 lecodes render --png shot.png     # pixels (needs @napi-rs/canvas installed)
 lecodes render --png card.png --clip card   # ONE component/region: a node name or x,y,w,h
+lecodes render src/screens/cart.ts   # ONE screen module, without booting the app: any file that
+                                  # \`export default\`s a UIScreen (or a (state) => UIScreen —
+                                  # --state <name> picks the branch). Same flags as above.
 lecodes render --desktop --png shot.png  # NATIVE render: real Filament 3D + UI + 2D composited —
                                   # use this to SEE 3D scenes / procedural geometry (headless
                                   # renders record 3D as JSON only). Windows/Linux; downloads
@@ -220828,9 +221317,12 @@ var run = async (args) => {
   }
   const appCfg = readAppConfigAt(root);
   const win = appCfg?.desktop?.window;
-  const { js, resources } = await buildBundle(args, undefined, { localAssets: true });
-  note("Launching LeCodes Desktop… (close the window to return)");
+  const renderer = resolveDesktopRenderer(root, args);
+  const { js, resources } = await buildBundle(args, undefined, { localAssets: true, desktopRenderer: renderer });
+  assertRendererSupportsBundle(renderer, js);
+  note(`Launching LeCodes Desktop${renderer === "vulkan" ? " (Vulkan)" : ""}… (close the window to return)`);
   await runDesktopApp(js, resources, {
+    renderer,
     width: Number(flagStr(args, "width")) || win?.width,
     height: Number(flagStr(args, "height")) || win?.height,
     minWidth: win?.minWidth,
@@ -220840,7 +221332,8 @@ var run = async (args) => {
     fullscreen: flagBool(args, "fullscreen") ? true : flagBool(args, "windowed") ? false : win?.fullscreen,
     scale: resolveScale(flagStr(args, "scale"), win?.scale),
     renderScale: resolveRenderScale(flagStr(args, "render-scale"), appCfg?.desktop?.renderScale),
-    maxRenderSize: appCfg?.desktop?.maxRenderSize
+    maxRenderSize: appCfg?.desktop?.maxRenderSize,
+    fps: flagBool(args, "fps")
   });
 };
 var status = async () => {
@@ -220865,9 +221358,11 @@ var desktop = async (args) => {
     return status();
   if (sub === "run")
     return run(args);
+  if (sub === "build")
+    return buildDesktop(args);
   if (sub === "update")
     return updateDesktop();
-  throw new CliError(`Unknown subcommand "desktop ${sub}". Use \`lecodes desktop\` (status), \`lecodes desktop run\` or \`lecodes desktop update\`.`);
+  throw new CliError(`Unknown subcommand "desktop ${sub}". Use \`lecodes desktop\` (status), \`lecodes desktop run\`, \`lecodes desktop build\` or \`lecodes desktop update\`.`);
 };
 
 // src/index.ts
@@ -220876,16 +221371,16 @@ init_design();
 // src/commands/dev.ts
 init_manifest();
 init_ignore();
-import { existsSync as existsSync24, mkdirSync as mkdirSync18, readFileSync as readFileSync20, watch, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync18, readFileSync as readFileSync21, watch, writeFileSync as writeFileSync19 } from "node:fs";
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { basename as basename10, join as join25 } from "node:path";
+import { basename as basename10, join as join26 } from "node:path";
 
 // src/dev/devServer.ts
 init_localFiles();
 import { createServer as createServer2 } from "node:http";
 import { createReadStream, statSync as statSync8 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 init_projectCompile();
 init_fonts();
 init_assetIcons();
@@ -221271,7 +221766,7 @@ var startDevServer = async (options) => {
       const name2 = route.slice("/shaders/".length);
       if (!isShaderArtifactName(name2))
         return sendText(res, 400, "text/plain", "Bad path");
-      const abs = join24(shadersCacheDir(root), name2);
+      const abs = join25(shadersCacheDir(root), name2);
       try {
         if (!statSync8(abs).isFile())
           throw new Error("not a file");
@@ -221385,14 +221880,14 @@ var lanCandidates = () => {
   return out.sort((x2, y2) => x2.rank - y2.rank).map(({ address, iface }) => ({ address, iface }));
 };
 var loadDevToken = (root) => {
-  const path2 = join25(root, LECODES_DIR, "dev.json");
+  const path2 = join26(root, LECODES_DIR, "dev.json");
   try {
-    const token2 = JSON.parse(readFileSync20(path2, "utf8")).token;
+    const token2 = JSON.parse(readFileSync21(path2, "utf8")).token;
     if (token2 && /^[a-z0-9]{8,}$/.test(token2))
       return token2;
   } catch {}
   const token = randomBytes3(6).toString("hex");
-  mkdirSync18(join25(root, LECODES_DIR), { recursive: true });
+  mkdirSync18(join26(root, LECODES_DIR), { recursive: true });
   writeFileSync19(path2, JSON.stringify({ token }, null, 2) + `
 `);
   return token;
@@ -221510,7 +222005,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 (existsSync24(join25(root, LECODES_DIR, "manifest.json")))
+  if (existsSync24(join26(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.`);
@@ -221525,7 +222020,8 @@ ${result.error}`);
       minHeight: win?.minHeight,
       resizable: win?.resizable,
       title: win?.title ?? appCfg?.name ?? name,
-      scale: resolveScale(undefined, win?.scale)
+      scale: resolveScale(undefined, win?.scale),
+      fps: flagBool(args, "fps")
     }).then(() => note("Desktop window closed — the dev server keeps running (Ctrl+C to stop)."), (e2) => warnErr(`Desktop host: ${e2 instanceof Error ? e2.message : String(e2)}`));
   }
 };
@@ -221538,7 +222034,7 @@ init_localFiles();
 
 // src/serverDiff.ts
 init_localFiles();
-import { readFileSync as readFileSync21 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 import { basename as basename11 } from "node:path";
 var isTextAsset = (t2) => t2 === "text" || t2 === "shader" || t2 === "scene";
 var computeServerDiff = (project, scan2) => {
@@ -221557,7 +222053,7 @@ var computeServerDiff = (project, scan2) => {
     const local = localByPath.get(path2);
     if (local && !server2) {
       const text = isTextKind(classifyKind(basename11(path2)));
-      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync21(local.absPath, "utf8") : undefined });
+      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync22(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server2 && !local) {
@@ -221568,12 +222064,12 @@ var computeServerDiff = (project, scan2) => {
     if (server2 && local) {
       if (isTextAsset(server2.type)) {
         const serverText = server2.text ?? "";
-        const localText = readFileSync21(local.absPath, "utf8");
+        const localText = readFileSync22(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(readFileSync21(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync22(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path: path2, status: "modified", binary: true });
         }
@@ -221732,7 +222228,7 @@ init_manifest();
 init_types4();
 init_ignore();
 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";
+import { basename as basename12, dirname as dirname14, join as join27, 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\`.
@@ -221845,7 +222341,7 @@ var init2 = async (args) => {
   mkdirSync19(root, { recursive: true });
   let created = 0;
   const write = (rel, content) => {
-    const abs = join26(root, rel);
+    const abs = join27(root, rel);
     if (existsSync25(abs)) {
       note(`kept      ${rel}`);
       return;
@@ -221899,7 +222395,7 @@ init_ignore();
 init_localFiles();
 init_manifest();
 import { existsSync as existsSync26 } from "node:fs";
-import { basename as basename14, join as join27, resolve as resolve11 } from "node:path";
+import { basename as basename14, join as join28, resolve as resolve11 } from "node:path";
 init_types4();
 init_util();
 
@@ -221909,7 +222405,7 @@ init_config();
 init_manifest();
 init_localFiles();
 import { basename as basename13 } from "node:path";
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 init_util();
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
@@ -221970,9 +222466,9 @@ var push = async (args) => {
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync22(file.absPath, "utf8");
+      entry.text = readFileSync23(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename13(file.path), readFileSync22(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename13(file.path), readFileSync23(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -222082,7 +222578,7 @@ var link = async (args) => {
   const root = dirArg ? resolve11(dirArg) : process.cwd();
   if (!existsSync26(root))
     throw new CliError(`No such directory: ${root}`);
-  if (existsSync26(join27(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
+  if (existsSync26(join28(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;
@@ -222144,6 +222640,173 @@ var link = async (args) => {
   log(`  ${c.dim("(add --publish to deploy it live in the same step)")}`);
 };
 
+// src/commands/lightmap.ts
+init_manifest();
+import { existsSync as existsSync27, mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync3, rmSync as rmSync8, statSync as statSync9, unlinkSync, writeFileSync as writeFileSync21 } from "node:fs";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join29, relative as relative4, resolve as resolve12 } from "node:path";
+init_util();
+var num = (args, key, fallback, min, max) => {
+  const raw = flagStr(args, key);
+  if (raw === undefined)
+    return fallback;
+  const n2 = Number(raw);
+  if (!Number.isFinite(n2) || n2 < min || n2 > max)
+    throw new CliError(`--${key} wants a number in ${min}..${max}, got "${raw}".`);
+  return n2;
+};
+var findToktx = () => {
+  const env = process.env.KTX_TOKTX;
+  if (env && existsSync27(env))
+    return env;
+  for (const base of [process.env.LOCALAPPDATA && join29(process.env.LOCALAPPDATA, "Programs"), process.env.ProgramFiles]) {
+    if (!base)
+      continue;
+    const guess = join29(base, "KTX-Software", "bin", "toktx.exe");
+    if (existsSync27(guess))
+      return guess;
+  }
+  return "toktx";
+};
+var checkToktx = (toktx) => {
+  try {
+    const p2 = spawnSync4(toktx, ["--version"], { encoding: "utf8" });
+    if (p2.status === 0)
+      return (p2.stdout ?? "").toString().trim() || "toktx";
+  } catch {}
+  return null;
+};
+var requireToktx = () => {
+  const toktx = findToktx();
+  if (!checkToktx(toktx)) {
+    throw new CliError(`lecodes lightmap bake needs KTX-Software's toktx — the atlas ships as KTX2 (GPU-compressed, mipmapped).
+  Install it from https://github.com/KhronosGroup/KTX-Software/releases (make sure toktx is on PATH) or set KTX_TOKTX=<path to toktx>.`);
+  }
+  return toktx;
+};
+var encodeKtx2 = (toktx, png2, ktx2) => {
+  const args = ["--t2", "--encode", "uastc", "--uastc_quality", "2", "--zcmp", "18", "--genmipmap", "--assign_oetf", "srgb", ktx2, png2];
+  const p2 = spawnSync4(toktx, args, { encoding: "utf8" });
+  if (p2.status !== 0) {
+    throw new CliError(`toktx failed (${p2.status ?? p2.error?.message ?? "?"}) while encoding ${ktx2}:
+${(p2.stderr || p2.stdout || "").trim()}`);
+  }
+};
+var bake = async (args) => {
+  let root;
+  try {
+    root = findProjectRoot(process.cwd());
+  } catch {
+    root = process.cwd();
+  }
+  const toktx = requireToktx();
+  const outDir = resolve12(root, flagStr(args, "out") ?? "assets/lightmap");
+  const entryFlag = flagStr(args, "entry");
+  const entryFile = entryFlag ?? "main.ts";
+  if (!existsSync27(resolve12(root, entryFile))) {
+    throw new CliError(`No ${entryFile} in ${root} — pass --entry <file> (the file that builds the scene and calls Lightmap.load).`);
+  }
+  const cfg = {
+    outDir: outDir.replace(/\\/g, "/"),
+    size: num(args, "size", 4096, 256, 16384),
+    texel: num(args, "texel", 0.02, 0.001, 2),
+    sunRays: num(args, "sun-rays", 32, 1, 1024),
+    aoRays: num(args, "ao-rays", 64, 1, 4096),
+    aoDistance: num(args, "ao-distance", 2, 0.01, 1000),
+    bias: num(args, "bias", 0.02, 0.0001, 1),
+    sunAngle: num(args, "sun-angle", 0.5, 0.01, 30)
+  };
+  const frames = num(args, "frames", 900, 30, 1e5);
+  const win = readAppConfigAt(root)?.desktop?.window;
+  const width = Number(flagStr(args, "width")) || win?.width || 1280;
+  const height = Number(flagStr(args, "height")) || win?.height || 720;
+  const logs = flagBool(args, "logs");
+  const importPath = "./" + entryFile.replace(/\\/g, "/").replace(/\.tsx?$/, "");
+  const entryPath = "/.lightmap-entry.ts";
+  const entryText = `globalThis.__lecodesLightmap = ${JSON.stringify(cfg)}
+import ${JSON.stringify(importPath)}
+`;
+  mkdirSync20(outDir, { recursive: true });
+  ensurePlaceholders(outDir);
+  const desktopRenderer = resolveDesktopRenderer(root, args);
+  const { js, resources } = await buildBundle(args, undefined, {
+    localAssets: true,
+    desktopRenderer,
+    extraEntries: [{ path: entryPath, type: "text", text: entryText }],
+    entryOverride: entryPath
+  });
+  const scratch = mkdtempSync3(join29(tmpdir3(), "lecodes-lightmap-"));
+  const outPng = join29(scratch, "frame.png");
+  note(`Baking ${cfg.size}² at ${(cfg.texel * 100).toFixed(1)} cm texels (${cfg.sunRays} sun + ${cfg.aoRays} AO rays) → ${relative4(root, outDir) || "."}…`);
+  let output = "";
+  try {
+    const timeoutMs = Number(flagStr(args, "timeout")) || 600000;
+    const res = await runDesktopRender(js, resources, {
+      renderer: desktopRenderer,
+      width,
+      height,
+      frames,
+      outPng,
+      logs,
+      timeoutMs,
+      stopOnLine: (chunk) => chunk.includes("[lightmap] done") || chunk.includes("[lightmap] error")
+    });
+    output = res.output;
+  } catch (e2) {
+    const msg = e2 instanceof Error ? e2.message : String(e2);
+    if (!/\[lightmap\] done/.test(msg))
+      throw e2;
+    output = msg;
+  } finally {
+    rmSync8(scratch, { recursive: true, force: true });
+  }
+  const lines = output.split(/\r?\n/).filter((l2) => l2.startsWith("[lightmap]"));
+  for (const l2 of lines) {
+    const text = l2.slice("[lightmap]".length).trim();
+    if (text === "done")
+      continue;
+    logErr(text.startsWith("error") ? c.red(`✗ ${text}`) : c.dim(`  ${text}`));
+  }
+  if (/\[lightmap\] done/.test(output)) {
+    const png2 = join29(outDir, "lightmap.png");
+    const ktx2 = join29(outDir, "lightmap.ktx2");
+    if (!existsSync27(png2))
+      throw new CliError(`The host reported a bake but ${png2} is missing.`);
+    const t0 = Date.now();
+    encodeKtx2(toktx, png2, ktx2);
+    const pngKb = Math.round(statSync9(png2).size / 1024), ktxKb = Math.round(statSync9(ktx2).size / 1024);
+    unlinkSync(png2);
+    logErr(c.dim(`  encoded lightmap.ktx2 (UASTC + mips, ${ktxKb} KB from a ${pngKb} KB raster) in ${((Date.now() - t0) / 1000).toFixed(1)} s`));
+    logErr(c.green(`✓ baked → ${relative4(root, outDir) || "."}/lightmap.ktx2 + lightmap.bake`));
+    logErr(c.dim(`  apply it with Lightmap.load(scene, { data: asset('<rel>/${relative4(root, join29(outDir, "lightmap.bake")).replace(/\\/g, "/")}'), texture: asset('<rel>/${relative4(root, ktx2).replace(/\\/g, "/")}') })  — asset() paths are relative to the calling file`));
+    return;
+  }
+  if (lines.some((l2) => /no bake module/.test(l2))) {
+    throw new CliError("This desktop host has no bake module. Build packages/desktop (CREATOR_GL_LIGHTMAP is on there) and point LECODES_DESKTOP_EXE at build/lecodes-desktop.exe, or update: lecodes desktop update.");
+  }
+  if (lines.some((l2) => /error/.test(l2)))
+    throw new CliError("The bake failed — see the lines above.");
+  warnErr("The host ran to its frame cap without baking. Make sure the app calls Lightmap.load(...) after the static scene is built, and skips menus when Lightmap.baking is true (a title screen never reaches the scene). More load headroom: --frames <n>. Host output: --logs.");
+  throw new CliError("Nothing was baked.");
+};
+var PLACEHOLDER_KTX2 = Buffer.from("q0tUWCAyMLsNChoKAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAaAAAACwAAACUAAAAfAAAAAAAAAAAAAAAAAAAAAAAAAAQAQAAAAAAABAAAAAAAAAAEAAAAAAAAAAsAAAAAAAAAAIAKACmAQIAAwMAABAAAAAAAAAAAAB/AAAAAAAAAAAA/////xEAAABLVFhvcmllbnRhdGlvbgByAAAAACcAAABLVFh3cml0ZXIAdG9rdHggdjQuNC4yIC8gbGlia3R4IHY0LjQuMgAAMwAAAEtUWHdyaXRlclNjUGFyYW1zAC0tZW5jb2RlIHVhc3RjIC0tdWFzdGNfcXVhbGl0eSAwAAD3////H3zvAQAAAAAAAAAA", "base64");
+var ensurePlaceholders = (outDir) => {
+  const bake2 = join29(outDir, "lightmap.bake");
+  const ktx2 = join29(outDir, "lightmap.ktx2");
+  if (!existsSync27(bake2))
+    writeFileSync21(bake2, JSON.stringify({ version: 1, placeholder: true, size: 1, texel: 0, instances: [] }) + `
+`);
+  if (!existsSync27(ktx2))
+    writeFileSync21(ktx2, PLACEHOLDER_KTX2);
+};
+var lightmap = async (args) => {
+  const sub = args._[0];
+  if (sub === "bake")
+    return bake({ ...args, _: args._.slice(1) });
+  throw new CliError("Usage: lecodes lightmap bake [--out assets/lightmap] [--size 4096] [--texel 0.02] [--sun-rays 32] [--ao-rays 64] [--ao-distance 2] [--bias 0.02] [--sun-angle 0.5] [--frames 900] [--entry main.ts] [--logs]   (needs KTX-Software's toktx)");
+};
+
 // src/commands/login.ts
 init_api();
 init_config();
@@ -222161,8 +222824,9 @@ var login = async (args) => {
 
 // src/commands/shaders.ts
 init_manifest();
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 init_util();
+init_compile();
 var collectShaders = () => {
   let root;
   let manifest;
@@ -222188,8 +222852,27 @@ var status2 = async () => {
     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`");
+      let state;
+      if (matcId === null)
+        state = c.dim("unknown (matc not downloaded)");
+      else {
+        const text = readFileSync24(shader.absPath, "utf8");
+        if (shaderIsCompiled(root, text, matcId))
+          state = "compiled";
+        else {
+          const present = shaderCompiledPlatforms(root, text, matcId);
+          state = present.length === 0 ? c.yellow("not compiled — run `lecodes shaders compile`") : c.yellow(`partial (${present.join(", ")}) — \`lecodes shaders compile\` for the rest`);
+        }
+      }
       log(`  ${shader.path.padEnd(width)}  ${state}`);
+      const schema = parseShaderSchema(readFileSync24(shader.absPath, "utf8"));
+      for (const p2 of schema.params) {
+        const range = p2.min !== undefined ? ` [${p2.min}..${p2.max}]` : "";
+        const def = p2.default !== null && p2.default !== undefined ? ` = ${JSON.stringify(p2.default)}` : "";
+        log(`      ${c.dim(p2.type.padEnd(10))} ${p2.name}${c.dim(`  ${p2.editor}${range}${def}`)}${p2.tooltip ? c.dim(`  — ${p2.tooltip}`) : ""}`);
+      }
+      for (const e2 of schema.errors)
+        log(`      ${c.yellow(e2)}`);
     }
   }
   try {
@@ -222201,7 +222884,23 @@ var status2 = async () => {
     log(`published       ${c.dim(e2 instanceof CliError ? e2.message : "unknown (couldn't reach the release manifest)")}`);
   }
 };
-var compile3 = async () => {
+var parsePlatforms = (args) => {
+  const raw = flagStr(args, "platform", "platforms");
+  if (raw === undefined)
+    return;
+  const known = allShaderPlatforms();
+  const asked = raw.split(",").map((p2) => p2.trim()).filter(Boolean);
+  if (asked.length === 0)
+    throw new CliError(`--platform needs at least one target. Known: ${known.join(", ")}`);
+  const bad = asked.filter((p2) => !known.includes(p2));
+  if (bad.length > 0) {
+    throw new CliError(`Unknown shader platform${bad.length > 1 ? "s" : ""}: ${bad.join(", ")}
+  Known: ${known.join(", ")}`);
+  }
+  return asked;
+};
+var compile3 = async (args) => {
+  const platforms = parsePlatforms(args);
   const { root, entries, shaders } = collectShaders();
   if (shaders.length === 0) {
     note("No .mat shaders in this project.");
@@ -222209,11 +222908,11 @@ var compile3 = async () => {
   }
   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 wasCompiled = new Map(shaders.map((s2) => [s2.path, shaderIsCompiled(root, readFileSync24(s2.absPath, "utf8"), matcId)]));
   const errors2 = [];
   for (const shader of shaders) {
     try {
-      const { warnings } = await applyLocalShaders([shader], { root, local: true });
+      const { warnings } = await applyLocalShaders([shader], { root, local: true, platforms });
       for (const w of warnings)
         warnErr(w);
       log(`  ${shader.path}  ${wasCompiled.get(shader.path) ? c.dim("compiled (cached)") : "compiled"}`);
@@ -222228,22 +222927,23 @@ var compile3 = async () => {
 ${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)}`);
+  const scope = platforms ? ` [${platforms.join(", ")}]` : "";
+  note(`${shaders.length} shader${shaders.length === 1 ? "" : "s"} compiled${scope} → ${shadersCacheDir(root)}`);
 };
 var shaders = async (args) => {
   const sub = args._[0];
   if (sub === undefined)
     return status2();
   if (sub === "compile")
-    return compile3();
+    return compile3(args);
   if (sub === "update")
     return updateMatc();
-  throw new CliError(`Unknown subcommand "shaders ${sub}". Use \`lecodes shaders\` (status), \`lecodes shaders compile\` or \`lecodes shaders update\`.`);
+  throw new CliError(`Unknown subcommand "shaders ${sub}". Use \`lecodes shaders\` (status), \`lecodes shaders compile [--platform a,b]\` or \`lecodes shaders update\`.`);
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync24, writeFileSync as writeFileSync21 } from "node:fs";
-import { dirname as dirname15, resolve as resolve13 } from "node:path";
+import { mkdirSync as mkdirSync21, readFileSync as readFileSync26, writeFileSync as writeFileSync22 } from "node:fs";
+import { dirname as dirname15, resolve as resolve15 } from "node:path";
 
 // src/compile/headlessBundle.ts
 init_api();
@@ -222254,7 +222954,7 @@ init_fonts();
 init_assetIcons();
 init_util();
 var LOCAL_ASSET_SCHEME2 = "lecodesfile://";
-var compileHeadlessBundle = async (args) => {
+var compileHeadlessBundle = async (args, opts = {}) => {
   let root;
   let manifest;
   try {
@@ -222289,7 +222989,9 @@ var compileHeadlessBundle = async (args) => {
       warnings.push("This is a local project (no server) — assets always load from the working tree.");
     }
   }
-  const compileEntries = useLocalAssets ? entries.map((e2) => e2.type === "resource" && e2.absPath ? { ...e2, fileSrc: encodeURIComponent(e2.absPath) } : e2) : entries;
+  const compileEntries = useLocalAssets ? entries.map((e2) => e2.type === "resource" && e2.absPath ? { ...e2, fileSrc: encodeURIComponent(e2.absPath) } : e2) : [...entries];
+  if (opts.screen)
+    compileEntries.push(opts.screen.entry);
   await applyProjectFonts(compileEntries, useLocalAssets ? {
     mode: "vendor",
     root,
@@ -222299,7 +223001,7 @@ var compileHeadlessBundle = async (args) => {
   } : { mode: "cdn", root });
   await applyAppAssetIcons(compileEntries);
   note("Compiling…");
-  const entryFlag = flagStr(args, "entry");
+  const entryFlag = opts.screen?.entryPath ?? flagStr(args, "entry");
   if (!entryFlag) {
     const ambiguous = ambiguousEntryWarning(compileEntries);
     if (ambiguous)
@@ -222322,12 +223024,84 @@ var compileHeadlessBundle = async (args) => {
   return { js, root, warnings, useLocalAssets };
 };
 
+// src/compile/screenEntry.ts
+init_designMeta();
+init_util();
+import { existsSync as existsSync28, readFileSync as readFileSync25, statSync as statSync10 } from "node:fs";
+import { isAbsolute, join as join30, relative as relative5, resolve as resolve13 } from "node:path";
+var SCREEN_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+var SCREEN_ENTRY_PATH = "/.screen-entry.ts";
+var DEFAULT_DESIGN_DIR = "design";
+var screenArg = (args) => args._[0];
+var hasSeparator = (file) => file.includes("/") || file.includes("\\");
+var findScreenFile = (root, file, dirFlag) => {
+  const candidates = [resolve13(process.cwd(), file)];
+  if (!hasSeparator(file)) {
+    candidates.push(join30(root, (dirFlag ?? DEFAULT_DESIGN_DIR).replace(/[/\\]+$/, ""), "screens", file));
+  }
+  for (const base of candidates) {
+    if (existsSync28(base) && statSync10(base).isFile())
+      return base;
+    for (const ext2 of SCREEN_EXTS)
+      if (existsSync28(base + ext2))
+        return base + ext2;
+  }
+  throw new CliError(`No screen file at "${file}".` + (hasSeparator(file) ? "" : ` Pass a path, or a screen id that exists in ${dirFlag ?? DEFAULT_DESIGN_DIR}/screens/.`));
+};
+var designDirOf = (root, key) => {
+  const m = /^\/(.*)screens\/([^/]+)\.[^./]+$/.exec(key);
+  if (!m)
+    return null;
+  const dir = join30(root, m[1]);
+  return existsSync28(join30(dir, "meta.json")) ? { dir, id: m[2] } : null;
+};
+var resolveScreenTarget = (root, file, opts = {}) => {
+  const abs = findScreenFile(root, file, opts.dir);
+  const rel = relative5(root, abs);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new CliError(`"${file}" is outside the project (${root}) — a screen renders as part of its project, so its ` + `imports and asset() files resolve from the same tree.`);
+  }
+  const key = toKey(rel);
+  if (!/^\s*export\s+default\b/m.test(readFileSync25(abs, "utf8"))) {
+    throw new CliError(`${key.slice(1)} has no default export. A screen file ends with ` + `\`export default UIScreen([...])\` — or \`export default (state) => UIScreen([...])\` for screen states.`);
+  }
+  const invoke = opts.state !== undefined ? `screen(${JSON.stringify(opts.state)})` : "screen()";
+  const spec = "." + key.replace(/\.[^./]+$/, "");
+  const design2 = designDirOf(root, key);
+  return {
+    entryPath: SCREEN_ENTRY_PATH,
+    entry: {
+      path: SCREEN_ENTRY_PATH,
+      type: "text",
+      text: `import screen from ${JSON.stringify(spec)}
+` + `const __screen = typeof screen === "function" ? ${invoke} : screen
+` + `__screen.open()
+`
+    },
+    frame: design2 ? screenFrame(design2.dir, design2.id) : undefined,
+    label: (design2 ? design2.id : key.slice(1)) + (opts.state !== undefined ? `@${opts.state}` : "")
+  };
+};
+var screenTargetFromArgs = (root, args) => {
+  const file = screenArg(args);
+  if (file === undefined) {
+    if (flagStr(args, "state") !== undefined) {
+      throw new CliError("--state picks a screen's state — name the screen file too: lecodes render <file> --state <name>");
+    }
+    return;
+  }
+  if (flagStr(args, "entry") !== undefined) {
+    throw new CliError("Use either a screen file or --entry, not both — each names the module to compile from.");
+  }
+  return resolveScreenTarget(root, file, { state: flagStr(args, "state"), dir: flagStr(args, "dir") });
+};
+
 // src/commands/render.ts
 init_manifest();
 
 // src/desktopScript.ts
 init_util();
-import { resolve as resolve12 } from "node:path";
+import { resolve as resolve14 } 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", "look", "mouseTo", "wheel", "stick", "gamepad", "camera", "view"];
@@ -222355,7 +223129,7 @@ var translateScenario = (rawSteps, opts) => {
     }
     throw new CliError(`${at}: "${key}" must be { "x", "y" }.`);
   };
-  const num = (at, key, v, def) => {
+  const num2 = (at, key, v, def) => {
     if (v === undefined && def !== undefined)
       return def;
     if (typeof v !== "number")
@@ -222382,7 +223156,7 @@ var translateScenario = (rawSteps, opts) => {
     }
     if (action === "view") {
       const v = s2.view;
-      const fov = s2.fov !== undefined ? num(at, "fov", s2.fov) : undefined;
+      const fov = s2.fov !== undefined ? num2(at, "fov", s2.fov) : undefined;
       if (v === "off") {
         plan.lines.push(emit("view off"));
         inspecting = false;
@@ -222402,7 +223176,7 @@ var translateScenario = (rawSteps, opts) => {
         parts.push("camera off");
       } else if (typeof cam === "object" && cam !== null && isVec3(cam.at) && isVec3(cam.lookAt)) {
         const { at: eye, lookAt, fov } = cam;
-        const fovN = fov !== undefined ? num(at, "camera.fov", fov) : undefined;
+        const fovN = fov !== undefined ? num2(at, "camera.fov", fov) : undefined;
         plan.lines.push(emit(`camera ${eye.join(" ")} ${lookAt.join(" ")}${fovN !== undefined ? ` ${fovN}` : ""}`));
         inspecting = true;
         parts.push(`camera at (${eye.join(",")}) → (${lookAt.join(",")})`);
@@ -222419,20 +223193,20 @@ var translateScenario = (rawSteps, opts) => {
       parts.push(`tap ${pt(p2)}`);
     } else if (action === "drag") {
       const a2 = coord(at, "drag", s2.drag), b = coord(at, "to", s2.to);
-      const ms = num(at, "ms", s2.ms, 300);
+      const ms = num2(at, "ms", s2.ms, 300);
       plan.lines.push(emit(`drag ${a2.x} ${a2.y} ${b.x} ${b.y} ${Math.round(ms)}`));
       budgetMs += ms + 4 * FRAME_MS;
       parts.push(`drag ${pt(a2)} → ${pt(b)} over ${ms}ms`);
     } else if (action === "hold") {
       const p2 = coord(at, "hold", s2.hold);
-      const ms = num(at, "ms", s2.ms);
+      const ms = num2(at, "ms", s2.ms);
       plan.lines.push(emit(`hold ${p2.x} ${p2.y} ${Math.round(ms)}`));
       budgetMs += ms + 4 * FRAME_MS;
       parts.push(`hold ${pt(p2)} ${ms}ms`);
     } else if (action === "key") {
       if (typeof s2.key !== "string")
         throw new CliError(`${at}: "key" must be a KeyboardEvent.code string.`);
-      const ms = num(at, "ms", s2.ms);
+      const ms = num2(at, "ms", s2.ms);
       plan.lines.push(emit(`key ${s2.key} ${Math.round(ms)}`));
       budgetMs += ms + 2 * FRAME_MS;
       parts.push(`key ${s2.key} ${ms}ms`);
@@ -222447,7 +223221,7 @@ var translateScenario = (rawSteps, opts) => {
       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);
+      const ms = num2(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`);
@@ -222493,12 +223267,12 @@ var translateScenario = (rawSteps, opts) => {
       budgetMs += 2 * FRAME_MS;
       parts.push(`gamepad ${s2.gamepad} #${pad}`);
     } else if (action === "wait") {
-      const ms = num(at, "wait", s2.wait);
+      const ms = num2(at, "wait", s2.wait);
       plan.lines.push(emit(`wait ${Math.round(ms)}`));
       budgetMs += ms + FRAME_MS;
       parts.push(`wait ${ms}ms`);
     } else if (action === "frames") {
-      const n2 = num(at, "frames", s2.frames);
+      const n2 = num2(at, "frames", s2.frames);
       plan.lines.push(emit(`frames ${Math.round(n2)}`));
       budgetMs += n2 * FRAME_MS + FRAME_MS;
       parts.push(`advance ${n2} frames`);
@@ -222528,7 +223302,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 = resolve12(opts.outDir, s2.screenshot);
+      plan.screenshot = resolve14(opts.outDir, s2.screenshot);
       plan.lines.push(emit(`frames 2`));
       plan.lines.push(emit(`shot ${plan.screenshot}`));
       budgetMs += 3 * FRAME_MS;
@@ -222637,9 +223411,9 @@ var requireRenderer = async () => {
 };
 var fileScenarioIO = (dir) => ({
   write: (relPath, data) => {
-    const abs = resolve13(dir, relPath);
-    mkdirSync20(dirname15(abs), { recursive: true });
-    writeFileSync21(abs, data);
+    const abs = resolve15(dir, relPath);
+    mkdirSync21(dirname15(abs), { recursive: true });
+    writeFileSync22(abs, data);
   }
 });
 var resolveFixtures = (value, baseDir) => {
@@ -222647,9 +223421,9 @@ var resolveFixtures = (value, baseDir) => {
     return;
   let map = value;
   if (typeof value === "string") {
-    const abs = resolve13(baseDir, value);
+    const abs = resolve15(baseDir, value);
     try {
-      map = JSON.parse(readFileSync24(abs, "utf8"));
+      map = JSON.parse(readFileSync26(abs, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read fixtures "${value}": ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -222662,7 +223436,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path2) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync24(resolve13(path2), "utf8"));
+    raw = JSON.parse(readFileSync26(resolve15(path2), "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read scenario "${path2}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -222697,10 +223471,11 @@ var renderDesktop = async (args) => {
     root = process.cwd();
   }
   const win = readAppConfigAt(root)?.desktop?.window;
+  const screen2 = screenTargetFromArgs(root, args);
   const scriptFlag = flagStr(args, "script");
   const scenario = scriptFlag !== undefined ? readScenarioFile(scriptFlag) : null;
-  const width = Number(flagStr(args, "width")) || scenario?.width || win?.width || 390;
-  const height = Number(flagStr(args, "height")) || scenario?.height || win?.height || 844;
+  const width = Number(flagStr(args, "width")) || scenario?.width || screen2?.frame?.[0] || win?.width || 390;
+  const height = Number(flagStr(args, "height")) || scenario?.height || screen2?.frame?.[1] || win?.height || 844;
   const frames = Number(flagStr(args, "frames")) || 60;
   const pngFlag = flagStr(args, "png") ?? "screenshot.png";
   const logs = flagBool(args, "logs");
@@ -222711,17 +223486,24 @@ var renderDesktop = async (args) => {
   const { camera, view } = resolveInspectionCamera(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 });
-  mkdirSync20(dirname15(resolve13(pngFlag)), { recursive: true });
+  const desktopRenderer = resolveDesktopRenderer(root, args);
+  const { js, resources } = await buildBundle(args, undefined, {
+    localAssets: true,
+    desktopRenderer,
+    extraEntries: screen2 ? [screen2.entry] : undefined,
+    entryOverride: screen2?.entryPath
+  });
+  mkdirSync21(dirname15(resolve15(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)
-        mkdirSync20(dirname15(st.screenshot), { recursive: true });
+        mkdirSync21(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, {
+      renderer: desktopRenderer,
       width,
       height,
       frames: plan.frameCap,
@@ -222751,8 +223533,9 @@ var renderDesktop = async (args) => {
     process.exit(result.ok ? 0 : 1);
   }
   const timeoutMs = Number(flagStr(args, "timeout")) || 60000;
-  note("Rendering (native)…");
+  note(screen2 ? `Rendering ${screen2.label} (native)…` : "Rendering (native)…");
   await runDesktopRender(js, resources, {
+    renderer: desktopRenderer,
     width,
     height,
     frames,
@@ -222798,6 +223581,13 @@ var render = async (args) => {
     return renderDesktop(args);
   const scriptFlag = flagStr(args, "script");
   const scenario = scriptFlag !== undefined ? readScenarioFile(scriptFlag) : null;
+  let projectRoot2;
+  try {
+    projectRoot2 = findProjectRoot(process.cwd());
+  } catch {
+    projectRoot2 = process.cwd();
+  }
+  const screen2 = screenTargetFromArgs(projectRoot2, args);
   const stepCount = scenario && Array.isArray(scenario.steps) ? scenario.steps.length : 0;
   const timeoutMs = Number(flagStr(args, "timeout")) || 15000 + stepCount * 3000;
   const killer = setTimeout(() => {
@@ -222805,15 +223595,15 @@ var render = async (args) => {
     process.exit(1);
   }, timeoutMs);
   killer.unref?.();
-  const { js, warnings, useLocalAssets, root } = await compileHeadlessBundle(args);
+  const { js, warnings, useLocalAssets, root } = await compileHeadlessBundle(args, { screen: screen2 });
   const renderer = await requireRenderer();
   const projectViewport = desktopDefaultViewport(root);
-  const width = Number(flagStr(args, "width")) || scenario?.width || projectViewport?.width || 390;
-  const height = Number(flagStr(args, "height")) || scenario?.height || projectViewport?.height || 844;
+  const width = Number(flagStr(args, "width")) || scenario?.width || screen2?.frame?.[0] || projectViewport?.width || 390;
+  const height = Number(flagStr(args, "height")) || scenario?.height || screen2?.frame?.[1] || projectViewport?.height || 844;
   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(resolve13(scriptFlag)) : ".");
+  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname15(resolve15(scriptFlag)) : ".");
   const flagFixtures = resolveFixtures(flagStr(args, "fixtures"), ".");
   const fixtures = envelopeFixtures || flagFixtures ? { ...envelopeFixtures, ...flagFixtures } : undefined;
   if (fixtures) {
@@ -222852,7 +223642,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) => resolve13(outDir, p2)).join(", ")}`));
+        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p2) => resolve15(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);
@@ -222862,7 +223652,7 @@ var render = async (args) => {
   }
   const pngFlag = flagStr(args, "png") ?? (flagBool(args, "png") ? "screenshot.png" : undefined);
   if (pngFlag !== undefined) {
-    note("Rendering PNG…");
+    note(screen2 ? `Rendering ${screen2.label} (PNG)…` : "Rendering PNG…");
     const clip = parseClip(flagStr(args, "clip"));
     const { png: png2, width: outW, height: outH, warnings: pngWarnings } = await renderer.renderToPng(js, {
       width,
@@ -222876,12 +223666,13 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync21(resolve13(pngFlag), png2);
+      mkdirSync21(dirname15(resolve15(pngFlag)), { recursive: true });
+      writeFileSync22(resolve15(pngFlag), png2);
       note(`Wrote ${pngFlag} (${png2.length} bytes, ${outW}x${outH}${clip !== undefined ? ", clipped" : ""})`);
     }
     return done((cb) => cb());
   }
-  note("Rendering…");
+  note(screen2 ? `Rendering ${screen2.label}…` : "Rendering…");
   const result = await renderer.renderToJson(js, { width, height, ...timing });
   for (const w of [...warnings, ...result.warnings])
     warnErr(w);
@@ -222891,7 +223682,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync21(resolve13(out), result.text);
+    writeFileSync22(resolve15(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -222906,8 +223697,8 @@ init_api();
 init_config();
 init_manifest();
 init_util();
-import { appendFileSync as appendFileSync2, existsSync as existsSync27, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join28 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync29, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "node:fs";
+import { join as join31 } from "node:path";
 var ENV_VAR = "LECODES_PUSH_KEY";
 var context = () => {
   const root = findProjectRoot(process.cwd());
@@ -223051,11 +223842,11 @@ var pnKeysList = async (ctx) => {
 };
 var writeEnv = (root, key) => {
   const touched = [];
-  const envPath = join28(root, ".env");
+  const envPath = join31(root, ".env");
   const line = `${ENV_VAR}=${key}`;
-  const existing = existsSync27(envPath) ? readFileSync25(envPath, "utf8") : "";
+  const existing = existsSync29(envPath) ? readFileSync27(envPath, "utf8") : "";
   if (new RegExp(`^${ENV_VAR}=`, "m").test(existing)) {
-    writeFileSync22(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
+    writeFileSync23(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
   } else {
     const separator = !existing || existing.endsWith(`
 `) ? "" : `
@@ -223064,8 +223855,8 @@ var writeEnv = (root, key) => {
 `);
   }
   touched.push(".env");
-  const ignorePath = join28(root, ".gitignore");
-  const ignore = existsSync27(ignorePath) ? readFileSync25(ignorePath, "utf8") : "";
+  const ignorePath = join31(root, ".gitignore");
+  const ignore = existsSync29(ignorePath) ? readFileSync27(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l2) => l2.trim() === ".env")) {
     const separator = !ignore || ignore.endsWith(`
@@ -223164,8 +223955,8 @@ var pn = async (args) => {
 init_api();
 init_config();
 init_manifest();
-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";
+import { existsSync as existsSync30, mkdirSync as mkdirSync22, rmSync as rmSync9, writeFileSync as writeFileSync24 } from "node:fs";
+import { dirname as dirname16, join as join32 } from "node:path";
 init_types4();
 init_localFiles();
 init_util();
@@ -223188,9 +223979,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 = join29(root, ...path2.replace(/^\//, "").split("/"));
-      if (existsSync28(abs))
-        rmSync8(abs);
+      const abs = join32(root, ...path2.replace(/^\//, "").split("/"));
+      if (existsSync30(abs))
+        rmSync9(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -223227,18 +224018,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 = join29(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync21(dirname16(abs), { recursive: true });
+    const abs = join32(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync22(dirname16(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync23(abs, bytes);
+      writeFileSync24(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync23(abs, text);
+      writeFileSync24(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf3(asset.type), sha };
@@ -223251,8 +224042,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/scene.ts
 init_manifest();
-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";
+import { existsSync as existsSync32, readFileSync as readFileSync29, readdirSync as readdirSync13, statSync as statSync11, writeFileSync as writeFileSync26 } from "node:fs";
+import { basename as basename15, dirname as dirname17, join as join34, resolve as resolve16 } from "node:path";
 
 // src/compile/sceneCompile.ts
 init_localFiles();
@@ -223260,18 +224051,19 @@ init_ignore();
 init_distRoot();
 init_util();
 init_projectCompile();
-import { existsSync as existsSync29, readFileSync as readFileSync26 } from "node:fs";
-import { join as join30 } from "node:path";
+import { createHash as createHash8 } from "node:crypto";
+import { existsSync as existsSync31, mkdirSync as mkdirSync23, readFileSync as readFileSync28, writeFileSync as writeFileSync25 } from "node:fs";
+import { join as join33 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join30(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join33(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync29(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync31(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join30(distRoot, "runtime", "scene-harness.json");
-    if (existsSync29(vendored))
-      return JSON.parse(readFileSync26(vendored, "utf8"));
+    const vendored = join33(distRoot, "runtime", "scene-harness.json");
+    if (existsSync31(vendored))
+      return JSON.parse(readFileSync28(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
 };
@@ -223283,11 +224075,32 @@ 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: readFileSync26(file.absPath, "utf8") });
+      entries.push({ path: path2, type: "text", text: readFileSync28(file.absPath, "utf8") });
+    } else if (/\.mat$/i.test(path2)) {
+      entries.push({ path: path2, type: "shader", text: readFileSync28(file.absPath, "utf8"), absPath: file.absPath });
     } else {
       entries.push({ path: path2, type: "resource", fileSrc: "/project/" + rel(file.path) });
     }
   }
+  const shaderEntries = entries.filter((e2) => e2.type === "shader");
+  if (shaderEntries.length > 0) {
+    const { warnings } = await applyLocalShaders(shaderEntries, { root, srcPrefix: "/project/.lecodes/shaders", platforms: ["webgl", "webgl-lite"] });
+    for (const w of warnings)
+      warnErr(w);
+    const { buildLiteMaterialArtifact: buildLiteMaterialArtifact2 } = await Promise.resolve().then(() => (init_compile(), exports_compile));
+    for (const e2 of shaderEntries) {
+      if (e2.shaders?.length)
+        continue;
+      const hash = createHash8("sha256").update(e2.text ?? "").digest("hex").slice(0, 16);
+      const dir = shadersCacheDir(root);
+      mkdirSync23(dir, { recursive: true });
+      const liteName = `${hash}_webgl-lite.filamat`;
+      if (!existsSync31(join33(dir, liteName)))
+        writeFileSync25(join33(dir, liteName), JSON.stringify(buildLiteMaterialArtifact2(e2.text ?? "")));
+      const src = `/project/.lecodes/shaders/${hash}_opengl.filamat`;
+      e2.shaders = ["opengl", "webgl", "webgl-lite"].map((platform) => ({ platform, src }));
+    }
+  }
   const scene = scenePath.startsWith("./") ? scenePath : "./" + rel(scenePath);
   if (!entries.some((e2) => e2.path === scene && e2.type === "text")) {
     return { js: null, error: `Scene file not found: ${scene}` };
@@ -223317,7 +224130,7 @@ var DEFAULT_PORT3 = 4488;
 var findAppRoot = (start) => {
   let dir = start;
   while (true) {
-    if (existsSync30(join31(dir, "app.json")))
+    if (existsSync32(join34(dir, "app.json")))
       return dir;
     const parent = dirname17(dir);
     if (parent === dir)
@@ -223336,10 +224149,10 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve14(process.cwd(), pathArg);
-      if (existsSync30(abs) && statSync9(abs).isDirectory())
+      const abs = resolve16(process.cwd(), pathArg);
+      if (existsSync32(abs) && statSync11(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync30(abs))
+      else if (abs.endsWith(".scene.ts") && existsSync32(abs))
         root = findAppRoot(dirname17(abs)) ?? dirname17(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
@@ -223350,12 +224163,12 @@ var getContext2 = (args) => {
   return { root, manifest, name: manifest?.name ?? basename15(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path2 = join31(root, ".mcp.json");
+  const path2 = join34(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync30(path2)) {
+  if (existsSync32(path2)) {
     try {
-      config = JSON.parse(readFileSync27(path2, "utf8"));
+      config = JSON.parse(readFileSync29(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -223368,7 +224181,7 @@ var writeMcpConfig2 = (root, port) => {
     return;
   }
   config.mcpServers["lecodes-scene"] = entry;
-  writeFileSync24(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync26(path2, JSON.stringify(config, null, 2) + `
 `);
   note(`${existing ? "updated" : "created"}   .mcp.json (lecodes-scene MCP → ${entry.url})`);
 };
@@ -223377,8 +224190,8 @@ var countScenes = (dir) => {
   for (const name of readdirSync13(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join31(dir, name);
-    if (statSync9(full).isDirectory())
+    const full = join34(dir, name);
+    if (statSync11(full).isDirectory())
       n2 += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n2++;
@@ -223406,7 +224219,8 @@ var scene = async (args) => {
       manifest: ctx.manifest,
       name: ctx.name,
       scenePath
-    })
+    }),
+    shaderArtifact: (shaderText, platform) => localShaderArtifact(ctx.root, shaderText, platform)
   });
   if (!flagBool(args, "no-mcp"))
     writeMcpConfig2(ctx.root, port);
@@ -223420,6 +224234,79 @@ var scene = async (args) => {
 
 // src/commands/assets.ts
 init_util();
+
+// src/cmgenTool.ts
+import { existsSync as existsSync33, readdirSync as readdirSync14 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join35, resolve as resolve17 } from "node:path";
+init_util();
+var exeName2 = () => process.platform === "win32" ? "cmgen.exe" : "cmgen";
+var platformKey3 = () => {
+  if (process.platform === "win32")
+    return "windows-x64";
+  if (process.platform === "linux")
+    return "linux-x64";
+  throw new CliError(process.platform === "darwin" ? "cmgen isn't published for macOS yet — build filament's host tools locally and set LECODES_CMGEN." : `cmgen isn't published for ${process.platform}.`);
+};
+var cacheRoot3 = () => join35(homedir8(), ".lecodes", "cmgen");
+var findCmgenIn = (dir) => {
+  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
+    const p2 = join35(dir, entry.name);
+    if (entry.isFile() && entry.name === exeName2())
+      return p2;
+    if (entry.isDirectory()) {
+      const found = findCmgenIn(p2);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+};
+var installedCmgenVersions = () => {
+  try {
+    return readdirSync14(cacheRoot3(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("cmgen-")).map((e2) => e2.name.slice("cmgen-".length)).filter((v) => findCmgenIn(join35(cacheRoot3(), `cmgen-${v}`)) !== null).sort(semverNewer);
+  } catch {
+    return [];
+  }
+};
+var fetchCmgenManifest = () => fetchReleaseProduct("cmgen", "cmgen (environment tool)");
+var downloadCmgen = async (version, versions, dest) => {
+  const key = platformKey3();
+  const file = versions.find((v) => v.version === version)?.files[key];
+  if (!file) {
+    throw new CliError(`cmgen ${version} [${key}] isn't published — build filament's host tools locally and point ` + `LECODES_CMGEN at the binary.`);
+  }
+  note(`Downloading the environment tool (cmgen ${version}, ${(file.size / 1024 / 1024).toFixed(1)} MB)…`);
+  await downloadReleaseArchive(file, {
+    cacheRoot: cacheRoot3(),
+    dest,
+    validate: (dir) => findCmgenIn(dir) ? null : "The downloaded archive doesn't contain the cmgen binary."
+  });
+};
+var resolveCmgenExeCached = () => {
+  const override = process.env.LECODES_CMGEN;
+  if (override) {
+    if (!existsSync33(override))
+      throw new CliError(`LECODES_CMGEN points at "${override}" which doesn't exist.`);
+    return resolve17(override);
+  }
+  const cached = installedCmgenVersions()[0];
+  return cached ? findCmgenIn(join35(cacheRoot3(), `cmgen-${cached}`)) : null;
+};
+var resolveCmgenExe = async () => {
+  const cached = resolveCmgenExeCached();
+  if (cached)
+    return cached;
+  const { latest, versions } = await fetchCmgenManifest();
+  const dir = join35(cacheRoot3(), `cmgen-${latest}`);
+  await downloadCmgen(latest, versions, dir);
+  const exe = findCmgenIn(dir);
+  if (!exe)
+    throw new CliError(`cmgen cache at ${dir} is broken — delete the folder and retry.`);
+  return exe;
+};
+
+// src/commands/assets.ts
 var assets = async (args) => {
   let mod;
   try {
@@ -223428,6 +224315,9 @@ var assets = async (args) => {
     throw new CliError("The asset pipeline isn't installed. Run:  npm install -g lecodes-assets");
   }
   const raw = args._raw ?? args._;
+  if (raw[0] === "sky" && !process.env.LECODES_CMGEN) {
+    process.env.LECODES_CMGEN = await resolveCmgenExe();
+  }
   const code = await mod.runAssetsCli(raw);
   if (code !== 0)
     process.exitCode = code;
@@ -223466,8 +224356,8 @@ var status3 = async (_args) => {
 };
 
 // src/commands/test.ts
-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";
+import { existsSync as existsSync34, mkdirSync as mkdirSync24, readFileSync as readFileSync30, readdirSync as readdirSync15 } from "node:fs";
+import { dirname as dirname18, resolve as resolve18 } from "node:path";
 init_manifest();
 init_util();
 var deriveDesignFlows = (meta, entryScreen) => {
@@ -223530,7 +224420,7 @@ var slug3 = (s2) => s2.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").
 var readFlowFile = (abs, displayName) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync28(abs, "utf8"));
+    raw = JSON.parse(readFileSync30(abs, "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read "${displayName}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -223556,7 +224446,14 @@ var test = async (args) => {
   const desktop2 = flagBool(args, "desktop");
   if (desktop2 && flagBool(args, "flows"))
     throw new CliError("--flows needs the headless renderer (design flows tap by name) — drop --desktop.");
-  const native = desktop2 ? await buildBundle(args, undefined, { localAssets: true }) : null;
+  let desktopRoot;
+  try {
+    desktopRoot = findProjectRoot(process.cwd());
+  } catch {
+    desktopRoot = process.cwd();
+  }
+  const desktopRenderer = desktop2 ? resolveDesktopRenderer(desktopRoot, args) : undefined;
+  const native = desktop2 ? await buildBundle(args, undefined, { localAssets: true, desktopRenderer }) : null;
   const headless = desktop2 ? null : await compileHeadlessBundle(args);
   const warnings = headless?.warnings ?? [];
   const useLocalAssets = headless?.useLocalAssets ?? false;
@@ -223578,40 +224475,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 = resolve15(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve15(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve18(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve18(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 = [resolve15(given), resolve15(testsDir, given), resolve15(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p2) => existsSync31(p2));
+      const candidates = [resolve18(given), resolve18(testsDir, given), resolve18(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p2) => existsSync34(p2));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync31(testsDir)) {
-    for (const f3 of readdirSync14(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve15(testsDir, f3), f3));
+  } else if (existsSync34(testsDir)) {
+    for (const f3 of readdirSync15(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve18(testsDir, f3), f3));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve15(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync31(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve18(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync34(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 && existsSync31(designMetaPath)) {
+  if (desktop2 && wantFlows && existsSync34(designMetaPath)) {
     note("Design-derived flows skipped with --desktop (they tap by name; run `lecodes test` headless for them).");
   }
-  if (!desktop2 && (wantFlows || flowsOnly) && existsSync31(designMetaPath)) {
+  if (!desktop2 && (wantFlows || flowsOnly) && existsSync34(designMetaPath)) {
     let meta;
     try {
-      meta = JSON.parse(readFileSync28(designMetaPath, "utf8"));
+      meta = JSON.parse(readFileSync30(designMetaPath, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read ${designMetaPath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -223643,17 +224540,18 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve15(root, flagStr(args, "artifacts") ?? resolve15(testsDir, ".artifacts"));
+  const artifactsRoot = resolve18(root, flagStr(args, "artifacts") ?? resolve18(testsDir, ".artifacts"));
   const results = [];
   const runNativeCase = async (kase) => {
-    const caseDir = resolve15(artifactsRoot, slug3(kase.name));
+    const caseDir = resolve18(artifactsRoot, slug3(kase.name));
     const plan = translateScenario(kase.steps, { outDir: caseDir, headroomFrames: nativeFrames });
     for (const st of plan.steps)
       if (st.screenshot)
-        mkdirSync22(dirname18(st.screenshot), { recursive: true });
-    mkdirSync22(caseDir, { recursive: true });
-    const finalPng = resolve15(caseDir, "final.png");
+        mkdirSync24(dirname18(st.screenshot), { recursive: true });
+    mkdirSync24(caseDir, { recursive: true });
+    const finalPng = resolve18(caseDir, "final.png");
     const { output } = await runDesktopRender(native.js, native.resources, {
+      renderer: desktopRenderer,
       width: Number(flagStr(args, "width")) || kase.width || projectViewport?.width || 390,
       height: Number(flagStr(args, "height")) || kase.height || projectViewport?.height || 844,
       frames: plan.frameCap,
@@ -223703,14 +224601,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve15(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve18(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) => resolve15(artifactsRoot, slug3(kase.name), p2))
+          artifacts: outcome.failureArtifacts.map((p2) => resolve18(artifactsRoot, slug3(kase.name), p2))
         };
       } finally {
         session.dispose();
@@ -223778,11 +224676,11 @@ init_config();
 init_manifest();
 init_types4();
 init_util();
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
 var types4 = async (args) => {
   const dirArg = args._[0];
-  const root = dirArg ? resolve16(dirArg) : (() => {
+  const root = dirArg ? resolve19(dirArg) : (() => {
     try {
       return findProjectRoot(process.cwd());
     } catch {
@@ -223841,23 +224739,23 @@ var types4 = async (args) => {
 };
 
 // src/index.ts
-import { existsSync as existsSync33, readFileSync as readFileSync30, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync32, realpathSync as realpathSync2 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname20, join as join33 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname20, join as join37 } 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 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";
+import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync4, existsSync as existsSync35, mkdirSync as mkdirSync25, readFileSync as readFileSync31, realpathSync, rmSync as rmSync10, symlinkSync } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { basename as basename16, delimiter, dirname as dirname19, join as join36, resolve as resolve20, sep as sep2 } from "node:path";
 var isWin = process.platform === "win32";
-var HOME = homedir8();
+var HOME = homedir9();
 var safeRealpath = (p2) => {
   try {
     return realpathSync(p2);
   } catch {
-    return resolve17(p2);
+    return resolve20(p2);
   }
 };
 var onPath = (dir) => {
@@ -223874,24 +224772,24 @@ var onPath = (dir) => {
 };
 var install = async (args) => {
   const bundle = dirname19(process.execPath);
-  const exeName2 = basename16(process.execPath);
+  const exeName3 = basename16(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync32(join32(bundle, "runtime")) || !existsSync32(join32(bundle, chiselName))) {
+  if (!existsSync35(join36(bundle, "runtime")) || !existsSync35(join36(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) => existsSync32(join32(bundle, f3)));
+  const companions = [exeName3, chiselName, "runtime", "README.txt"].filter((f3) => existsSync35(join36(bundle, f3)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
 };
 var copyBundle = (bundle, target, companions) => {
-  mkdirSync23(target, { recursive: true });
+  mkdirSync25(target, { recursive: true });
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f3 of companions) {
-    const dest = join32(target, f3);
-    rmSync9(dest, { recursive: true, force: true });
-    cpSync4(join32(bundle, f3), dest, { recursive: true });
+    const dest = join36(target, f3);
+    rmSync10(dest, { recursive: true, force: true });
+    cpSync4(join36(bundle, f3), dest, { recursive: true });
   }
 };
 var permError = (e2, dir, system) => {
@@ -223903,41 +224801,41 @@ var permError = (e2, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  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");
+  const libDir = resolve20(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join36(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve20(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join36(HOME, ".local", "bin")));
+  const link2 = join36(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync2(join32(libDir, "lecodes"), 493);
-    chmodSync2(join32(libDir, "chisel"), 493);
+    chmodSync2(join36(libDir, "lecodes"), 493);
+    chmodSync2(join36(libDir, "chisel"), 493);
   } catch (e2) {
     throw permError(e2, libDir, system);
   }
   try {
-    mkdirSync23(binDir, { recursive: true });
-    rmSync9(link2, { force: true });
-    symlinkSync(join32(libDir, "lecodes"), link2);
+    mkdirSync25(binDir, { recursive: true });
+    rmSync10(link2, { force: true });
+    symlinkSync(join36(libDir, "lecodes"), link2);
   } catch (e2) {
     throw permError(e2, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link2 + " → " + join32(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join36(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
   const shell = basename16(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join32(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join36(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join32(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join32(HOME, ".profile"), name: "~/.profile" };
+    return { file: join36(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join36(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 = existsSync32(file) ? readFileSync29(file, "utf8") : "";
+    const existing = existsSync35(file) ? readFileSync31(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -223975,7 +224873,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 = resolve17(flagStr(args, "dir") ?? join32(process.env.LOCALAPPDATA ?? join32(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve20(flagStr(args, "dir") ?? join36(process.env.LOCALAPPDATA ?? join36(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e2) {
@@ -224015,7 +224913,7 @@ init_util();
 var STANDALONE = (() => {
   const dir = dirname20(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync33(join33(dir, "runtime")) && existsSync33(join33(dir, chisel));
+  return existsSync36(join37(dir, "runtime")) && existsSync36(join37(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -224030,8 +224928,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join33(d, exe);
-      return existsSync33(cand) && realpathSync2(cand) === self2;
+      const cand = join37(d, exe);
+      return existsSync36(cand) && realpathSync2(cand) === self2;
     } catch {
       return false;
     }
@@ -224102,6 +225000,7 @@ ${c.bold("Commands:")}
                                   --desktop       also open the app in the native desktop host
                                                     (same hot reload; window from app.json's
                                                     desktop block; closing it keeps the server)
+                                  --fps           (--desktop) draw the host's frame counter
   compile                       Compile the local project to JS (prints to stdout)
                                   (was 'lecodes preview' — the old name still works)
                                   -o, --out <file>   write to a file instead of stdout
@@ -224110,8 +225009,16 @@ ${c.bold("Commands:")}
                                   --no-minify        keep the bundle readable (no compress/mangle)
                                   --no-sourcemap     don't generate/inline the source map
                                   --public-url <url> asset URL prefix (default: the API origin)
-  render                        Render the local UI project to a semantic JSON description
+  render [file]                 Render the local UI project to a semantic JSON description
                                   (needs the optional 'lecodes-renderer' package; UI projects only)
+                                  [file]             render ONE screen module instead of the app:
+                                                       a file that default-exports a UIScreen (or a
+                                                       (state) => UIScreen) — every 'lecodes design'
+                                                       screen is written that way. A bare id
+                                                       ("login") resolves in design/screens/, and a
+                                                       design screen renders at its meta.json frame
+                                  --state <name>     ([file]) the state to pass a
+                                                       (state) => UIScreen screen
                                   -o, --out <file>   write JSON to a file instead of stdout
                                   --png [file]       rasterize a PNG (default screenshot.png;
                                                        needs @napi-rs/canvas)
@@ -224204,7 +225111,7 @@ ${c.bold("Commands:")}
                                   add "<text>" [--screen <id>] [--state <s>] [--element <name>]
                                   reply <number> "<text>"  ·  resolve <number> [--reply "<text>"] [--reopen]
                                   (--ai signs a write as Claude; sends with the next "lecodes push")
-  desktop [run|update]          The native desktop host ('lecodes render --desktop' uses it too):
+  desktop [run|build|update]    The desktop target — the host 'lecodes render --desktop' uses too:
                                   no args shows the version status (selected / downloaded /
                                   newest published)
                                   run     compile the current project and open it in a real
@@ -224214,11 +225121,35 @@ ${c.bold("Commands:")}
                                           app.json fullscreen; --scale <0.5..4|fit> overrides
                                           the display scale — "fit" sizes a 1080p-designed app
                                           to the monitor with the density raised to match;
-                                          --entry overrides the entrypoint; asset() resources
+                                          --entry overrides the entrypoint; --fps draws the
+                                          host's frame counter in the corner — composited fps,
+                                          plus the 3D fps when they diverge; asset() resources
                                           load from the working tree — --remote-assets or
                                           --public-url <url> uses the server's copies instead)
+                                  build   stage a portable app folder (default dist/<name>/):
+                                          the cached host renamed to <Name>.exe + app.js +
+                                          assets/ (the project's files) + runtime/ (the engine's)
+                                          + app.json (the host reads title/size/fullscreen from
+                                          it) + app.ico from app.json "icon". Duplicate asset
+                                          basenames are a build error (they silently alias in
+                                          the bundle). Also spelled 'lecodes app build desktop'.
+                                          -o <dir>       output folder (default dist/<name>)
+                                          --slug <name>  folder/zip name override (Latin-only)
+                                          --renderer <gl|vulkan>  host + shader variant
+                                          --probe        headless-render the staged folder to PNG
+                                          --zip          <out>.zip, UTF-8/forward-slash entries
                                   update  move to the newest published release
                                           (cached in ~/.lecodes/renderer)
+  lightmap bake                 Bake static shadows + ambient occlusion into a lightmap atlas
+                                  (assets/lightmap/lightmap.{png,bake}) by running the app in
+                                  the desktop host: the statics are what the app registers
+                                  with Lightmap.add, the bake fires at its Lightmap.load call.
+                                  Props need UVs first: lecodes assets doctor … --lightmap-uv
+                                  --out <dir>        where the atlas lands (assets/lightmap)
+                                  --size <px>        atlas edge (4096)   --texel <m> density (0.02)
+                                  --sun-rays/--ao-rays <n>   quality (32 / 64)
+                                  --ao-distance <m>  AO reach (2)        --sun-angle <deg> (0.5)
+                                  --frames <n>       load headroom (900) --logs  host output
   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
@@ -224252,6 +225183,11 @@ ${c.bold("Commands:")}
                                 Skeleton, clips (+ root motion / first-frame-vs-rest per clip), meshes,
                                   materials, textures, bind sanity, duplicate names; --filmstrip renders
                                   a CPU-skinned PNG strip per clip (no GPU)
+  assets sky <env.exr|.hdr> [-o dir] [--size N] [--ibl-size N] [--ibl-only]
+                                Equirectangular HDR → the two cubemaps a scene needs: sky.ktx (sharp,
+                                  for 'skybox: { texture }') and ibl.ktx (prefiltered + SH, lights the
+                                  scene) — they are NOT interchangeable. Reports where the sun is in
+                                  the environment so the scene's light can be aimed to match
   assets doctor <in.glb|dir> [--fix] [--ktx2] [--dump]
                                 Analyze / fix a GLB against engine limits (bone cap 256, texture
                                   formats/size, KTX2 via toktx)
@@ -224300,15 +225236,8 @@ ${c.bold("Commands:")}
                                   --configuration <c>  Release (default) or Debug
                                   --no-aab             skip the .aab (APK only)
                                   --no-sync            skip the lecodes app sync step
-  app build desktop             Stage a portable desktop app folder (default dist/<name>/):
-                                  the cached host renamed to <Name>.exe + app.js + every asset +
-                                  app.json (the host ≥1.3.0 reads title/size/fullscreen from it)
-                                  + app.ico from app.json "icon". Duplicate asset basenames are
-                                  a build error (they silently alias in the bundle).
-                                  -o <dir>             output folder (default dist/<name>)
-                                  --slug <name>        folder/zip name override (e.g. Latin-only)
-                                  --probe              headless-render the staged folder to a PNG
-                                  --zip                <out>.zip, UTF-8/forward-slash entries
+  app build desktop             Same as 'lecodes desktop build' (kept for symmetry with the
+                                  ios/android shells) — see the desktop group above.
   app upload ios                Upload the archive to App Store Connect (then bumps buildNumber)
                                   --key-path <p8> --key-id <id> --issuer-id <id>
                                                        ASC API key; stored in ~/.lecodes/asc.json
@@ -224323,7 +225252,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: status3, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn, desktop, shaders, 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, lightmap };
 if (STANDALONE)
   commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
@@ -224338,9 +225267,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 = join33(dir, "package.json");
-      if (existsSync33(manifest)) {
-        const parsed = JSON.parse(readFileSync30(manifest, "utf8"));
+      const manifest = join37(dir, "package.json");
+      if (existsSync36(manifest)) {
+        const parsed = JSON.parse(readFileSync32(manifest, "utf8"));
         if (parsed.name === name)
           return parsed.version ?? "unknown";
       }