lecodes-cli 0.18.1 → 0.18.2

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/", "dist/"];
+  BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store", ".artifacts/", "dist/", ".env", ".env.*"];
 });
 
 // src/localFiles.ts
@@ -3174,7 +3174,7 @@ var require_source_map_support = __commonJS((exports, module) => {
 
 // ../../node_modules/.bun/typescript@5.8.3/node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS((exports, module) => {
-  var __dirname = "C:\\Users\\Den\\Desktop\\LeCodes\\lecodes\\node_modules\\.bun\\typescript@5.8.3\\node_modules\\typescript\\lib", __filename = "C:\\Users\\Den\\Desktop\\LeCodes\\lecodes\\node_modules\\.bun\\typescript@5.8.3\\node_modules\\typescript\\lib\\typescript.js";
+  var __dirname = "/Users/den/Desktop/Ingenuity/le-codes/node_modules/.bun/typescript@5.8.3/node_modules/typescript/lib", __filename = "/Users/den/Desktop/Ingenuity/le-codes/node_modules/.bun/typescript@5.8.3/node_modules/typescript/lib/typescript.js";
   /*! *****************************************************************************
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -173350,7 +173350,7 @@ var init_fonts = __esm(() => {
 
 // src/compile/assetIcons.ts
 import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname7, join as join14 } from "node:path";
 var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => createHash5("sha256").update(s).digest("hex").slice(0, 12), readText = async (registry, rel) => {
@@ -173363,13 +173363,13 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
     }
   }
   try {
-    return readFileSync11(join14(registry, rel), "utf8");
+    return readFileSync12(join14(registry, rel), "utf8");
   } catch {
     return null;
   }
 }, safeRead = (path) => {
   try {
-    return readFileSync11(path, "utf8");
+    return readFileSync12(path, "utf8");
   } catch {
     return null;
   }
@@ -173391,7 +173391,7 @@ var DEFAULT_REGISTRY, isHttp2 = (s) => /^https?:/i.test(s), sha122 = (s) => crea
   return JSON.parse(raw);
 }, readLock2 = (path) => {
   try {
-    const lock = JSON.parse(readFileSync11(path, "utf8"));
+    const lock = JSON.parse(readFileSync12(path, "utf8"));
     if (lock && typeof lock === "object" && lock.icons && lock.packs)
       return lock;
   } catch {}
@@ -214120,65 +214120,65 @@ var init_esm30 = __esm(() => {
 });
 
 // src/types.ts
-import { dirname as dirname13, join as join21, relative as relative3, sep } from "node:path";
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, readdirSync as readdirSync9, readFileSync as readFileSync17, rmSync as rmSync7, statSync as statSync7, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname13, join as join22, relative as relative3, sep } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync10, readFileSync as readFileSync18, rmSync as rmSync8, statSync as statSync8, writeFileSync as writeFileSync17 } from "node:fs";
 var TSCONFIG, listBundleFiles = (dir, base = dir) => {
-  if (!existsSync20(dir))
+  if (!existsSync21(dir))
     return [];
   const out = [];
-  for (const name of readdirSync9(dir)) {
-    const path2 = join21(dir, name);
-    if (statSync7(path2).isDirectory())
+  for (const name of readdirSync10(dir)) {
+    const path2 = join22(dir, name);
+    if (statSync8(path2).isDirectory())
       out.push(...listBundleFiles(path2, base));
     else
       out.push(relative3(base, path2).split(sep).join("/"));
   }
   return out;
 }, pruneEmptyDirs = (dir, root) => {
-  if (!existsSync20(dir) || !statSync7(dir).isDirectory())
+  if (!existsSync21(dir) || !statSync8(dir).isDirectory())
     return;
-  for (const name of readdirSync9(dir))
-    pruneEmptyDirs(join21(dir, name), root);
-  if (dir !== root && readdirSync9(dir).length === 0)
-    rmSync7(dir, { recursive: true });
+  for (const name of readdirSync10(dir))
+    pruneEmptyDirs(join22(dir, name), root);
+  if (dir !== root && readdirSync10(dir).length === 0)
+    rmSync8(dir, { recursive: true });
 }, writeTypeBundle = (root, bundle) => {
-  const typesDir = join21(root, LECODES_DIR, "types");
+  const typesDir = join22(root, LECODES_DIR, "types");
   const before = new Set(listBundleFiles(typesDir));
   const stats = { added: 0, updated: 0, removed: 0, total: Object.keys(bundle).length };
   for (const [path2, text] of Object.entries(bundle)) {
-    const dest = join21(typesDir, path2);
+    const dest = join22(typesDir, path2);
     if (!before.has(path2))
       stats.added++;
-    else if (readFileSync17(dest, "utf8") !== text)
+    else if (readFileSync18(dest, "utf8") !== text)
       stats.updated++;
     else
       continue;
-    mkdirSync14(dirname13(dest), { recursive: true });
-    writeFileSync16(dest, text);
+    mkdirSync15(dirname13(dest), { recursive: true });
+    writeFileSync17(dest, text);
   }
   for (const path2 of before) {
     if (path2 in bundle)
       continue;
-    rmSync7(join21(typesDir, path2));
+    rmSync8(join22(typesDir, path2));
     stats.removed++;
   }
   pruneEmptyDirs(typesDir, typesDir);
   return stats;
 }, bundleHash = (bundle) => sha256(Object.keys(bundle).sort().map((k) => `${k}\x00${bundle[k]}`).join("\x00")), readProjectTypeBundle = (root) => {
-  const typesDir = join21(root, LECODES_DIR, "types");
+  const typesDir = join22(root, LECODES_DIR, "types");
   const bundle = {};
   for (const path2 of listBundleFiles(typesDir))
-    bundle[path2] = readFileSync17(join21(typesDir, path2), "utf8");
+    bundle[path2] = readFileSync18(join22(typesDir, path2), "utf8");
   return bundle;
 }, materializeTypes = async (root, apiUrl) => writeTypeBundle(root, await getTypes(apiUrl)), readLocalTypeBundle = () => {
   const candidates = [
-    join21(distRoot, "runtime", "sdk-types.json"),
-    join21(distRoot, "..", "sdk", "dist", "types.json")
+    join22(distRoot, "runtime", "sdk-types.json"),
+    join22(distRoot, "..", "sdk", "dist", "types.json")
   ];
   for (const path2 of candidates) {
-    if (existsSync20(path2)) {
+    if (existsSync21(path2)) {
       try {
-        return JSON.parse(readFileSync17(path2, "utf8"));
+        return JSON.parse(readFileSync18(path2, "utf8"));
       } catch {}
     }
   }
@@ -214190,7 +214190,7 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   writeTypeBundle(root, bundle);
   return true;
 }, writeTsconfig = (root) => {
-  writeFileSync16(join21(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+  writeFileSync17(join22(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
 };
 var init_types4 = __esm(() => {
   init_api();
@@ -214216,14 +214216,14 @@ var init_types4 = __esm(() => {
 });
 
 // src/compile/designCompile.ts
-import { readFileSync as readFileSync18 } from "node:fs";
-import { basename as basename8 } from "node:path";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { basename as basename9 } from "node:path";
 var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) => {
   const { root, manifest, designDir, designKey, screenId, state } = opts;
   const entries = [];
   const scan2 = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
   for (const file of scan2.files) {
-    const type = manifest?.files[file.path]?.type ?? classifyKind(basename8(file.path));
+    const type = manifest?.files[file.path]?.type ?? classifyKind(basename9(file.path));
     if (type === "resource") {
       entries.push({
         path: file.path,
@@ -214234,7 +214234,7 @@ var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) =>
     } else if (type === "shader") {
       entries.push({ path: file.path, type, shaders: [] });
     } else {
-      entries.push({ path: file.path, type, text: readFileSync18(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync19(file.absPath, "utf8") });
     }
   }
   const invoke = state !== undefined ? `screen(${JSON.stringify(state)})` : "screen()";
@@ -214279,7 +214279,7 @@ var init_designCompile = __esm(() => {
 
 // src/browserAuth.ts
 import { createServer } from "node:http";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { hostname } from "node:os";
 var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
@@ -214304,16 +214304,16 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     args = [url];
   }
   try {
-    const child = spawn4(cmd, args, { stdio: "ignore", detached: true });
+    const child = spawn5(cmd, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
 }, browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser) => {
   const state = randomBytes2(16).toString("hex");
-  let resolve10;
+  let resolve11;
   let reject;
   const tokenPromise = new Promise((res, rej) => {
-    resolve10 = res;
+    resolve11 = res;
     reject = rej;
   });
   const server2 = createServer((req, res) => {
@@ -214331,7 +214331,7 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     }
     res.writeHead(200, { "content-type": "text/html" });
     res.end(SUCCESS_HTML);
-    resolve10(token);
+    resolve11(token);
   });
   await new Promise((res, rej) => {
     server2.once("error", rej);
@@ -214831,11 +214831,11 @@ var init_designTemplates = __esm(() => {
 });
 
 // src/designMeta.ts
-import { readFileSync as readFileSync19 } from "node:fs";
-import { join as join23 } from "node:path";
+import { readFileSync as readFileSync20 } from "node:fs";
+import { join as join24 } from "node:path";
 var PHONE_SIZE, readMetaFrames = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync19(join23(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync20(join24(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 {
@@ -214859,8 +214859,8 @@ __export(exports_design, {
   flushDesignComments: () => flushDesignComments,
   design: () => design
 });
-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";
+import { existsSync as existsSync24, mkdirSync as mkdirSync18, readFileSync as readFileSync21, readdirSync as readdirSync13, writeFileSync as writeFileSync19, appendFileSync } from "node:fs";
+import { basename as basename10, join as join25 } from "node:path";
 var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   let root;
   let manifest;
@@ -214875,13 +214875,13 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   return {
     root,
     manifest,
-    name: manifest?.name ?? basename9(root),
+    name: manifest?.name ?? basename10(root),
     dirName,
-    designDir: join24(root, dirName),
+    designDir: join25(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 }, loadDesignServer = async (ctx, needs = []) => {
-  if (!existsSync23(ctx.designDir)) {
+  if (!existsSync24(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let mod;
@@ -214913,17 +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 = join24(designDir, "screens");
-  if (!existsSync23(dir))
+  const dir = join25(designDir, "screens");
+  if (!existsSync24(dir))
     return [];
-  return readdirSync12(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
+  return readdirSync13(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
 }, writeMcpConfig = (ctx, port) => {
-  const path2 = join24(ctx.root, ".mcp.json");
+  const path2 = join25(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync23(path2)) {
+  if (existsSync24(path2)) {
     try {
-      config = JSON.parse(readFileSync20(path2, "utf8"));
+      config = JSON.parse(readFileSync21(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-design server by hand.");
       return;
@@ -214936,7 +214936,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     return;
   }
   config.mcpServers["lecodes-design"] = entry;
-  writeFileSync18(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync19(path2, JSON.stringify(config, null, 2) + `
 `);
   log(`${c.green(existing ? "updated" : "created")}   .mcp.json (lecodes-design MCP → ${entry.url})`);
 }, init = async (ctx, args) => {
@@ -214945,26 +214945,26 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join24("shared", "tokens.ts"), TOKENS_TS],
-    [join24("shared", "tabs.ts"), TABS_TS],
-    [join24("screens", "home.ts"), HOME_SCREEN_TS]
+    [join25("shared", "tokens.ts"), TOKENS_TS],
+    [join25("shared", "tabs.ts"), TABS_TS],
+    [join25("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync17(join24(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync17(join24(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync18(join25(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync18(join25(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join24(ctx.designDir, rel);
-    if (existsSync23(abs)) {
+    const abs = join25(ctx.designDir, rel);
+    if (existsSync24(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
     }
-    writeFileSync18(abs, content);
+    writeFileSync19(abs, content);
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join24(ctx.root, ".lecodesignore");
+  const ignorePath = join25(ctx.root, ".lecodesignore");
   const ignoreLines = [`${ctx.dirName}/.snapshots/`, `${ctx.dirName}/comments/`];
-  const current = existsSync23(ignorePath) ? readFileSync20(ignorePath, "utf8") : "";
+  const current = existsSync24(ignorePath) ? readFileSync21(ignorePath, "utf8") : "";
   const present = new Set(current.split(/\r?\n/));
   const missing = ignoreLines.filter((line) => !present.has(line));
   if (missing.length) {
@@ -214979,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(join24(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync18(join24(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync18(join25(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync19(join25(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.");
@@ -215028,16 +215028,16 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   killer.unref?.();
   const png2 = flagBool(args, "png") || flagStr(args, "png") !== undefined;
   const frames = readMetaFrames(ctx.designDir);
-  const outDir = flagStr(args, "out-dir") ?? join24(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join25(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)
-    mkdirSync17(outDir, { recursive: true });
+    mkdirSync18(outDir, { recursive: true });
   for (const id of targets) {
     const [width, height] = frames.screens[id]?.size ?? frames.defaultSize;
     let plan = [{ state: undefined, bases: [id] }];
     if (discover) {
-      const { states, canonical } = discover(readFileSync20(join24(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync21(join25(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -215078,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(join24(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join24(outDir, `${base}.json`)}`);
+        writeFileSync19(join25(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join25(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync18(join24(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join24(outDir, `${base}.png`)}`);
+          writeFileSync19(join25(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join25(outDir, `${base}.png`)}`);
         }
       }
     }
@@ -215384,7 +215384,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     note("Read them with:  lecodes design comments");
 }, flushDesignComments = async (args) => {
   const ctx = getContext(args);
-  if (!existsSync23(ctx.designDir))
+  if (!existsSync24(ctx.designDir))
     return null;
   const platform = optionalPlatform(ctx);
   if (!platform)
@@ -216526,7 +216526,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.18.1",
+  version: "0.18.2",
   dependencies: {
     "@letary/chisel": "^0.10.0",
     jimp: "^1.6.1"
@@ -216593,10 +216593,10 @@ var package_default = {
 // src/commands/app.ts
 init_manifest();
 init_config();
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { cpSync as cpSync3, existsSync as existsSync19, mkdirSync as mkdirSync13, readFileSync as readFileSync16, readdirSync as readdirSync8, rmSync as rmSync6, statSync as statSync6, writeFileSync as writeFileSync15 } from "node:fs";
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { cpSync as cpSync4, existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync17, readdirSync as readdirSync9, rmSync as rmSync7, statSync as statSync7, writeFileSync as writeFileSync16 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename7, dirname as dirname12, join as join20, resolve as resolve7 } from "node:path";
+import { basename as basename8, dirname as dirname12, join as join21, resolve as resolve8 } from "node:path";
 
 // src/commands/compile.ts
 init_api();
@@ -216721,7 +216721,7 @@ init_fonts();
 init_compile();
 import { execFile } from "node:child_process";
 import { createHash as createHash4, randomBytes } from "node:crypto";
-import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename as basename3, join as join13 } from "node:path";
 
@@ -216733,10 +216733,18 @@ import { join as join12, resolve } from "node:path";
 // src/releases.ts
 init_util();
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, mkdtempSync, renameSync, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, mkdtempSync, readFileSync as readFileSync10, renameSync, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join11 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json";
+var ARTIFACT_STAMP = ".lecodes-artifact.json";
+var cachedArtifactSha = (dir) => {
+  try {
+    return JSON.parse(readFileSync10(join11(dir, ARTIFACT_STAMP), "utf8")).sha256 ?? null;
+  } catch {
+    return null;
+  }
+};
 var semverNewer = (a, b) => {
   const pa = a.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
   for (let i = 0;i < 3; i++)
@@ -216778,15 +216786,20 @@ var downloadReleaseArchive = async (file, opts) => {
     const archiveName = file.url.split("/").pop() ?? "archive";
     const archive = join11(stage, archiveName);
     writeFileSync6(archive, bytes);
-    const winTar = join11(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
-    const tarExe = process.platform === "win32" && existsSync9(winTar) ? winTar : "tar";
-    const tar = spawnSync2(tarExe, ["-xf", archiveName], { cwd: stage, stdio: ["ignore", "ignore", "pipe"] });
-    if (tar.status !== 0)
-      throw new CliError(`Couldn't extract the archive: ${tar.stderr?.toString() ?? "tar failed"}`);
+    if (opts.extract) {
+      opts.extract(archive, stage);
+    } else {
+      const winTar = join11(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+      const tarExe = process.platform === "win32" && existsSync9(winTar) ? winTar : "tar";
+      const tar = spawnSync2(tarExe, ["-xf", archiveName], { cwd: stage, stdio: ["ignore", "ignore", "pipe"] });
+      if (tar.status !== 0)
+        throw new CliError(`Couldn't extract the archive: ${tar.stderr?.toString() ?? "tar failed"}`);
+    }
     rmSync(archive);
     const bad = opts.validate(stage);
     if (bad)
       throw new CliError(bad);
+    writeFileSync6(join11(stage, ARTIFACT_STAMP), JSON.stringify({ sha256: file.sha256, url: file.url }, null, 2));
     try {
       renameSync(stage, opts.dest);
     } catch {
@@ -216812,7 +216825,13 @@ var platformKey = () => {
     return "windows-x64";
   if (process.platform === "linux")
     return "linux-x64";
-  throw new CliError(process.platform === "darwin" ? "matc isn't published for macOS yet — push the project once so shaders compile on the server." : `matc isn't published for ${process.platform}.`);
+  if (process.platform === "darwin") {
+    if (process.arch !== "arm64") {
+      throw new CliError("matc isn't published for Intel macOS — set LECODES_MATC to a locally built matc " + "(creator-gl/out/cmake-release/filament/tools/matc), or push the project once so shaders " + "compile on the server.");
+    }
+    return "macos-arm64";
+  }
+  throw new CliError(`matc isn't published for ${process.platform}.`);
 };
 var cacheRoot = () => join12(homedir2(), ".lecodes", "matc");
 var findMatc = (dir) => {
@@ -216930,7 +216949,7 @@ var cleanMatcOutput = (err, tempName, realName) => {
 };
 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 desktopShaderPlatform = (platform, renderer) => platform === "win32" ? renderer === "vulkan" ? "desktop-vulkan" : "desktop" : platform === "darwin" ? "metal" : "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)
@@ -216948,7 +216967,7 @@ var applyLocalShaders = async (entries, opts) => {
   mkdirSync6(cacheDir, { recursive: true });
   const artifacts = [];
   for (const entry of shaderEntries) {
-    const text = readFileSync10(entry.absPath, "utf8");
+    const text = readFileSync11(entry.absPath, "utf8");
     const hash = shaderHash(text, matcId);
     const family = artifactFamily(text);
     const artifact = (platform) => `${hash}_${platform}.filamat`;
@@ -217011,7 +217030,7 @@ init_manifest();
 init_ignore();
 init_util();
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname8, join as join15, resolve as resolve2 } from "node:path";
 var FIRST_PARTY_PLUGINS = {
@@ -217029,8 +217048,13 @@ var resolveDesktopRenderer = (root, args) => {
   const value = String(raw).toLowerCase();
   if (value === "gl" || value === "opengl")
     return "gl";
-  if (value === "vulkan" || value === "vk")
+  if (value === "vulkan" || value === "vk") {
+    if (process.platform === "darwin") {
+      note('desktop.renderer "vulkan" is Windows-only — the macOS host renders with Metal.');
+      return "gl";
+    }
     return "vulkan";
+  }
   throw new CliError(`Unknown desktop renderer "${raw}". Use "gl" or "vulkan".`);
 };
 var desktopDefaultViewport = (root) => {
@@ -217046,7 +217070,7 @@ var readJson = (path) => {
   if (!existsSync13(path))
     return null;
   try {
-    return JSON.parse(readFileSync12(path, "utf8").replace(/^\uFEFF/, ""));
+    return JSON.parse(readFileSync13(path, "utf8").replace(/^\uFEFF/, ""));
   } catch {
     throw new CliError(`Invalid JSON in ${path}`);
   }
@@ -217077,7 +217101,7 @@ ${tail}`);
 };
 var ensureShellIgnored = (root, dir) => {
   const ignorePath = join15(root, ".lecodesignore");
-  const ignore = existsSync13(ignorePath) ? readFileSync12(ignorePath, "utf8") : DEFAULT_IGNORE_FILE;
+  const ignore = existsSync13(ignorePath) ? readFileSync13(ignorePath, "utf8") : DEFAULT_IGNORE_FILE;
   if (new RegExp(`^${dir}\\/$`, "m").test(ignore))
     return;
   const comment = ignore.includes("# Native app shells") ? "" : "# Native app shells — generated by `lecodes app init`, never pushed to LeCodes.\n";
@@ -218217,14 +218241,14 @@ buildNumber) — edit it there, then re-run \`lecodes app sync\`. Plugins are ma
 init_manifest();
 import { execFileSync as execFileSync2, spawn, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
-import { chmodSync, cpSync, existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync5, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync12 } from "node:fs";
+import { chmodSync, cpSync, existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync15, readdirSync as readdirSync5, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename5, dirname as dirname10, join as join17 } from "node:path";
 init_util();
 
 // src/commands/appIcon.ts
 init_util();
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
 import { dirname as dirname9, join as join16, resolve as resolve4 } from "node:path";
 var MASTER_PX = 1024;
 var DENSITIES = [
@@ -218354,7 +218378,7 @@ var restampManifestIcon = (androidDir) => {
   const path2 = join16(androidDir, "app", "src", "main", "AndroidManifest.xml");
   if (!existsSync15(path2))
     return;
-  const content = readFileSync13(path2, "utf8");
+  const content = readFileSync14(path2, "utf8");
   if (content.includes(`android:icon="@mipmap/ic_launcher"`))
     return;
   if (!/android:icon="[^"]*"/.test(content)) {
@@ -219274,7 +219298,7 @@ var shellSdkVersionAndroid = (androidDir) => {
   const path2 = join17(androidDir, "lecodes-runtime", "build.gradle.kts");
   if (!existsSync16(path2))
     return null;
-  const m = /io\.letary:lecodes-sdk(?:-(?:core|2d|3d))?:(\d+\.\d+\.\d+)@aar/.exec(readFileSync14(path2, "utf8"));
+  const m = /io\.letary:lecodes-sdk(?:-(?:core|2d|3d))?:(\d+\.\d+\.\d+)@aar/.exec(readFileSync15(path2, "utf8"));
   return m ? m[1] : null;
 };
 var GRADLE_WRAPPER_JAR_URL = "https://raw.githubusercontent.com/gradle/gradle/v8.13.0/gradle/wrapper/gradle-wrapper.jar";
@@ -219282,7 +219306,7 @@ var GRADLE_WRAPPER_JAR_SHA256 = "81a82aaea5abcc8ff68b3dfcb58b3c3c429378efd98e743
 var ensureGradleWrapperJar = async () => {
   const cached = join17(homedir5(), ".lecodes", "gradle-wrapper", GRADLE_VERSION, "gradle-wrapper.jar");
   if (existsSync16(cached))
-    return new Uint8Array(readFileSync14(cached));
+    return new Uint8Array(readFileSync15(cached));
   try {
     const res = await fetch(GRADLE_WRAPPER_JAR_URL);
     if (!res.ok)
@@ -219409,7 +219433,7 @@ var syncAndroid = async (root, config, prior) => {
     resources = prior.resources;
   } else {
     resources = await compileShell({ _: [], flags: { o: join17(assetsDir, "app.js") } }, { remotePatterns });
-    bundleJs = readFileSync14(join17(assetsDir, "app.js"), "utf8");
+    bundleJs = readFileSync15(join17(assetsDir, "app.js"), "utf8");
   }
   const requestedVariant = config.android?.variant ?? "auto";
   if (requestedVariant !== "auto" && !SDK_VARIANTS.includes(requestedVariant)) {
@@ -219546,7 +219570,7 @@ var restampAppBuildGradle = (androidDir, config, gradlePlugins) => {
     warn("android/app/build.gradle.kts is missing — run `lecodes app init android` on a clean tree to regenerate the shell.");
     return;
   }
-  let content = readFileSync14(path2, "utf8");
+  let content = readFileSync15(path2, "utf8");
   const before = content;
   const versionName = config.version ?? "1.0.0";
   const versionCode = config.android?.versionCode ?? 1;
@@ -219719,13 +219743,13 @@ var doctorAndroidChecks = async (root, config, check) => {
 };
 
 // src/commands/appDesktop.ts
-import { execFileSync as execFileSync3, spawn as spawn3 } from "node:child_process";
-import { cpSync as cpSync2, existsSync as existsSync18, mkdirSync as mkdirSync12, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync5, writeFileSync as writeFileSync14 } from "node:fs";
-import { basename as basename6, dirname as dirname11, join as join19, resolve as resolve6 } from "node:path";
+import { execFileSync as execFileSync5, spawn as spawn4 } from "node:child_process";
+import { cpSync as cpSync3, existsSync as existsSync19, mkdirSync as mkdirSync13, readdirSync as readdirSync8, rmSync as rmSync6, statSync as statSync6, writeFileSync as writeFileSync15 } from "node:fs";
+import { basename as basename7, dirname as dirname11, join as join20, resolve as resolve7 } from "node:path";
 
 // src/desktopRenderer.ts
-import { spawn as spawn2 } from "node:child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync2, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { execFileSync as execFileSync3, spawn as spawn2, spawnSync as spawnSync4 } from "node:child_process";
+import { copyFileSync as copyFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync2, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync4, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "node:os";
 import { join as join18, resolve as resolve5 } from "node:path";
 init_util();
@@ -219839,9 +219863,12 @@ var platformKey2 = (renderer = "gl") => {
   }
   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}.`);
+  if (process.platform === "darwin")
+    return process.arch === "arm64" ? "macos-arm64" : "macos-x64";
+  throw new CliError(`The LeCodes Desktop host isn't available on ${process.platform}.`);
 };
-var exeName = () => process.platform === "win32" ? "lecodes-desktop.exe" : "lecodes-desktop";
+var isMac = () => process.platform === "darwin";
+var exeName = () => process.platform === "win32" ? "lecodes-desktop.exe" : isMac() ? "lecodes-app" : "lecodes-desktop";
 var findExe = (dir) => {
   const name = exeName();
   for (const entry of readdirSync6(dir, { withFileTypes: true })) {
@@ -219867,13 +219894,33 @@ var installedDesktopVersions = () => {
 };
 var selectedDesktopVersion = () => {
   try {
-    const saved = JSON.parse(readFileSync15(currentFile(), "utf8")).version;
+    const saved = JSON.parse(readFileSync16(currentFile(), "utf8")).version;
     if (saved && /^\d+\.\d+\.\d+/.test(saved) && semverNewer(DESKTOP_RENDERER_VERSION, saved) > 0)
       return saved;
   } catch {}
   return DESKTOP_RENDERER_VERSION;
 };
 var fetchDesktopManifest = () => fetchReleaseProduct("desktop", "desktop");
+var pickMacVersion = (versions, wanted, key = "macos-arm64") => {
+  if (versions.find((v) => v.version === wanted)?.files[key])
+    return wanted;
+  const eligible = versions.filter((v) => v.files[key] && semverNewer(DESKTOP_RENDERER_VERSION, v.version) >= 0).map((v) => v.version).sort(semverNewer);
+  return eligible[0] ?? null;
+};
+var extractDmg = (archive, stage) => {
+  const mount = join18(stage, "mnt");
+  mkdirSync11(mount, { recursive: true });
+  execFileSync3("hdiutil", ["attach", "-nobrowse", "-readonly", "-quiet", "-mountpoint", mount, archive]);
+  try {
+    const app = readdirSync6(mount).find((n2) => n2.endsWith(".app"));
+    if (!app)
+      throw new CliError("The downloaded DMG holds no .app bundle.");
+    execFileSync3("cp", ["-R", join18(mount, app), join18(stage, app)]);
+  } finally {
+    spawnSync4("hdiutil", ["detach", "-quiet", "-force", mount]);
+    rmSync4(mount, { recursive: true, force: true });
+  }
+};
 var downloadDesktop = async (version, dest, renderer = "gl") => {
   const key = platformKey2(renderer);
   const entry = (await fetchDesktopManifest()).versions.find((v) => v.version === version);
@@ -219886,13 +219933,55 @@ var downloadDesktop = async (version, dest, renderer = "gl") => {
     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.`);
   }
-  note(`Downloading the native renderer (LeCodes Desktop ${version}, ${(file.size / 1024 / 1024).toFixed(1)} MB)…`);
+  note(`Downloading LeCodes Desktop ${version} [${key}] (${(file.size / 1024 / 1024).toFixed(1)} MB)…`);
   await downloadReleaseArchive(file, {
     cacheRoot: cacheRoot2(),
     dest,
-    validate: (dir) => findExe(dir) ? null : "The downloaded archive doesn't contain the desktop host binary."
+    validate: (dir) => findExe(dir) ? null : "The downloaded archive doesn't contain the desktop host binary.",
+    extract: file.url.toLowerCase().endsWith(".dmg") ? extractDmg : undefined
   });
 };
+var findMacHostExe = () => {
+  const candidates = [
+    ...["/Applications", join18(homedir6(), "Applications")].flatMap((root) => ["LeCodes Desktop.app", "LeCodes.app"].map((app) => join18(root, app)))
+  ].map((app) => join18(app, "Contents", "MacOS", "lecodes-app"));
+  return candidates.find((exe) => existsSync17(exe)) ?? null;
+};
+var resolveMacExe = async (selected) => {
+  const cached = findExe(join18(cacheRoot2(), `desktop-${selected}`));
+  if (cached)
+    return cached;
+  try {
+    const { versions } = await fetchDesktopManifest();
+    const version = pickMacVersion(versions, selected, platformKey2());
+    if (!version) {
+      throw new CliError(`No LeCodes Desktop release for ${platformKey2()} is published at or above ${DESKTOP_RENDERER_VERSION}.`);
+    }
+    const dir = join18(cacheRoot2(), `desktop-${version}`);
+    let exe = findExe(dir);
+    if (!exe) {
+      await downloadDesktop(version, dir);
+      exe = findExe(dir);
+      if (!exe)
+        throw new CliError(`Renderer cache at ${dir} is broken — delete the folder and retry.`);
+    }
+    if (version !== selected) {
+      note(`LeCodes Desktop ${selected} has no macOS build — using ${version}.`);
+      mkdirSync11(cacheRoot2(), { recursive: true });
+      writeFileSync13(currentFile(), JSON.stringify({ version }, null, 2));
+    }
+    return exe;
+  } catch (e2) {
+    const installed = findMacHostExe();
+    if (installed) {
+      warnErr(`${e2 instanceof Error ? e2.message : String(e2)}
+  Falling back to the installed host: ${installed}`);
+      return installed;
+    }
+    throw new CliError(`${e2 instanceof Error ? e2.message : String(e2)}
+` + "  No LeCodes Desktop.app is installed either — retry online (`lecodes desktop update`), install the DMG into\n" + "  /Applications, or point LECODES_DESKTOP_EXE at a build (…/LeCodes Desktop.app/Contents/MacOS/lecodes-app).");
+  }
+};
 var resolveDesktopExe = async (renderer = "gl") => {
   const override = process.env.LECODES_DESKTOP_EXE;
   if (override) {
@@ -219903,6 +219992,8 @@ var resolveDesktopExe = async (renderer = "gl") => {
   if (renderer === "vulkan")
     platformKey2(renderer);
   const version = selectedDesktopVersion();
+  if (isMac())
+    return resolveMacExe(version);
   const dir = join18(cacheRoot2(), `desktop-${version}${renderer === "vulkan" ? "-vulkan" : ""}`);
   let exe = existsSync17(dir) ? findExe(dir) : null;
   if (!exe) {
@@ -219914,13 +220005,23 @@ var resolveDesktopExe = async (renderer = "gl") => {
   return exe;
 };
 var updateDesktop = async () => {
-  const { latest } = await fetchDesktopManifest();
+  const manifest = await fetchDesktopManifest();
+  const latest = isMac() ? pickMacVersion(manifest.versions, manifest.latest, platformKey2()) : manifest.latest;
+  if (!latest)
+    throw new CliError(`No LeCodes Desktop release for ${platformKey2()} is published at or above ${DESKTOP_RENDERER_VERSION}.`);
   if (semverNewer(latest, DESKTOP_RENDERER_VERSION) > 0) {
     throw new CliError(`The newest published LeCodes Desktop is ${latest}, but this CLI needs ≥ ${DESKTOP_RENDERER_VERSION} ` + `for the render contract. Publish the desktop release first.`);
   }
   const before = selectedDesktopVersion();
   const dir = join18(cacheRoot2(), `desktop-${latest}`);
-  const hadIt = existsSync17(dir) && findExe(dir) !== null;
+  const published = (await fetchDesktopManifest()).versions.find((v) => v.version === latest)?.files[platformKey2()];
+  const cached = existsSync17(dir) && findExe(dir) !== null;
+  const republished = cached && published !== undefined && cachedArtifactSha(dir) !== published.sha256;
+  if (republished) {
+    note(`LeCodes Desktop ${latest} was republished since this machine cached it — downloading the current build.`);
+    rmSync4(dir, { recursive: true, force: true });
+  }
+  const hadIt = cached && !republished;
   if (!hadIt)
     await downloadDesktop(latest, dir);
   mkdirSync11(cacheRoot2(), { recursive: true });
@@ -220019,6 +220120,9 @@ var runDesktopDev = async (url, opts = {}) => {
   });
 };
 var runDesktopRender = async (js, resources, opts) => {
+  if (isMac()) {
+    throw new CliError("`lecodes render --desktop` isn't available on macOS yet — the macOS host has no headless mode " + "(CREATOR_HIDDEN / CREATOR_DUMP_PNG). `lecodes desktop run` and `lecodes desktop build` do work there.");
+  }
   const exe = await resolveDesktopExe(opts.renderer);
   const runDir = stageBundle(js, resources);
   try {
@@ -220087,15 +220191,333 @@ ${tail}` : "";
 
 // src/commands/appDesktop.ts
 init_util();
+
+// src/commands/appDesktopMac.ts
+init_util();
+import { execFileSync as execFileSync4, spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
+import { cpSync as cpSync2, existsSync as existsSync18, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readdirSync as readdirSync7, rmSync as rmSync5, statSync as statSync5, writeFileSync as writeFileSync14 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { basename as basename6, join as join19, resolve as resolve6 } from "node:path";
 var mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 var dirSize = (dir) => readdirSync7(dir, { withFileTypes: true }).reduce((sum, e2) => {
   const p2 = join19(dir, e2.name);
-  return sum + (e2.isDirectory() ? dirSize(p2) : statSync5(p2).size);
+  return sum + (e2.isDirectory() ? dirSize(p2) : e2.isSymbolicLink() ? 0 : statSync5(p2).size);
+}, 0);
+var cleanBundleName = (name) => name.replace(/[/:]/g, "").trim() || "App";
+var macHostAppOf = (exe) => {
+  const app = resolve6(exe, "..", "..", "..");
+  if (!app.endsWith(".app") || !existsSync18(join19(app, "Contents", "Info.plist"))) {
+    throw new CliError(`The macOS host must be an .app bundle (got ${exe}). Install LeCodes Desktop.app, or point ` + `LECODES_DESKTOP_EXE at <Build>.app/Contents/MacOS/lecodes-app — a bare SwiftPM binary has no ` + `resource bundles and can't be re-signed into an app.`);
+  }
+  return app;
+};
+var macHostProvidedNames = (exe) => {
+  const names3 = new Set;
+  const walk = (dir) => {
+    for (const e2 of readdirSync7(dir, { withFileTypes: true })) {
+      if (e2.isDirectory())
+        walk(join19(dir, e2.name));
+      else
+        names3.add(e2.name);
+    }
+  };
+  const res = join19(macHostAppOf(exe), "Contents", "Resources");
+  if (existsSync18(res))
+    walk(res);
+  return names3;
+};
+var plistRead = (plist, key) => {
+  const r2 = spawnSync5("/usr/libexec/PlistBuddy", ["-c", `Print :${key}`, plist], { encoding: "utf8" });
+  return r2.status === 0 ? r2.stdout.trim() : null;
+};
+var plistSet = (plist, key, value) => {
+  const quoted = `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+  const set = spawnSync5("/usr/libexec/PlistBuddy", ["-c", `Set :${key} ${quoted}`, plist], { stdio: "ignore" });
+  if (set.status !== 0)
+    execFileSync4("/usr/libexec/PlistBuddy", ["-c", `Add :${key} string ${quoted}`, plist], { stdio: "ignore" });
+};
+var macHostVersion = (exe) => {
+  const plist = join19(macHostAppOf(exe), "Contents", "Info.plist");
+  return plistRead(plist, "LeCodesHostVersion") ?? plistRead(plist, "CFBundleShortVersionString") ?? "unknown";
+};
+var macHostFeatures = (exe) => {
+  const raw = plistRead(join19(macHostAppOf(exe), "Contents", "Info.plist"), "LeCodesHostFeatures") ?? "";
+  return new Set(raw.split(`
+`).map((l2) => l2.trim()).filter((l2) => l2 && l2 !== "Array {" && l2 !== "}"));
+};
+var assertMacHostCanBundle = (exe) => {
+  if (macHostFeatures(exe).has("project-bundle"))
+    return;
+  throw new CliError(`This LeCodes Desktop host (${macHostAppOf(exe)}) predates project bundles — an app built from it would ` + `open the host's home screen instead of the project.
+` + "  Run `lecodes desktop update` (needs a published macOS host with project-bundle support), or point " + "LECODES_DESKTOP_EXE at a current build (…/LeCodes Desktop.app/Contents/MacOS/lecodes-app).");
+};
+var developerIdInKeychain = () => {
+  const r2 = spawnSync5("security", ["find-identity", "-v", "-p", "codesigning"], { encoding: "utf8" });
+  if (r2.status !== 0)
+    return null;
+  return /"(Developer ID Application: [^"]+)"/.exec(r2.stdout)?.[1] ?? null;
+};
+var resolveMacSigning = (cfg, overrides, keychainDeveloperId) => {
+  let identity = overrides.sign ?? overrides.env.LECODES_MACOS_SIGN_ID ?? cfg?.signing?.identity;
+  if (identity === undefined || identity === "" || identity === "auto")
+    identity = keychainDeveloperId() ?? "-";
+  if (identity === "adhoc" || identity === "ad-hoc")
+    identity = "-";
+  const notaryProfile = overrides.noNotarize ? null : overrides.notarize ?? overrides.env.LECODES_NOTARY_PROFILE ?? cfg?.notarize?.profile ?? null;
+  if (notaryProfile && identity === "-") {
+    throw new CliError(`Notarization needs a Developer ID signature — an ad-hoc-signed app can't be notarized.
+` + '  Set desktop.macos.signing.identity (or --sign) to a "Developer ID Application: …" certificate, ' + "or drop the notarize profile (--no-notarize).");
+  }
+  return { identity, notaryProfile: notaryProfile || null };
+};
+var FALLBACK_ENTITLEMENTS = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.cs.allow-jit</key>
+  <true/>
+</dict>
+</plist>
+`;
+var entitlementsFor = (hostApp) => {
+  const r2 = spawnSync5("codesign", ["-d", "--entitlements", "-", "--xml", hostApp], { encoding: "utf8" });
+  const xml = r2.status === 0 ? r2.stdout.trim() : "";
+  if (xml.startsWith("<?xml") && xml.includes("com.apple.security.cs.allow-jit"))
+    return xml + `
+`;
+  return FALLBACK_ENTITLEMENTS;
+};
+var codesignRetrying = async (args) => {
+  for (let attempt = 1;; attempt++) {
+    const r2 = spawnSync5("codesign", args, { encoding: "utf8" });
+    if (r2.status === 0)
+      return;
+    const out = (r2.stdout + `
+` + r2.stderr).trim();
+    if (!/timestamp/i.test(out) || attempt >= 5)
+      throw new CliError(`codesign failed:
+${out}`);
+    const delay = attempt * 15;
+    warn(`timestamp service unavailable (attempt ${attempt}/5) — retrying in ${delay}s…`);
+    await new Promise((r3) => setTimeout(r3, delay * 1000));
+  }
+};
+var signApp = async (app, signing, hostApp, tmp) => {
+  if (signing.identity === "-") {
+    note("Signing ad-hoc (runs on this Mac only — pass a Developer ID identity to distribute)…");
+    await codesignRetrying(["--force", "--sign", "-", app]);
+    return;
+  }
+  note(`Signing with "${signing.identity}" (Hardened Runtime + JIT entitlement)…`);
+  const ent = join19(tmp, "entitlements.plist");
+  writeFileSync14(ent, entitlementsFor(hostApp));
+  await codesignRetrying(["--force", "--options", "runtime", "--timestamp", "--entitlements", ent, "--sign", signing.identity, app]);
+  const verify = spawnSync5("codesign", ["--verify", "--strict", "--verbose=2", app], { encoding: "utf8" });
+  if (verify.status !== 0)
+    throw new CliError(`The signature doesn't verify:
+${(verify.stdout + verify.stderr).trim()}`);
+};
+var notarizeApp = (app, profile, tmp) => {
+  const zip = join19(tmp, `${basename6(app, ".app")}.zip`);
+  execFileSync4("ditto", ["-c", "-k", "--keepParent", app, zip]);
+  note(`Notarizing with profile "${profile}" — this waits on Apple (usually 1–5 minutes)…`);
+  const r2 = spawnSync5("xcrun", ["notarytool", "submit", zip, "--keychain-profile", profile, "--wait"], { encoding: "utf8" });
+  const out = (r2.stdout + `
+` + r2.stderr).trim();
+  const id = /id: ([0-9a-f-]{36})/.exec(out)?.[1];
+  if (r2.status !== 0 || !/status: Accepted/.test(out)) {
+    throw new CliError(`Notarization failed:
+${out}
+` + (id ? `  Details: xcrun notarytool log ${id} --keychain-profile ${profile}` : ""));
+  }
+  const staple = spawnSync5("xcrun", ["stapler", "staple", app], { encoding: "utf8" });
+  if (staple.status !== 0)
+    throw new CliError(`Stapling failed:
+${(staple.stdout + staple.stderr).trim()}`);
+  success("Notarized + stapled.");
+};
+var gatekeeperVerdict = (app) => {
+  const r2 = spawnSync5("spctl", ["-a", "-t", "exec", "-vv", app], { encoding: "utf8" });
+  const line = (r2.stdout + r2.stderr).trim().split(`
+`).filter((l2) => l2.includes("source=") || l2.includes("rejected") || l2.includes("accepted")).join("; ");
+  return { accepted: r2.status === 0, line: line || (r2.stdout + r2.stderr).trim() };
+};
+var writeIcns = async (root, config, dest, tmp) => {
+  const master = await loadIconMaster(root, config);
+  const { Jimp: Jimp2 } = await Promise.resolve().then(() => (init_esm30(), exports_esm2));
+  const SIZE = 1024, INSET = 100, RADIUS = 185;
+  const tileSize = SIZE - 2 * INSET;
+  const tile = new Jimp2({ width: tileSize, height: tileSize, color: master.background });
+  const art = master.image.clone();
+  art.resize({ w: tileSize, h: tileSize });
+  tile.composite(art, 0, 0);
+  const { data } = tile.bitmap;
+  for (let y2 = 0;y2 < tileSize; y2++) {
+    for (let x2 = 0;x2 < tileSize; x2++) {
+      const cx = x2 < RADIUS ? RADIUS : x2 >= tileSize - RADIUS ? tileSize - RADIUS - 1 : x2;
+      const cy = y2 < RADIUS ? RADIUS : y2 >= tileSize - RADIUS ? tileSize - RADIUS - 1 : y2;
+      const dx = x2 - cx, dy = y2 - cy;
+      if (dx * dx + dy * dy > RADIUS * RADIUS)
+        data[(y2 * tileSize + x2) * 4 + 3] = 0;
+    }
+  }
+  const canvas = new Jimp2({ width: SIZE, height: SIZE, color: 0 });
+  canvas.composite(tile, INSET, INSET);
+  const iconset = join19(tmp, "AppIcon.iconset");
+  mkdirSync12(iconset, { recursive: true });
+  for (const pt of [16, 32, 128, 256, 512]) {
+    for (const scale of [1, 2]) {
+      const px = pt * scale;
+      const frame = canvas.clone();
+      frame.resize({ w: px, h: px });
+      writeFileSync14(join19(iconset, `icon_${pt}x${pt}${scale === 2 ? "@2x" : ""}.png`), await frame.getBuffer("image/png"));
+    }
+  }
+  execFileSync4("iconutil", ["-c", "icns", "-o", dest, iconset]);
+};
+var probeMacApp = async (app, out, args) => {
+  const after = Number(flagStr(args, "after")) || 8;
+  const shot = join19(out, `${basename6(app, ".app")}-probe.png`);
+  rmSync5(shot, { force: true });
+  note(`Probe: launching the built app for ${after + 2}s (the window will show)…`);
+  await new Promise((done, fail) => {
+    const child = spawn3(join19(app, "Contents", "MacOS", "lecodes-app"), [], {
+      cwd: "/",
+      env: { ...process.env, LECODES_SNAPSHOT: shot, LECODES_SNAPSHOT_AFTER: String(after), LECODES_EXIT_AFTER: String(after + 2) },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const tail = [];
+    const sink = (d) => {
+      tail.push(String(d));
+      while (tail.length > 60)
+        tail.shift();
+    };
+    child.stdout.on("data", sink);
+    child.stderr.on("data", sink);
+    const killer = setTimeout(() => {
+      child.kill();
+      fail(new CliError("The probe timed out after 120s."));
+    }, 120000);
+    child.on("error", (e2) => {
+      clearTimeout(killer);
+      fail(new CliError(`Probe couldn't run: ${e2.message}`));
+    });
+    child.on("exit", (code) => {
+      clearTimeout(killer);
+      const detail = tail.length > 0 ? `
+${tail.join("").trimEnd()}` : "";
+      if (code === 0 && existsSync18(shot)) {
+        success(`Probe: ${shot}`);
+        done();
+      } else
+        fail(new CliError(`Probe failed (exit ${code}).${detail}`));
+    });
+  });
+};
+var buildMacApp = async (input) => {
+  const { root, config, name, slug, out, js, shipped, hostExe, args } = input;
+  const hostApp = macHostAppOf(hostExe);
+  assertMacHostCanBundle(hostExe);
+  const mac = config.desktop?.macos ?? {};
+  const appName = cleanBundleName(name);
+  const app = join19(out, `${appName}.app`);
+  const tmp = mkdtempSync3(join19(tmpdir3(), "lecodes-macapp-"));
+  try {
+    note(`  host: LeCodes Desktop ${macHostVersion(hostExe)} (${hostApp})`);
+    rmSync5(out, { recursive: true, force: true });
+    mkdirSync12(out, { recursive: true });
+    execFileSync4("cp", ["-R", hostApp, app]);
+    execFileSync4("xattr", ["-cr", app]);
+    rmSync5(join19(app, "Contents", "_CodeSignature"), { recursive: true, force: true });
+    rmSync5(join19(app, "Contents", "CodeResources"), { force: true });
+    const proj = join19(app, "Contents", "Resources", "project");
+    mkdirSync12(join19(proj, "assets"), { recursive: true });
+    writeFileSync14(join19(proj, "app.js"), js);
+    let assetBytes = 0, assetCount = 0;
+    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(proj, "assets", r2.name));
+      assetBytes += statSync5(r2.absPath).size;
+      assetCount++;
+    }
+    note(`  assets: ${assetCount} files, ${mb(assetBytes)} → Contents/Resources/project/assets/`);
+    writeJson(join19(proj, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
+    const plist = join19(app, "Contents", "Info.plist");
+    const bundleId = mac.bundleId ?? `codes.le.app.${slug.toLowerCase().replace(/[^a-z0-9.-]+/g, "-")}`;
+    plistSet(plist, "CFBundleName", appName);
+    plistSet(plist, "CFBundleDisplayName", appName);
+    plistSet(plist, "CFBundleIdentifier", bundleId);
+    plistSet(plist, "CFBundleShortVersionString", config.version ?? "1.0");
+    plistSet(plist, "CFBundleVersion", String(mac.buildNumber ?? 1));
+    if (mac.category)
+      plistSet(plist, "LSApplicationCategoryType", mac.category);
+    if (config.icon) {
+      await writeIcns(root, config, join19(app, "Contents", "Resources", "AppIcon.icns"), tmp);
+      plistSet(plist, "CFBundleIconFile", "AppIcon");
+      note("  icon: AppIcon.icns rendered from " + config.icon);
+    }
+    note(`  bundle: ${bundleId} ${config.version ?? "1.0"} (${mac.buildNumber ?? 1})`);
+    const signing = resolveMacSigning(mac, {
+      sign: flagStr(args, "sign"),
+      notarize: flagStr(args, "notarize"),
+      noNotarize: flagBool(args, "no-notarize"),
+      env: process.env
+    }, developerIdInKeychain);
+    await signApp(app, signing, hostApp, tmp);
+    if (signing.notaryProfile) {
+      notarizeApp(app, signing.notaryProfile, tmp);
+    } else if (signing.identity !== "-") {
+      warn("Signed with Developer ID but NOT notarized — Gatekeeper refuses a downloaded copy on every other Mac.");
+      warn("  Set desktop.macos.notarize.profile in app.json (a `xcrun notarytool store-credentials` profile) or pass --notarize <profile>.");
+    }
+    const verdict = gatekeeperVerdict(app);
+    log(`${verdict.accepted ? c.green("gatekeeper") : c.yellow("gatekeeper")} ${verdict.line}`);
+    if (signing.notaryProfile && !verdict.accepted) {
+      throw new CliError("The app was notarized but Gatekeeper still rejects it — see the spctl line above.");
+    }
+    writeFileSync14(join19(out, "README.txt"), readmeText(appName, !!signing.notaryProfile, signing.identity !== "-"));
+    success(`App: ${app}  (${mb(dirSize(app))})`);
+    if (flagBool(args, "probe"))
+      await probeMacApp(app, out, args);
+    if (flagBool(args, "zip")) {
+      const zip = join19(out, `${appName}.zip`);
+      rmSync5(zip, { force: true });
+      execFileSync4("ditto", ["-c", "-k", "--keepParent", app, zip]);
+      success(`Zip: ${zip} (${mb(statSync5(zip).size)})`);
+    } else {
+      note("Tip: --zip packs the .app for sending (ditto, structure-preserving).");
+    }
+  } finally {
+    rmSync5(tmp, { recursive: true, force: true });
+  }
+};
+var readmeText = (name, notarized, developerId) => `${name}
+${"=".repeat(Math.max(name.length, 4))}
+
+A LeCodes desktop app for macOS (Apple Silicon). Nothing to install: unzip and double-click
+${name}.app — or drag it to Applications first.
+
+${notarized ? `The app is signed and notarized by Apple: macOS asks once whether to open a downloaded app,
+then it runs.` : developerId ? `The app is signed but NOT notarized: macOS will refuse to open the downloaded copy. To run it
+anyway: System Settings › Privacy & Security › "Open Anyway" (after the first refused launch),
+or remove the quarantine flag in Terminal:  xattr -dr com.apple.quarantine "` + name + '.app"' : `The app is not signed for distribution: macOS will refuse to open the downloaded copy. To run it
+anyway: System Settings › Privacy & Security › "Open Anyway" (after the first refused launch),
+or remove the quarantine flag in Terminal:  xattr -dr com.apple.quarantine "` + name + '.app"'}
+`;
+
+// src/commands/appDesktop.ts
+var mb2 = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+var dirSize2 = (dir) => readdirSync8(dir, { withFileTypes: true }).reduce((sum, e2) => {
+  const p2 = join20(dir, e2.name);
+  return sum + (e2.isDirectory() ? dirSize2(p2) : statSync6(p2).size);
 }, 0);
 var initDesktop = async (args) => {
   const root = projectRoot();
-  const existing = readJson(join19(root, "app.json")) ?? {};
-  const name = flagStr(args, "name") ?? existing.name ?? basename6(root);
+  const existing = readJson(join20(root, "app.json")) ?? {};
+  const name = flagStr(args, "name") ?? existing.name ?? basename7(root);
   const window2 = {
     width: 1280,
     height: 800,
@@ -220105,7 +220527,7 @@ var initDesktop = async (args) => {
     ...flagBool(args, "fullscreen") ? { fullscreen: true } : {}
   };
   const config = { ...existing, name, desktop: { ...existing.desktop, window: window2 } };
-  writeJson(join19(root, "app.json"), config);
+  writeJson(join20(root, "app.json"), config);
   log(`${c.green("written")}   app.json  (desktop.window ${window2.width}×${window2.height}${window2.fullscreen ? ", fullscreen" : ""})`);
   log(`Next: ${c.bold("lecodes dev --desktop")} to develop, ${c.bold("lecodes app build desktop")} to package.`);
 };
@@ -220114,13 +220536,13 @@ var ASSETS_DIR = "assets";
 var RUNTIME_DIR = "runtime";
 var buildDesktop = async (args) => {
   const root = projectRoot();
-  const config = readJson(join19(root, "app.json")) ?? {};
-  const name = (config.name ?? basename6(root)).trim() || "app";
+  const config = readJson(join20(root, "app.json")) ?? {};
+  const name = (config.name ?? basename7(root)).trim() || "app";
   const slug = flagStr(args, "slug") ?? cleanFileName(name);
-  const out = resolve6(root, flagStr(args, "o", "out") ?? join19(root, "dist", slug));
-  if (existsSync18(out)) {
-    const entries = readdirSync7(out);
-    const looksLikeBuild = entries.length === 0 || entries.includes("app.js");
+  const out = resolve7(root, flagStr(args, "o", "out") ?? join20(root, "dist", slug));
+  if (existsSync19(out)) {
+    const entries = readdirSync8(out);
+    const looksLikeBuild = entries.length === 0 || entries.includes("app.js") || entries.some((e2) => e2.endsWith(".app"));
     if (!looksLikeBuild) {
       throw new CliError(`${out} exists and doesn't look like a previous desktop build — pick another -o or clear it yourself.`);
     }
@@ -220128,7 +220550,8 @@ var buildDesktop = async (args) => {
   if (config.desktop?.entry && flagStr(args, "entry") === undefined)
     args.flags.entry = config.desktop.entry;
   const renderer = resolveDesktopRenderer(root, args);
-  note(`Building "${name}" for desktop${renderer === "vulkan" ? " (Vulkan)" : ""}…`);
+  const mac = process.platform === "darwin";
+  note(`Building "${name}" for ${mac ? "macOS" : "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]));
@@ -220152,55 +220575,59 @@ var buildDesktop = async (args) => {
   const exe = await resolveDesktopExe(renderer);
   const hostDir = dirname11(exe);
   const IMPLICIT_PRELOADS = new Set(["uberarchive", "capture"]);
-  const hostProvided = new Set;
-  try {
-    for (const f3 of readdirSync7(join19(hostDir, "assets")))
-      hostProvided.add(f3);
-  } catch {}
+  const hostProvided = mac ? macHostProvidedNames(exe) : new Set;
+  if (!mac) {
+    try {
+      for (const f3 of readdirSync8(join20(hostDir, "assets")))
+        hostProvided.add(f3);
+    } catch {}
+  }
   const shippedNames = new Set(shipped.map((r2) => r2.name));
   const missing = [...wanted].filter((n2) => !shippedNames.has(n2) && !hostProvided.has(n2) && !IMPLICIT_PRELOADS.has(n2));
   if (missing.length > 0) {
     throw new CliError(`The bundle references assets with no local file: ${missing.join(", ")}`);
   }
+  if (mac)
+    return buildMacApp({ root, config, name, slug, out, js, shipped, hostExe: exe, args });
   const version = process.env.LECODES_DESKTOP_EXE ? "local build" : selectedDesktopVersion();
-  rmSync5(out, { recursive: true, force: true });
-  mkdirSync12(out, { recursive: true });
-  for (const entry of readdirSync7(hostDir, { withFileTypes: true })) {
+  rmSync6(out, { recursive: true, force: true });
+  mkdirSync13(out, { recursive: true });
+  for (const entry of readdirSync8(hostDir, { withFileTypes: true })) {
     if (entry.isFile() && entry.name.toLowerCase().endsWith(".dll")) {
-      cpSync2(join19(hostDir, entry.name), join19(out, entry.name));
+      cpSync3(join20(hostDir, entry.name), join20(out, entry.name));
     } else if (entry.isDirectory() && entry.name === "assets") {
-      cpSync2(join19(hostDir, entry.name), join19(out, RUNTIME_DIR), { recursive: true });
+      cpSync3(join20(hostDir, entry.name), join20(out, RUNTIME_DIR), { recursive: true });
     } else if (entry.isDirectory() && entry.name === "fonts") {
-      cpSync2(join19(hostDir, entry.name), join19(out, entry.name), { recursive: true });
+      cpSync3(join20(hostDir, entry.name), join20(out, entry.name), { recursive: true });
     }
   }
-  if (!existsSync18(join19(out, RUNTIME_DIR, "initial.js"))) {
+  if (!existsSync19(join20(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);
-  cpSync2(exe, join19(out, exeName2));
+  cpSync3(exe, join20(out, exeName2));
   note(`  host: LeCodes Desktop ${version}`);
-  writeFileSync14(join19(out, "app.js"), js);
+  writeFileSync15(join20(out, "app.js"), js);
   let assetBytes = 0, assetCount = 0;
   if (shipped.length > 0)
-    mkdirSync12(join19(out, ASSETS_DIR), { recursive: true });
+    mkdirSync13(join20(out, ASSETS_DIR), { recursive: true });
   for (const r2 of shipped) {
-    if (!r2.absPath || !existsSync18(r2.absPath) || !statSync5(r2.absPath).isFile()) {
+    if (!r2.absPath || !existsSync19(r2.absPath) || !statSync6(r2.absPath).isFile()) {
       warn(`asset "${r2.name}" (${r2.path}) has no local file — skipped`);
       continue;
     }
-    cpSync2(r2.absPath, join19(out, ASSETS_DIR, r2.name));
-    assetBytes += statSync5(r2.absPath).size;
+    cpSync3(r2.absPath, join20(out, ASSETS_DIR, r2.name));
+    assetBytes += statSync6(r2.absPath).size;
     assetCount++;
   }
-  note(`  assets: ${assetCount} files, ${mb(assetBytes)} → ${ASSETS_DIR}/`);
-  writeJson(join19(out, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
+  note(`  assets: ${assetCount} files, ${mb2(assetBytes)} → ${ASSETS_DIR}/`);
+  writeJson(join20(out, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
   if (config.icon) {
-    await writeIco(root, config, join19(out, "app.ico"));
+    await writeIco(root, config, join20(out, "app.ico"));
     note("  app.ico rendered from " + config.icon);
   }
-  writeFileSync14(join19(out, "README.txt"), "\uFEFF" + readmeText(name, exeName2, version));
-  success(`Portable build: ${out}  (${mb(dirSize(out))})`);
+  writeFileSync15(join20(out, "README.txt"), "\uFEFF" + readmeText2(name, exeName2, version));
+  success(`Portable build: ${out}  (${mb2(dirSize2(out))})`);
   if (flagBool(args, "probe"))
     await probeBuild(out, exeName2, config, args);
   if (flagBool(args, "zip"))
@@ -220232,15 +220659,15 @@ var writeIco = async (root, config, dest) => {
     header.writeUInt32LE(offset, e2 + 12);
     offset += pngs[i2].length;
   });
-  writeFileSync14(dest, Buffer.concat([header, ...pngs]));
+  writeFileSync15(dest, Buffer.concat([header, ...pngs]));
 };
 var probeBuild = async (out, exeName2, config, args) => {
   const win = config.desktop?.window;
   const frames = Number(flagStr(args, "frames")) || 90;
-  const shot = join19(dirname11(out), `${basename6(out)}-probe.png`);
+  const shot = join20(dirname11(out), `${basename7(out)}-probe.png`);
   note(`Probe: hidden render of the staged folder (${frames} frames)…`);
   await new Promise((done, fail) => {
-    const child = spawn3(join19(out, exeName2), [], {
+    const child = spawn4(join20(out, exeName2), [], {
       cwd: out,
       env: {
         ...process.env,
@@ -220269,7 +220696,7 @@ var probeBuild = async (out, exeName2, config, args) => {
     });
     child.on("exit", (code) => {
       clearTimeout(killer);
-      if (code === 0 && existsSync18(shot)) {
+      if (code === 0 && existsSync19(shot)) {
         success(`Probe: ${shot}`);
         done();
       } else {
@@ -220282,11 +220709,11 @@ ${tail.join("").trimEnd()}` : "";
 };
 var zipBuild = (out) => {
   const zip = `${out}.zip`;
-  rmSync5(zip, { force: true });
+  rmSync6(zip, { force: true });
   note("Zipping…");
   if (process.platform === "win32") {
     const q = (s2) => s2.replaceAll("'", "''");
-    execFileSync3("powershell", ["-NoProfile", "-Command", [
+    execFileSync5("powershell", ["-NoProfile", "-Command", [
       "Add-Type -AssemblyName System.IO.Compression.FileSystem;",
       `$src='${q(out)}'; $base=Split-Path $src -Parent;`,
       `$zip=[System.IO.Compression.ZipFile]::Open('${q(zip)}','Create');`,
@@ -220296,11 +220723,11 @@ var zipBuild = (out) => {
       "$zip.Dispose()"
     ].join(" ")], { stdio: ["ignore", "ignore", "pipe"] });
   } else {
-    execFileSync3("zip", ["-rq", zip, basename6(out)], { cwd: dirname11(out) });
+    execFileSync5("zip", ["-rq", zip, basename7(out)], { cwd: dirname11(out) });
   }
-  success(`Zip: ${zip} (${mb(statSync5(zip).size)})`);
+  success(`Zip: ${zip} (${mb2(statSync6(zip).size)})`);
 };
-var readmeText = (name, exeName2, version) => `${name}
+var readmeText2 = (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}.
@@ -220319,10 +220746,10 @@ var SDK_REPO = "letary/lecodes-ios-sdk";
 var SDK_MIN_VERSION = "1.2.0";
 var SDK_IDENTITY_VERSION = "1.6.0";
 var shellSdkVersion = (iosDir) => {
-  const path2 = join20(iosDir, "LeCodesRuntime", "Package.swift");
-  if (!existsSync19(path2))
+  const path2 = join21(iosDir, "LeCodesRuntime", "Package.swift");
+  if (!existsSync20(path2))
     return null;
-  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync16(path2, "utf8"));
+  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync17(path2, "utf8"));
   return m && VERSION_RE.test(m[1]) ? m[1] : null;
 };
 var IOS_SDK_OPTS = { repo: SDK_REPO, minVersion: SDK_MIN_VERSION, configKey: "ios.sdk" };
@@ -220336,11 +220763,11 @@ var appInit = async (args) => {
     throw new CliError(platform ? `Unsupported platform "${platform}" — use ios, android or desktop.` : "Usage: lecodes app init <ios|android|desktop> [--name <display name>] [--bundle-id <id>] [--team <team id>] [--variant auto|core|2d|3d|full] [--app-id <application id>] [--sdk <version|latest>]");
   }
   const root = projectRoot();
-  const iosDir = join20(root, "ios");
-  if (existsSync19(iosDir)) {
+  const iosDir = join21(root, "ios");
+  if (existsSync20(iosDir)) {
     throw new CliError("ios/ already exists — run `lecodes app sync` to update it.");
   }
-  const existing = readJson(join20(root, "app.json")) ?? {};
+  const existing = readJson(join21(root, "app.json")) ?? {};
   const variant = flagStr(args, "variant") ?? existing.ios?.variant ?? "auto";
   if (variant !== "auto" && !SDK_VARIANTS.includes(variant)) {
     throw new CliError(`--variant must be auto, ${SDK_VARIANTS.join(", ")} (got "${variant}")`);
@@ -220348,7 +220775,7 @@ var appInit = async (args) => {
   const sdkFlag = flagStr(args, "sdk") ?? existing.ios?.sdk;
   const sdkVersion = await resolveSdkVersion(process.env.LECODES_IOS_SDK ?? sdkFlag ?? "latest", null, IOS_SDK_OPTS);
   const sdk = sdkFlag === "latest" ? "latest" : sdkVersion;
-  const name = flagStr(args, "name") ?? existing.name ?? basename7(root);
+  const name = flagStr(args, "name") ?? existing.name ?? basename8(root);
   const config = {
     ...existing,
     name,
@@ -220362,7 +220789,7 @@ var appInit = async (args) => {
       buildNumber: existing.ios?.buildNumber ?? 1
     }
   };
-  writeJson(join20(root, "app.json"), config);
+  writeJson(join21(root, "app.json"), config);
   log(`${c.green("written")}   app.json`);
   ensureShellIgnored(root, "ios");
   const identity = {
@@ -220373,9 +220800,9 @@ var appInit = async (args) => {
     buildNumber: config.ios.buildNumber
   };
   const write = (rel, content) => {
-    const abs = join20(iosDir, rel);
-    mkdirSync13(dirname12(abs), { recursive: true });
-    writeFileSync15(abs, content);
+    const abs = join21(iosDir, rel);
+    mkdirSync14(dirname12(abs), { recursive: true });
+    writeFileSync16(abs, content);
     log(`${c.green("created")}   ios/${rel}`);
   };
   write("README.md", IOS_README);
@@ -220403,23 +220830,23 @@ var ensureSdkResourcesBundle = async (sdkVersion) => {
   const override = process.env.LECODES_SDK_RESOURCES;
   if (override) {
     note(`Using local resources bundle ${override} (LECODES_SDK_RESOURCES)`);
-    return resolve7(override);
+    return resolve8(override);
   }
-  const dir = join20(homedir7(), ".lecodes", "sdk-resources", sdkVersion);
-  const bundle = join20(dir, "LeCodesSDKResources.bundle");
-  if (existsSync19(bundle))
+  const dir = join21(homedir7(), ".lecodes", "sdk-resources", sdkVersion);
+  const bundle = join21(dir, "LeCodesSDKResources.bundle");
+  if (existsSync20(bundle))
     return bundle;
   const url = `https://github.com/${SDK_REPO}/releases/download/${sdkVersion}/LeCodesSDKResources.bundle.zip`;
   note(`Downloading LeCodesSDKResources.bundle (SDK ${sdkVersion})…`);
   const res = await fetch(url);
   if (!res.ok)
     throw new CliError(`Resources bundle download failed (HTTP ${res.status}) — ${url}`);
-  mkdirSync13(dir, { recursive: true });
-  const zip = join20(dir, "LeCodesSDKResources.bundle.zip");
-  writeFileSync15(zip, new Uint8Array(await res.arrayBuffer()));
-  execFileSync4("ditto", ["-x", "-k", zip, dir]);
-  rmSync6(zip);
-  if (!existsSync19(bundle))
+  mkdirSync14(dir, { recursive: true });
+  const zip = join21(dir, "LeCodesSDKResources.bundle.zip");
+  writeFileSync16(zip, new Uint8Array(await res.arrayBuffer()));
+  execFileSync6("ditto", ["-x", "-k", zip, dir]);
+  rmSync7(zip);
+  if (!existsSync20(bundle))
     throw new CliError(`No LeCodesSDKResources.bundle inside the release asset ${url}`);
   return bundle;
 };
@@ -220444,13 +220871,13 @@ var resolveUpdateUrl = (update, root) => {
 };
 var appSync = async (args) => {
   const root = projectRoot();
-  const config = readJson(join20(root, "app.json"));
+  const config = readJson(join21(root, "app.json"));
   const platform = args._[1];
   if (platform !== undefined && platform !== "ios" && platform !== "android") {
     throw new CliError(`Unknown platform "${platform}" — use ios or android.`);
   }
-  const hasIos = !!config?.ios && existsSync19(join20(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync19(join20(root, "android"));
+  const hasIos = !!config?.ios && existsSync20(join21(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync20(join21(root, "android"));
   if (platform === "ios" && !hasIos)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   if (platform === "android" && !hasAndroid)
@@ -220465,7 +220892,7 @@ var appSync = async (args) => {
     await syncAndroid(root, config, iosArtifacts);
 };
 var syncIos = async (root, config) => {
-  const iosDir = join20(root, "ios");
+  const iosDir = join21(root, "ios");
   if (!config.ios)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   const requestedVariant = config.ios.variant ?? "auto";
@@ -220475,14 +220902,14 @@ var syncIos = async (root, config) => {
   const linkedSdk = shellSdkVersion(iosDir);
   const sdkPin = process.env.LECODES_IOS_SDK ?? config.ios.sdk ?? linkedSdk ?? "latest";
   const sdkVersion = await resolveSdkVersion(sdkPin, linkedSdk, IOS_SDK_OPTS);
-  const lockPath = join20(root, "plugins.lock.json");
+  const lockPath = join21(root, "plugins.lock.json");
   const oldLock = readJson(lockPath)?.plugins ?? {};
   const pluginSpecs = Object.entries(config.plugins ?? {});
   const runtimePlugins = [];
   const infoValues = {};
   const entitlementValues = {};
   const newLock = {};
-  const sourcesDir = join20(iosDir, "LeCodesRuntime", "Sources");
+  const sourcesDir = join21(iosDir, "LeCodesRuntime", "Sources");
   for (const [id, spec] of pluginSpecs) {
     const plugin = resolvePlugin(id, spec, oldLock[id], "ios");
     const ios = plugin.manifest.ios;
@@ -220490,12 +220917,12 @@ var syncIos = async (root, config) => {
     const register = ios.register;
     if (!module || !register)
       throw new CliError(`Plugin "${id}": manifest ios.module / ios.register missing`);
-    const src = join20(plugin.dir, ios.sources ?? "ios");
-    if (!existsSync19(src))
+    const src = join21(plugin.dir, ios.sources ?? "ios");
+    if (!existsSync20(src))
       throw new CliError(`Plugin "${id}": sources dir ${src} missing`);
-    const dest = join20(sourcesDir, module);
-    rmSync6(dest, { recursive: true, force: true });
-    cpSync3(src, dest, { recursive: true });
+    const dest = join21(sourcesDir, module);
+    rmSync7(dest, { recursive: true, force: true });
+    cpSync4(src, dest, { recursive: true });
     if (ios.minSdk && VERSION_RE.test(ios.minSdk) && cmpVersion(sdkVersion, ios.minSdk) < 0) {
       throw new CliError(`Plugin "${id}" needs lecodes-ios-sdk ${ios.minSdk} but the shell links ${sdkVersion} — run \`lecodes app update\` (or set app.json ios.sdk).`);
     }
@@ -220510,9 +220937,9 @@ var syncIos = async (root, config) => {
     log(`${c.green("plugin")}    ${id}@${plugin.lock.version} (${plugin.lock.tag} → Sources/${module})`);
   }
   const keep = new Set(["LeCodesRuntime", ...runtimePlugins.map((p2) => p2.module)]);
-  for (const entry of existsSync19(sourcesDir) ? readdirSync8(sourcesDir) : []) {
-    if (!keep.has(entry) && statSync6(join20(sourcesDir, entry)).isDirectory()) {
-      rmSync6(join20(sourcesDir, entry), { recursive: true });
+  for (const entry of existsSync20(sourcesDir) ? readdirSync9(sourcesDir) : []) {
+    if (!keep.has(entry) && statSync7(join21(sourcesDir, entry)).isDirectory()) {
+      rmSync7(join21(sourcesDir, entry), { recursive: true });
       log(`${c.yellow("removed")}   ios/LeCodesRuntime/Sources/${entry}  (plugin uninstalled)`);
     }
   }
@@ -220520,11 +220947,11 @@ var syncIos = async (root, config) => {
   if (!Array.isArray(remotePatterns) || remotePatterns.some((p2) => typeof p2 !== "string")) {
     throw new CliError('app.json "resources.remote" must be an array of glob strings (e.g. ["videos/**"]).');
   }
-  const resourcesDir = join20(iosDir, "App", "Resources");
-  rmSync6(resourcesDir, { recursive: true, force: true });
-  mkdirSync13(resourcesDir, { recursive: true });
-  const resources = await compileShell({ _: [], flags: { o: join20(resourcesDir, "app.js") } }, { remotePatterns });
-  const bundleJs = readFileSync16(join20(resourcesDir, "app.js"), "utf8");
+  const resourcesDir = join21(iosDir, "App", "Resources");
+  rmSync7(resourcesDir, { recursive: true, force: true });
+  mkdirSync14(resourcesDir, { recursive: true });
+  const resources = await compileShell({ _: [], flags: { o: join21(resourcesDir, "app.js") } }, { remotePatterns });
+  const bundleJs = readFileSync17(join21(resourcesDir, "app.js"), "utf8");
   const { variant, detected } = resolveVariant(requestedVariant, bundleJs);
   const WHY = {
     core: "UI only",
@@ -220538,8 +220965,8 @@ var syncIos = async (root, config) => {
   const sdkProvided = new Set;
   if (variant === "3d" || variant === "full") {
     const sdkResources = await ensureSdkResourcesBundle(sdkVersion);
-    cpSync3(sdkResources, join20(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
-    for (const f3 of readdirSync8(sdkResources))
+    cpSync4(sdkResources, join21(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
+    for (const f3 of readdirSync9(sdkResources))
       if (f3 !== "Info.plist")
         sdkProvided.add(f3);
     log(`${c.green("resources")} LeCodesSDKResources.bundle (filament) → ios/App/Resources/`);
@@ -220566,7 +220993,7 @@ var syncIos = async (root, config) => {
     }
     if (candidates.length > 1)
       warn(`asset name collision: ${name} (${candidates.map((r2) => r2.path).join(", ")}) — embedding ${candidates[0].path}`);
-    cpSync3(candidates[0].absPath, join20(resourcesDir, name));
+    cpSync4(candidates[0].absPath, join21(resourcesDir, name));
     embedded++;
   }
   if (embedded > 0)
@@ -220586,14 +221013,14 @@ var syncIos = async (root, config) => {
   }
   if (shellUuid)
     log(`${c.green("identity")}  project ${shellUuid} baked into the shell (world identity)`);
-  writeFileSync15(join20(iosDir, "README.md"), IOS_README);
-  writeFileSync15(join20(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
-  writeFileSync15(join20(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins, shellUuid));
+  writeFileSync16(join21(iosDir, "README.md"), IOS_README);
+  writeFileSync16(join21(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
+  writeFileSync16(join21(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins, shellUuid));
   const mergedKeys = {};
   for (const [key, values] of Object.entries(infoValues))
     mergedKeys[key] = [...new Set(values)].join(" ");
   const updateUrl = resolveUpdateUrl(config.update, root);
-  writeFileSync15(join20(iosDir, "App", "Info.plist"), infoPlistTemplate(mergedKeys, updateUrl));
+  writeFileSync16(join21(iosDir, "App", "Info.plist"), infoPlistTemplate(mergedKeys, updateUrl));
   if (updateUrl)
     log(`${c.green("update")}    OTA source ${updateUrl} — checked natively at launch, new code applies next launch`);
   else if (!config.update) {
@@ -220604,10 +221031,10 @@ var syncIos = async (root, config) => {
     if (manifest)
       note(`tip: add "update": true to app.json for over-the-air JS updates — ship with \`lecodes push --publish\`, no store release`);
   }
-  if (pluginSpecs.length > 0 || existsSync19(lockPath))
+  if (pluginSpecs.length > 0 || existsSync20(lockPath))
     writeJson(lockPath, { plugins: newLock });
-  const pbxPath = join20(iosDir, "App.xcodeproj", "project.pbxproj");
-  let pbx = readFileSync16(pbxPath, "utf8").replace(/MARKETING_VERSION = [^;]+;/g, `MARKETING_VERSION = ${config.version ?? "1.0.0"};`).replace(/CURRENT_PROJECT_VERSION = [^;]+;/g, `CURRENT_PROJECT_VERSION = ${config.ios.buildNumber ?? 1};`);
+  const pbxPath = join21(iosDir, "App.xcodeproj", "project.pbxproj");
+  let pbx = readFileSync17(pbxPath, "utf8").replace(/MARKETING_VERSION = [^;]+;/g, `MARKETING_VERSION = ${config.version ?? "1.0.0"};`).replace(/CURRENT_PROJECT_VERSION = [^;]+;/g, `CURRENT_PROJECT_VERSION = ${config.ios.buildNumber ?? 1};`);
   const mergedEntitlements = {};
   for (const [key, values] of Object.entries(entitlementValues)) {
     if (values.every((v) => Array.isArray(v))) {
@@ -220628,7 +221055,7 @@ var syncIos = async (root, config) => {
   }
   const hasEntitlements = Object.keys(mergedEntitlements).length > 0;
   if (pbx.includes("CODE_SIGN_ENTITLEMENTS") || hasEntitlements) {
-    writeFileSync15(join20(iosDir, "App", "App.entitlements"), entitlementsTemplate(mergedEntitlements));
+    writeFileSync16(join21(iosDir, "App", "App.entitlements"), entitlementsTemplate(mergedEntitlements));
     if (hasEntitlements)
       log(`${c.green("caps")}      App/App.entitlements: ${Object.keys(mergedEntitlements).sort().join(", ")}`);
     if (!pbx.includes("CODE_SIGN_ENTITLEMENTS")) {
@@ -220644,7 +221071,7 @@ $2Info.plist,`);
       }
     }
   }
-  writeFileSync15(pbxPath, pbx);
+  writeFileSync16(pbxPath, pbx);
   if (config.icon) {
     await writeIosAppIcon(iosDir, await loadIconMaster(root, config));
   }
@@ -220656,7 +221083,7 @@ $2Info.plist,`);
 var appPlugin = async (args) => {
   const sub = args._[1];
   const root = projectRoot();
-  const configPath = join20(root, "app.json");
+  const configPath = join21(root, "app.json");
   const config = readJson(configPath);
   if (!config)
     throw new CliError("No app.json here — run `lecodes app init <ios|android>` first.");
@@ -220667,7 +221094,7 @@ var appPlugin = async (args) => {
       log("No plugins installed.");
       return;
     }
-    const lock = readJson(join20(root, "plugins.lock.json"))?.plugins ?? {};
+    const lock = readJson(join21(root, "plugins.lock.json"))?.plugins ?? {};
     for (const [id2, spec] of entries) {
       const pin = lock[id2] ? c.dim(`  ${lock[id2].repo} ${lock[id2].tag} (${lock[id2].commit.slice(0, 7)})`) : c.dim("  (not synced)");
       log(`${c.bold(id2)} ${spec}${pin}`);
@@ -220720,14 +221147,14 @@ var exportOptionsPlist = (method, teamId, destination) => `<?xml version="1.0" e
 `;
 var requireShell = () => {
   const root = projectRoot();
-  const config = readJson(join20(root, "app.json"));
-  if (!config?.ios || !existsSync19(join20(root, "ios"))) {
+  const config = readJson(join21(root, "app.json"));
+  if (!config?.ios || !existsSync20(join21(root, "ios"))) {
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   }
   return { root, config };
 };
 var updateSdkPin = async (root, config, args, checkOnly, platform) => {
-  const [label, repo, minVersion, shellVersion] = platform === "ios" ? ["lecodes-ios-sdk", SDK_REPO, SDK_MIN_VERSION, () => shellSdkVersion(join20(root, "ios"))] : ["lecodes-android-sdk", ANDROID_SDK_REPO, ANDROID_SDK_MIN_VERSION, () => shellSdkVersionAndroid(join20(root, "android"))];
+  const [label, repo, minVersion, shellVersion] = platform === "ios" ? ["lecodes-ios-sdk", SDK_REPO, SDK_MIN_VERSION, () => shellSdkVersion(join21(root, "ios"))] : ["lecodes-android-sdk", ANDROID_SDK_REPO, ANDROID_SDK_MIN_VERSION, () => shellSdkVersionAndroid(join21(root, "android"))];
   const section = config[platform];
   const wanted = flagStr(args, "sdk");
   let changed = false;
@@ -220758,19 +221185,19 @@ var updateSdkPin = async (root, config, args, checkOnly, platform) => {
   }
   if (!checkOnly && nextPin !== pin) {
     section.sdk = nextPin;
-    writeJson(join20(root, "app.json"), config);
+    writeJson(join21(root, "app.json"), config);
   }
   return changed;
 };
 var appUpdate = async (args) => {
   const root = projectRoot();
-  const config = readJson(join20(root, "app.json"));
+  const config = readJson(join21(root, "app.json"));
   const platform = args._[1];
   if (platform !== undefined && platform !== "ios" && platform !== "android") {
     throw new CliError(`Unknown platform "${platform}" — use ios or android.`);
   }
-  const hasIos = !!config?.ios && existsSync19(join20(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync19(join20(root, "android"));
+  const hasIos = !!config?.ios && existsSync20(join21(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync20(join21(root, "android"));
   if (platform === "ios" && !hasIos)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   if (platform === "android" && !hasAndroid)
@@ -220788,7 +221215,7 @@ var appUpdate = async (args) => {
     changed = await updateSdkPin(root, config, args, checkOnly, "ios") || changed;
   if (doAndroid)
     changed = await updateSdkPin(root, config, args, checkOnly, "android") || changed;
-  const lockPath = join20(root, "plugins.lock.json");
+  const lockPath = join21(root, "plugins.lock.json");
   const lock = readJson(lockPath)?.plugins ?? {};
   const specs = Object.entries(config.plugins ?? {});
   if (specs.length > 0 && !flagBool(args, "no-plugins")) {
@@ -220817,7 +221244,7 @@ var appUpdate = async (args) => {
       log(`${c.green("plugin")}    ${id} ${entry?.tag ?? "—"} → ${c.bold(tag)}`);
       changed = true;
     }
-    if (!checkOnly && existsSync19(lockPath))
+    if (!checkOnly && existsSync20(lockPath))
       writeJson(lockPath, { plugins: kept });
   }
   log("");
@@ -220837,9 +221264,9 @@ var appUpdate = async (args) => {
 };
 var appDoctor = async (_args) => {
   const root = projectRoot();
-  const config = readJson(join20(root, "app.json"));
-  const hasIos = !!config?.ios && existsSync19(join20(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync19(join20(root, "android"));
+  const config = readJson(join21(root, "app.json"));
+  const hasIos = !!config?.ios && existsSync20(join21(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync20(join21(root, "android"));
   if (!hasIos && !hasAndroid) {
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   }
@@ -220850,14 +221277,14 @@ var appDoctor = async (_args) => {
       failed++;
   };
   if (config?.icon) {
-    check(existsSync19(join20(root, config.icon)), `Icon master ${config.icon}`, `app.json "icon" points at a missing file — sync will fail`);
+    check(existsSync20(join21(root, config.icon)), `Icon master ${config.icon}`, `app.json "icon" points at a missing file — sync will fail`);
   }
   if (hasIos)
     await doctorIosChecks(root, config, check);
   if (hasAndroid) {
     await doctorAndroidChecks(root, config, check);
     if (!hasIos) {
-      const lock = readJson(join20(root, "plugins.lock.json"))?.plugins ?? {};
+      const lock = readJson(join21(root, "plugins.lock.json"))?.plugins ?? {};
       const wanted = Object.keys(config.plugins ?? {});
       const inSync = wanted.every((id) => lock[id]) && Object.keys(lock).every((id) => wanted.includes(id));
       check(wanted.length === 0 || inSync, "Plugins synced", "run `lecodes app sync`");
@@ -220876,22 +221303,22 @@ var doctorIosChecks = async (root, config, check) => {
   } catch {}
   check(xcodeVersion !== "", `Xcode CLI (${xcodeVersion || "not found"})`, "install Xcode + command line tools");
   check(!!config.ios.teamId, "Development team set", "lecodes app init wrote app.json — fill ios.teamId", false);
-  const iconDir = join20(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
-  const hasIcon = existsSync19(iconDir) && readdirSync8(iconDir).some((f3) => f3.endsWith(".png"));
+  const iconDir = join21(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
+  const hasIcon = existsSync20(iconDir) && readdirSync9(iconDir).some((f3) => f3.endsWith(".png"));
   check(hasIcon, "App icon present", "drop a 1024×1024 PNG into ios/App/Assets.xcassets/AppIcon.appiconset/ (App Store requires it)", false);
-  const bundle = join20(root, "ios", "App", "Resources", "app.js");
-  check(existsSync19(bundle), "Bundled app.js", "run `lecodes app sync`");
+  const bundle = join21(root, "ios", "App", "Resources", "app.js");
+  check(existsSync20(bundle), "Bundled app.js", "run `lecodes app sync`");
   const requestedVariant = config.ios.variant ?? "auto";
   const validVariant = requestedVariant === "auto" || SDK_VARIANTS.includes(requestedVariant);
   check(validVariant, `ios.variant "${requestedVariant}"`, `use "auto" or one of ${SDK_VARIANTS.join(", ")}`);
-  if (existsSync19(bundle) && validVariant) {
-    const { variant } = resolveVariant(requestedVariant, readFileSync16(bundle, "utf8"));
-    const pkg = readFileSync16(join20(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
+  if (existsSync20(bundle) && validVariant) {
+    const { variant } = resolveVariant(requestedVariant, readFileSync17(bundle, "utf8"));
+    const pkg = readFileSync17(join21(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
     const needsResources = variant === "3d" || variant === "full";
-    const hasResources = existsSync19(join20(root, "ios", "App", "Resources", "LeCodesSDKResources.bundle"));
+    const hasResources = existsSync20(join21(root, "ios", "App", "Resources", "LeCodesSDKResources.bundle"));
     check(pkg.includes(`"LeCodesSDK-${variant}"`) && (!needsResources || hasResources), `SDK variant ${variant}${needsResources ? " (+ filament resources)" : ""}`, "run `lecodes app sync`");
   }
-  const linked = shellSdkVersion(join20(root, "ios"));
+  const linked = shellSdkVersion(join21(root, "ios"));
   const pin = config.ios.sdk ?? "latest";
   check(!!linked, `SDK ${linked ?? "version unreadable"}`, "run `lecodes app sync`");
   if (linked && pin !== "latest") {
@@ -220903,27 +221330,27 @@ var doctorIosChecks = async (root, config, check) => {
       check(cmpVersion(linked, latest) >= 0, `SDK is the latest release (${latest})`, "run `lecodes app update`", false);
     } catch {}
   }
-  const lock = readJson(join20(root, "plugins.lock.json"))?.plugins ?? {};
+  const lock = readJson(join21(root, "plugins.lock.json"))?.plugins ?? {};
   const wanted = Object.keys(config.plugins ?? {});
   const inSync = wanted.every((id) => lock[id]) && Object.keys(lock).every((id) => wanted.includes(id));
   check(wanted.length === 0 || inSync, "Plugins synced", "run `lecodes app sync`");
-  const pbxFile = join20(root, "ios", "App.xcodeproj", "project.pbxproj");
-  if (existsSync19(pbxFile) && readFileSync16(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
-    check(existsSync19(join20(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
+  const pbxFile = join21(root, "ios", "App.xcodeproj", "project.pbxproj");
+  if (existsSync20(pbxFile) && readFileSync17(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
+    check(existsSync20(join21(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
   }
   if (wanted.includes("push")) {
-    const runtimeSwift = join20(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
-    const baked = existsSync19(runtimeSwift) && readFileSync16(runtimeSwift, "utf8").includes("bootProjectUuid");
+    const runtimeSwift = join21(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
+    const baked = existsSync20(runtimeSwift) && readFileSync17(runtimeSwift, "utf8").includes("bootProjectUuid");
     check(baked, "Push world identity baked", `without it Push.register() rejects "unavailable" — needs a pushed project (uuid), lecodes-ios-sdk ${SDK_IDENTITY_VERSION}+ and \`lecodes app sync\``, false);
   }
   if (config.update) {
-    const plist = readFileSync16(join20(root, "ios", "App", "Info.plist"), "utf8");
+    const plist = readFileSync17(join21(root, "ios", "App", "Info.plist"), "utf8");
     check(plist.includes("<key>LeCodesUpdateURL</key>"), "OTA update URL in Info.plist", "run `lecodes app sync`", false);
-    const appDir = join20(root, "ios", "App");
-    const callsUpdater = readdirSync8(appDir).some((f3) => f3.endsWith(".swift") && readFileSync16(join20(appDir, f3), "utf8").includes("LeCodesUpdater.activeBundle"));
+    const appDir = join21(root, "ios", "App");
+    const callsUpdater = readdirSync9(appDir).some((f3) => f3.endsWith(".swift") && readFileSync17(join21(appDir, f3), "utf8").includes("LeCodesUpdater.activeBundle"));
     check(callsUpdater, "App code launches via LeCodesUpdater", `no App/*.swift calls LeCodesUpdater.activeBundle() — downloaded updates would never run; see "Over-the-air updates" in ios/README.md for the ViewController snippet`, false);
   }
-  const asc = readJson(join20(homedir7(), ".lecodes", "asc.json"));
+  const asc = readJson(join21(homedir7(), ".lecodes", "asc.json"));
   check(!!asc?.keyPath, "App Store Connect API key configured", "pass --key-path/--key-id/--issuer-id to `lecodes app upload` once to store it", false);
 };
 var ARCHIVE_PATH = "ios/build/App.xcarchive";
@@ -220959,8 +221386,8 @@ var appBuild = async (args) => {
   success(`Archive: ios/build/App.xcarchive`);
   if (flagBool(args, "no-export"))
     return;
-  const optionsPath = join20(root, "ios", "build", "ExportOptions.plist");
-  writeFileSync15(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
+  const optionsPath = join21(root, "ios", "build", "ExportOptions.plist");
+  writeFileSync16(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
   note(`Exporting (.ipa, method ${method})…`);
   runTool(root, "xcodebuild", [
     "-exportArchive",
@@ -220979,10 +221406,10 @@ var appUpload = async (args) => {
     throw new CliError("Play upload isn't wired yet — upload android/app/build/outputs/bundle/release/*.aab in the Play Console (`lecodes app build android` produces it).");
   }
   const { root, config } = requireShell();
-  if (!existsSync19(join20(root, ARCHIVE_PATH))) {
+  if (!existsSync20(join21(root, ARCHIVE_PATH))) {
     throw new CliError("No archive at ios/build/App.xcarchive — run `lecodes app build ios` first.");
   }
-  const ascPath = join20(homedir7(), ".lecodes", "asc.json");
+  const ascPath = join21(homedir7(), ".lecodes", "asc.json");
   const stored = readJson(ascPath) ?? {};
   const keyPath = flagStr(args, "key-path") ?? stored.keyPath;
   const keyId = flagStr(args, "key-id") ?? stored.keyId;
@@ -220991,15 +221418,15 @@ var appUpload = async (args) => {
     throw new CliError(`App Store Connect API key needed: --key-path <AuthKey.p8> --key-id <id> --issuer-id <id>
 (create one at appstoreconnect.apple.com → Users and Access → Integrations; stored in ~/.lecodes/asc.json after first use)`);
   }
-  if (!existsSync19(keyPath))
+  if (!existsSync20(keyPath))
     throw new CliError(`API key file not found: ${keyPath}`);
   if (flagStr(args, "key-path")) {
-    mkdirSync13(dirname12(ascPath), { recursive: true });
+    mkdirSync14(dirname12(ascPath), { recursive: true });
     writeJson(ascPath, { keyPath, keyId, issuerId });
     note("Stored the key reference in ~/.lecodes/asc.json");
   }
-  const optionsPath = join20(root, "ios", "build", "UploadOptions.plist");
-  writeFileSync15(optionsPath, exportOptionsPlist("app-store-connect", config.ios.teamId ?? "", "upload"));
+  const optionsPath = join21(root, "ios", "build", "UploadOptions.plist");
+  writeFileSync16(optionsPath, exportOptionsPlist("app-store-connect", config.ios.teamId ?? "", "upload"));
   note("Uploading to App Store Connect… (processing continues on Apple's side)");
   runTool(root, "xcodebuild", [
     "-exportArchive",
@@ -221010,14 +221437,14 @@ var appUpload = async (args) => {
     "-exportPath",
     "ios/build/upload",
     "-authenticationKeyPath",
-    resolve7(keyPath),
+    resolve8(keyPath),
     "-authenticationKeyID",
     keyId,
     "-authenticationKeyIssuerID",
     issuerId,
     "-allowProvisioningUpdates"
   ]);
-  const configPath = join20(root, "app.json");
+  const configPath = join21(root, "app.json");
   const fresh = readJson(configPath);
   fresh.ios.buildNumber = (fresh.ios.buildNumber ?? 1) + 1;
   writeJson(configPath, fresh);
@@ -221028,19 +221455,19 @@ var appOpen = async (args) => {
   const root = projectRoot();
   let platform = args._[1];
   if (!platform) {
-    const hasIos = existsSync19(join20(root, "ios"));
-    const hasAndroid = existsSync19(join20(root, "android"));
+    const hasIos = existsSync20(join21(root, "ios"));
+    const hasAndroid = existsSync20(join21(root, "android"));
     if (hasIos && hasAndroid)
       throw new CliError("Both shells exist — `lecodes app open ios` or `lecodes app open android`.");
     platform = hasAndroid ? "android" : "ios";
   }
   if (platform === "ios") {
-    const proj = join20(root, "ios", "App.xcodeproj");
-    if (!existsSync19(proj))
+    const proj = join21(root, "ios", "App.xcodeproj");
+    if (!existsSync20(proj))
       throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
     if (process.platform !== "darwin")
       throw new CliError("Opening Xcode requires macOS.");
-    execFileSync4("open", [proj], { stdio: "ignore" });
+    execFileSync6("open", [proj], { stdio: "ignore" });
     success("Opened ios/App.xcodeproj in Xcode.");
     return;
   }
@@ -221073,8 +221500,8 @@ var app = async (args) => {
 init_api();
 init_config();
 init_manifest();
-import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync10 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync16, readdirSync as readdirSync11 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
 init_types4();
 init_ignore();
 init_util();
@@ -221095,11 +221522,11 @@ var clone3 = async (args) => {
   const uuid = parseUuid(args._[0]);
   const project = await getProject(apiUrl, token, uuid);
   const dir = args._[1] ?? slug(project.name);
-  const root = resolve8(dir);
-  if (existsSync21(root) && readdirSync10(root).length > 0) {
+  const root = resolve9(dir);
+  if (existsSync22(root) && readdirSync11(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync15(root, { recursive: true });
+  mkdirSync16(root, { recursive: true });
   info(c.dim(`Fetching project ${c.bold(project.name)}…`));
   const files = await materializeAssets(root, project, apiUrl, token, progress);
   endProgress();
@@ -221122,8 +221549,8 @@ init_config();
 init_manifest();
 init_types4();
 init_ignore();
-import { existsSync as existsSync22, mkdirSync as mkdirSync16, readdirSync as readdirSync11, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join22, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync17, readdirSync as readdirSync12, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join23, resolve as resolve10 } from "node:path";
 
 // src/commands/projectTemplates.ts
 var appClaudeMd = (name) => `# ${name} — LeCodes app
@@ -221263,21 +221690,21 @@ var create = async (args) => {
   if (!name)
     throw new CliError("Usage: lecodes create <name> [directory]");
   const dir = args._[1] ?? slug2(name);
-  const root = resolve9(dir);
-  if (existsSync22(root) && readdirSync11(root).length > 0) {
+  const root = resolve10(dir);
+  if (existsSync23(root) && readdirSync12(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync16(root, { recursive: true });
+  mkdirSync17(root, { recursive: true });
   info(c.dim(`Creating project ${c.bold(name)}…`));
   const { uuid } = await createProject(apiUrl, token, name, flagStr(args, "team"));
   info(c.dim("Fetching type definitions…"));
   await materializeTypes(root, apiUrl);
   writeTsconfig(root);
   writeDefaultIgnore(root);
-  writeFileSync17(join22(root, "main.ts"), STARTER);
-  writeFileSync17(join22(root, "CLAUDE.md"), appClaudeMd(name));
-  mkdirSync16(join22(root, ".claude"), { recursive: true });
-  writeFileSync17(join22(root, ".claude", "settings.json"), CLAUDE_SETTINGS);
+  writeFileSync18(join23(root, "main.ts"), STARTER);
+  writeFileSync18(join23(root, "CLAUDE.md"), appClaudeMd(name));
+  mkdirSync17(join23(root, ".claude"), { recursive: true });
+  writeFileSync18(join23(root, ".claude", "settings.json"), CLAUDE_SETTINGS);
   const commits = await getCommits(apiUrl, token, uuid);
   writeManifest(root, { uuid, apiUrl, name, baseHeadId: commits.headId, files: {} });
   success(`Created ${c.bold(name)} in ${c.bold(dir)}/`);
@@ -221344,6 +221771,10 @@ var status = async () => {
   log(`downloaded      ${installed.length > 0 ? installed.join(", ") : c.dim("none")}   ${c.dim("(~/.lecodes/renderer)")}`);
   if (process.env.LECODES_DESKTOP_EXE)
     log(`override        LECODES_DESKTOP_EXE=${process.env.LECODES_DESKTOP_EXE}`);
+  if (process.platform === "darwin") {
+    const installed2 = findMacHostExe();
+    log(`installed       ${installed2 ?? c.dim("none")}   ${c.dim("(offline fallback only)")}`);
+  }
   try {
     const { latest } = await fetchDesktopManifest();
     const hint = semverNewer(selected, latest) > 0 ? c.yellow("(newer — run `lecodes desktop update`)") : latest === selected ? c.dim("(up to date)") : c.dim("(older than the CLI's minimum — this desktop release isn't published yet)");
@@ -221371,16 +221802,16 @@ init_design();
 // src/commands/dev.ts
 init_manifest();
 init_ignore();
-import { existsSync as existsSync24, mkdirSync as mkdirSync18, readFileSync as readFileSync21, watch, writeFileSync as writeFileSync19 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync19, readFileSync as readFileSync22, watch, writeFileSync as writeFileSync20 } from "node:fs";
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { basename as basename10, join as join26 } from "node:path";
+import { basename as basename11, join as join27 } 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 join25 } from "node:path";
+import { createReadStream, statSync as statSync9 } from "node:fs";
+import { join as join26 } from "node:path";
 init_projectCompile();
 init_fonts();
 init_assetIcons();
@@ -221654,14 +222085,14 @@ var sendText = (res, status2, type, body) => {
   res.end(body);
 };
 var sendJson = (res, status2, body) => sendText(res, status2, "application/json", JSON.stringify(body));
-var readBody = (req) => new Promise((resolve10) => {
+var readBody = (req) => new Promise((resolve11) => {
   let body = "";
   req.on("data", (c4) => {
     if (body.length < 256 * 1024)
       body += c4.toString("utf8");
   });
-  req.on("end", () => resolve10(body));
-  req.on("error", () => resolve10(body));
+  req.on("end", () => resolve11(body));
+  req.on("error", () => resolve11(body));
 });
 var startDevServer = async (options) => {
   const { root, manifest, name, origin, token, entryOverride } = options;
@@ -221766,9 +222197,9 @@ var startDevServer = async (options) => {
       const name2 = route.slice("/shaders/".length);
       if (!isShaderArtifactName(name2))
         return sendText(res, 400, "text/plain", "Bad path");
-      const abs = join25(shadersCacheDir(root), name2);
+      const abs = join26(shadersCacheDir(root), name2);
       try {
-        if (!statSync8(abs).isFile())
+        if (!statSync9(abs).isFile())
           throw new Error("not a file");
       } catch {
         return sendText(res, 404, "text/plain", "Not found");
@@ -221785,7 +222216,7 @@ var startDevServer = async (options) => {
         return sendText(res, 400, "text/plain", "Bad path");
       }
       const abs = resolveLocalPath(root, key);
-      if (!abs || !statSync8(abs).isFile())
+      if (!abs || !statSync9(abs).isFile())
         return sendText(res, 404, "text/plain", "Not found");
       res.writeHead(200, { "content-type": contentType(key), "cache-control": "no-store" });
       createReadStream(abs).pipe(res);
@@ -221828,11 +222259,11 @@ var startDevServer = async (options) => {
     if (conn)
       clients.add(conn);
   });
-  await new Promise((resolve10, reject) => {
+  await new Promise((resolve11, reject) => {
     server2.once("error", reject);
     server2.listen(options.port, options.bind ?? "0.0.0.0", () => {
       server2.removeListener("error", reject);
-      resolve10();
+      resolve11();
     });
   });
   const address = server2.address();
@@ -221880,24 +222311,24 @@ var lanCandidates = () => {
   return out.sort((x2, y2) => x2.rank - y2.rank).map(({ address, iface }) => ({ address, iface }));
 };
 var loadDevToken = (root) => {
-  const path2 = join26(root, LECODES_DIR, "dev.json");
+  const path2 = join27(root, LECODES_DIR, "dev.json");
   try {
-    const token2 = JSON.parse(readFileSync21(path2, "utf8")).token;
+    const token2 = JSON.parse(readFileSync22(path2, "utf8")).token;
     if (token2 && /^[a-z0-9]{8,}$/.test(token2))
       return token2;
   } catch {}
   const token = randomBytes3(6).toString("hex");
-  mkdirSync18(join26(root, LECODES_DIR), { recursive: true });
-  writeFileSync19(path2, JSON.stringify({ token }, null, 2) + `
+  mkdirSync19(join27(root, LECODES_DIR), { recursive: true });
+  writeFileSync20(path2, JSON.stringify({ token }, null, 2) + `
 `);
   return token;
 };
 var printQr = async (url) => {
   try {
     const qrcode = (await Promise.resolve().then(() => __toESM(require_main(), 1))).default;
-    await new Promise((resolve10) => qrcode.generate(url, { small: true }, (out) => {
+    await new Promise((resolve11) => qrcode.generate(url, { small: true }, (out) => {
       log(out);
-      resolve10();
+      resolve11();
     }));
   } catch {
     note("(couldn't render a QR code — open the URL below on the device)");
@@ -221913,7 +222344,7 @@ var dev = async (args) => {
     root = process.cwd();
     manifest = null;
   }
-  const name = manifest?.name ?? basename10(root);
+  const name = manifest?.name ?? basename11(root);
   if (typeof globalThis.Bun !== "undefined") {
     warnErr("Running under Bun: the websocket reload channel doesn't work here — run `lecodes dev` with Node (or use ?t=poll on the device URL).");
   }
@@ -222005,7 +222436,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(join26(root, LECODES_DIR, "manifest.json")))
+  if (existsSync25(join27(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.`);
@@ -222034,8 +222465,8 @@ init_localFiles();
 
 // src/serverDiff.ts
 init_localFiles();
-import { readFileSync as readFileSync22 } from "node:fs";
-import { basename as basename11 } from "node:path";
+import { readFileSync as readFileSync23 } from "node:fs";
+import { basename as basename12 } from "node:path";
 var isTextAsset = (t2) => t2 === "text" || t2 === "shader" || t2 === "scene";
 var computeServerDiff = (project, scan2) => {
   const pathById = buildPaths(project.assets);
@@ -222052,8 +222483,8 @@ var computeServerDiff = (project, scan2) => {
     const server2 = serverByPath.get(path2);
     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 ? readFileSync22(local.absPath, "utf8") : undefined });
+      const text = isTextKind(classifyKind(basename12(path2)));
+      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync23(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server2 && !local) {
@@ -222064,12 +222495,12 @@ var computeServerDiff = (project, scan2) => {
     if (server2 && local) {
       if (isTextAsset(server2.type)) {
         const serverText = server2.text ?? "";
-        const localText = readFileSync22(local.absPath, "utf8");
+        const localText = readFileSync23(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(readFileSync22(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync23(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path: path2, status: "modified", binary: true });
         }
@@ -222227,8 +222658,8 @@ var statusLabel = (e2) => e2.status === "added" ? c.green("  added    ") : e2.st
 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 join27, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync20, writeFileSync as writeFileSync21 } from "node:fs";
+import { basename as basename13, dirname as dirname14, join as join28, resolve as resolve11 } 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\`.
@@ -222336,18 +222767,18 @@ Full command list: \`lecodes --help\`.
 `;
 var init2 = async (args) => {
   const dirArg = (args._[0] ?? ".").replace(/[/\\]+$/, "") || ".";
-  const root = resolve10(dirArg);
-  const name = basename12(root);
-  mkdirSync19(root, { recursive: true });
+  const root = resolve11(dirArg);
+  const name = basename13(root);
+  mkdirSync20(root, { recursive: true });
   let created = 0;
   const write = (rel, content) => {
-    const abs = join27(root, rel);
-    if (existsSync25(abs)) {
+    const abs = join28(root, rel);
+    if (existsSync26(abs)) {
       note(`kept      ${rel}`);
       return;
     }
-    mkdirSync19(dirname14(abs), { recursive: true });
-    writeFileSync20(abs, content);
+    mkdirSync20(dirname14(abs), { recursive: true });
+    writeFileSync21(abs, content);
     log(`${c.green("created")}   ${rel}`);
     created++;
   };
@@ -222394,8 +222825,8 @@ init_config();
 init_ignore();
 init_localFiles();
 init_manifest();
-import { existsSync as existsSync26 } from "node:fs";
-import { basename as basename14, join as join28, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { basename as basename15, join as join29, resolve as resolve12 } from "node:path";
 init_types4();
 init_util();
 
@@ -222404,8 +222835,8 @@ init_api();
 init_config();
 init_manifest();
 init_localFiles();
-import { basename as basename13 } from "node:path";
-import { readFileSync as readFileSync23 } from "node:fs";
+import { basename as basename14 } from "node:path";
+import { readFileSync as readFileSync24 } from "node:fs";
 init_util();
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
@@ -222461,14 +222892,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan2.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename13(file.path));
+    const kind = source?.type ?? classifyKind(basename14(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync23(file.absPath, "utf8");
+      entry.text = readFileSync24(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename13(file.path), readFileSync23(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename14(file.path), readFileSync24(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -222575,10 +223006,10 @@ var link = async (args) => {
   const apiUrl = requireApiUrl(config);
   const token = requireToken(config);
   const dirArg = args._[0];
-  const root = dirArg ? resolve11(dirArg) : process.cwd();
-  if (!existsSync26(root))
+  const root = dirArg ? resolve12(dirArg) : process.cwd();
+  if (!existsSync27(root))
     throw new CliError(`No such directory: ${root}`);
-  if (existsSync26(join28(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
+  if (existsSync27(join29(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;
@@ -222605,7 +223036,7 @@ var link = async (args) => {
     }
     name = project.name;
   } else {
-    name = flagStr(args, "name") ?? basename14(root);
+    name = flagStr(args, "name") ?? basename15(root);
     info(c.dim(`Creating project ${c.bold(name)}…`));
     uuid = (await createProject(apiUrl, token, name, flagStr(args, "team"))).uuid;
     files = {};
@@ -222642,10 +223073,10 @@ var link = async (args) => {
 
 // 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";
+import { existsSync as existsSync28, mkdirSync as mkdirSync21, mkdtempSync as mkdtempSync4, rmSync as rmSync9, statSync as statSync10, unlinkSync, writeFileSync as writeFileSync22 } from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join30, relative as relative4, resolve as resolve13 } from "node:path";
 init_util();
 var num = (args, key, fallback, min, max) => {
   const raw = flagStr(args, key);
@@ -222658,20 +223089,20 @@ var num = (args, key, fallback, min, max) => {
 };
 var findToktx = () => {
   const env = process.env.KTX_TOKTX;
-  if (env && existsSync27(env))
+  if (env && existsSync28(env))
     return env;
-  for (const base of [process.env.LOCALAPPDATA && join29(process.env.LOCALAPPDATA, "Programs"), process.env.ProgramFiles]) {
+  for (const base of [process.env.LOCALAPPDATA && join30(process.env.LOCALAPPDATA, "Programs"), process.env.ProgramFiles]) {
     if (!base)
       continue;
-    const guess = join29(base, "KTX-Software", "bin", "toktx.exe");
-    if (existsSync27(guess))
+    const guess = join30(base, "KTX-Software", "bin", "toktx.exe");
+    if (existsSync28(guess))
       return guess;
   }
   return "toktx";
 };
 var checkToktx = (toktx) => {
   try {
-    const p2 = spawnSync4(toktx, ["--version"], { encoding: "utf8" });
+    const p2 = spawnSync6(toktx, ["--version"], { encoding: "utf8" });
     if (p2.status === 0)
       return (p2.stdout ?? "").toString().trim() || "toktx";
   } catch {}
@@ -222687,7 +223118,7 @@ var requireToktx = () => {
 };
 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" });
+  const p2 = spawnSync6(toktx, args, { encoding: "utf8" });
   if (p2.status !== 0) {
     throw new CliError(`toktx failed (${p2.status ?? p2.error?.message ?? "?"}) while encoding ${ktx2}:
 ${(p2.stderr || p2.stdout || "").trim()}`);
@@ -222701,10 +223132,10 @@ var bake = async (args) => {
     root = process.cwd();
   }
   const toktx = requireToktx();
-  const outDir = resolve12(root, flagStr(args, "out") ?? "assets/lightmap");
+  const outDir = resolve13(root, flagStr(args, "out") ?? "assets/lightmap");
   const entryFlag = flagStr(args, "entry");
   const entryFile = entryFlag ?? "main.ts";
-  if (!existsSync27(resolve12(root, entryFile))) {
+  if (!existsSync28(resolve13(root, entryFile))) {
     throw new CliError(`No ${entryFile} in ${root} — pass --entry <file> (the file that builds the scene and calls Lightmap.load).`);
   }
   const cfg = {
@@ -222727,7 +223158,7 @@ var bake = async (args) => {
   const entryText = `globalThis.__lecodesLightmap = ${JSON.stringify(cfg)}
 import ${JSON.stringify(importPath)}
 `;
-  mkdirSync20(outDir, { recursive: true });
+  mkdirSync21(outDir, { recursive: true });
   ensurePlaceholders(outDir);
   const desktopRenderer = resolveDesktopRenderer(root, args);
   const { js, resources } = await buildBundle(args, undefined, {
@@ -222736,8 +223167,8 @@ import ${JSON.stringify(importPath)}
     extraEntries: [{ path: entryPath, type: "text", text: entryText }],
     entryOverride: entryPath
   });
-  const scratch = mkdtempSync3(join29(tmpdir3(), "lecodes-lightmap-"));
-  const outPng = join29(scratch, "frame.png");
+  const scratch = mkdtempSync4(join30(tmpdir4(), "lecodes-lightmap-"));
+  const outPng = join30(scratch, "frame.png");
   note(`Baking ${cfg.size}² at ${(cfg.texel * 100).toFixed(1)} cm texels (${cfg.sunRays} sun + ${cfg.aoRays} AO rays) → ${relative4(root, outDir) || "."}…`);
   let output = "";
   try {
@@ -222759,7 +223190,7 @@ import ${JSON.stringify(importPath)}
       throw e2;
     output = msg;
   } finally {
-    rmSync8(scratch, { recursive: true, force: true });
+    rmSync9(scratch, { recursive: true, force: true });
   }
   const lines = output.split(/\r?\n/).filter((l2) => l2.startsWith("[lightmap]"));
   for (const l2 of lines) {
@@ -222769,17 +223200,17 @@ import ${JSON.stringify(importPath)}
     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))
+    const png2 = join30(outDir, "lightmap.png");
+    const ktx2 = join30(outDir, "lightmap.ktx2");
+    if (!existsSync28(png2))
       throw new CliError(`The host reported a bake but ${png2} is missing.`);
     const t0 = Date.now();
     encodeKtx2(toktx, png2, ktx2);
-    const pngKb = Math.round(statSync9(png2).size / 1024), ktxKb = Math.round(statSync9(ktx2).size / 1024);
+    const pngKb = Math.round(statSync10(png2).size / 1024), ktxKb = Math.round(statSync10(ktx2).size / 1024);
     unlinkSync(png2);
     logErr(c.dim(`  encoded lightmap.ktx2 (UASTC + mips, ${ktxKb} KB from a ${pngKb} KB raster) in ${((Date.now() - t0) / 1000).toFixed(1)} s`));
     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`));
+    logErr(c.dim(`  apply it with Lightmap.load(scene, { data: asset('<rel>/${relative4(root, join30(outDir, "lightmap.bake")).replace(/\\/g, "/")}'), texture: asset('<rel>/${relative4(root, ktx2).replace(/\\/g, "/")}') })  — asset() paths are relative to the calling file`));
     return;
   }
   if (lines.some((l2) => /no bake module/.test(l2))) {
@@ -222792,13 +223223,13 @@ import ${JSON.stringify(importPath)}
 };
 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: [] }) + `
+  const bake2 = join30(outDir, "lightmap.bake");
+  const ktx2 = join30(outDir, "lightmap.ktx2");
+  if (!existsSync28(bake2))
+    writeFileSync22(bake2, JSON.stringify({ version: 1, placeholder: true, size: 1, texel: 0, instances: [] }) + `
 `);
-  if (!existsSync27(ktx2))
-    writeFileSync21(ktx2, PLACEHOLDER_KTX2);
+  if (!existsSync28(ktx2))
+    writeFileSync22(ktx2, PLACEHOLDER_KTX2);
 };
 var lightmap = async (args) => {
   const sub = args._[0];
@@ -222824,7 +223255,7 @@ var login = async (args) => {
 
 // src/commands/shaders.ts
 init_manifest();
-import { readFileSync as readFileSync24 } from "node:fs";
+import { readFileSync as readFileSync25 } from "node:fs";
 init_util();
 init_compile();
 var collectShaders = () => {
@@ -222856,7 +223287,7 @@ var status2 = async () => {
       if (matcId === null)
         state = c.dim("unknown (matc not downloaded)");
       else {
-        const text = readFileSync24(shader.absPath, "utf8");
+        const text = readFileSync25(shader.absPath, "utf8");
         if (shaderIsCompiled(root, text, matcId))
           state = "compiled";
         else {
@@ -222865,7 +223296,7 @@ var status2 = async () => {
         }
       }
       log(`  ${shader.path.padEnd(width)}  ${state}`);
-      const schema = parseShaderSchema(readFileSync24(shader.absPath, "utf8"));
+      const schema = parseShaderSchema(readFileSync25(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)}` : "";
@@ -222908,7 +223339,7 @@ var compile3 = async (args) => {
   }
   const matcExe = await resolveMatcExe();
   const matcId = matcIdentity(matcExe);
-  const wasCompiled = new Map(shaders.map((s2) => [s2.path, shaderIsCompiled(root, readFileSync24(s2.absPath, "utf8"), matcId)]));
+  const wasCompiled = new Map(shaders.map((s2) => [s2.path, shaderIsCompiled(root, readFileSync25(s2.absPath, "utf8"), matcId)]));
   const errors2 = [];
   for (const shader of shaders) {
     try {
@@ -222942,8 +223373,8 @@ var shaders = async (args) => {
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync21, readFileSync as readFileSync26, writeFileSync as writeFileSync22 } from "node:fs";
-import { dirname as dirname15, resolve as resolve15 } from "node:path";
+import { mkdirSync as mkdirSync22, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "node:fs";
+import { dirname as dirname15, resolve as resolve16 } from "node:path";
 
 // src/compile/headlessBundle.ts
 init_api();
@@ -223027,23 +223458,23 @@ var compileHeadlessBundle = async (args, opts = {}) => {
 // 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";
+import { existsSync as existsSync29, readFileSync as readFileSync26, statSync as statSync11 } from "node:fs";
+import { isAbsolute, join as join31, relative as relative5, resolve as resolve14 } 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)];
+  const candidates = [resolve14(process.cwd(), file)];
   if (!hasSeparator(file)) {
-    candidates.push(join30(root, (dirFlag ?? DEFAULT_DESIGN_DIR).replace(/[/\\]+$/, ""), "screens", file));
+    candidates.push(join31(root, (dirFlag ?? DEFAULT_DESIGN_DIR).replace(/[/\\]+$/, ""), "screens", file));
   }
   for (const base of candidates) {
-    if (existsSync28(base) && statSync10(base).isFile())
+    if (existsSync29(base) && statSync11(base).isFile())
       return base;
     for (const ext2 of SCREEN_EXTS)
-      if (existsSync28(base + ext2))
+      if (existsSync29(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/.`));
@@ -223052,8 +223483,8 @@ 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;
+  const dir = join31(root, m[1]);
+  return existsSync29(join31(dir, "meta.json")) ? { dir, id: m[2] } : null;
 };
 var resolveScreenTarget = (root, file, opts = {}) => {
   const abs = findScreenFile(root, file, opts.dir);
@@ -223062,7 +223493,7 @@ var resolveScreenTarget = (root, file, opts = {}) => {
     throw new CliError(`"${file}" is outside the project (${root}) — a screen renders as part of its project, so its ` + `imports and asset() files resolve from the same tree.`);
   }
   const key = toKey(rel);
-  if (!/^\s*export\s+default\b/m.test(readFileSync25(abs, "utf8"))) {
+  if (!/^\s*export\s+default\b/m.test(readFileSync26(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()";
@@ -223101,7 +223532,7 @@ init_manifest();
 
 // src/desktopScript.ts
 init_util();
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } 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"];
@@ -223302,7 +223733,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 = resolve14(opts.outDir, s2.screenshot);
+      plan.screenshot = resolve15(opts.outDir, s2.screenshot);
       plan.lines.push(emit(`frames 2`));
       plan.lines.push(emit(`shot ${plan.screenshot}`));
       budgetMs += 3 * FRAME_MS;
@@ -223411,9 +223842,9 @@ var requireRenderer = async () => {
 };
 var fileScenarioIO = (dir) => ({
   write: (relPath, data) => {
-    const abs = resolve15(dir, relPath);
-    mkdirSync21(dirname15(abs), { recursive: true });
-    writeFileSync22(abs, data);
+    const abs = resolve16(dir, relPath);
+    mkdirSync22(dirname15(abs), { recursive: true });
+    writeFileSync23(abs, data);
   }
 });
 var resolveFixtures = (value, baseDir) => {
@@ -223421,9 +223852,9 @@ var resolveFixtures = (value, baseDir) => {
     return;
   let map = value;
   if (typeof value === "string") {
-    const abs = resolve15(baseDir, value);
+    const abs = resolve16(baseDir, value);
     try {
-      map = JSON.parse(readFileSync26(abs, "utf8"));
+      map = JSON.parse(readFileSync27(abs, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read fixtures "${value}": ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -223436,7 +223867,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path2) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync26(resolve15(path2), "utf8"));
+    raw = JSON.parse(readFileSync27(resolve16(path2), "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read scenario "${path2}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -223493,13 +223924,13 @@ var renderDesktop = async (args) => {
     extraEntries: screen2 ? [screen2.entry] : undefined,
     entryOverride: screen2?.entryPath
   });
-  mkdirSync21(dirname15(resolve15(pngFlag)), { recursive: true });
+  mkdirSync22(dirname15(resolve16(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)
-        mkdirSync21(dirname15(st.screenshot), { recursive: true });
+        mkdirSync22(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, {
@@ -223603,7 +224034,7 @@ var render = async (args) => {
   const settleStr = flagStr(args, "settle") ?? (scenario?.settle !== undefined ? String(scenario.settle) : undefined);
   const timeStr = flagStr(args, "time");
   const onConsole = flagBool(args, "logs") ? (level, text2) => logErr(`${c.dim(`[${level}]`)} ${text2}`) : undefined;
-  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname15(resolve15(scriptFlag)) : ".");
+  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname15(resolve16(scriptFlag)) : ".");
   const flagFixtures = resolveFixtures(flagStr(args, "fixtures"), ".");
   const fixtures = envelopeFixtures || flagFixtures ? { ...envelopeFixtures, ...flagFixtures } : undefined;
   if (fixtures) {
@@ -223642,7 +224073,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) => resolve15(outDir, p2)).join(", ")}`));
+        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p2) => resolve16(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);
@@ -223666,8 +224097,8 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      mkdirSync21(dirname15(resolve15(pngFlag)), { recursive: true });
-      writeFileSync22(resolve15(pngFlag), png2);
+      mkdirSync22(dirname15(resolve16(pngFlag)), { recursive: true });
+      writeFileSync23(resolve16(pngFlag), png2);
       note(`Wrote ${pngFlag} (${png2.length} bytes, ${outW}x${outH}${clip !== undefined ? ", clipped" : ""})`);
     }
     return done((cb) => cb());
@@ -223682,7 +224113,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync22(resolve15(out), result.text);
+    writeFileSync23(resolve16(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -223697,8 +224128,8 @@ init_api();
 init_config();
 init_manifest();
 init_util();
-import { appendFileSync as appendFileSync2, existsSync as existsSync29, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "node:fs";
-import { join as join31 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync24 } from "node:fs";
+import { join as join32 } from "node:path";
 var ENV_VAR = "LECODES_PUSH_KEY";
 var context = () => {
   const root = findProjectRoot(process.cwd());
@@ -223842,11 +224273,11 @@ var pnKeysList = async (ctx) => {
 };
 var writeEnv = (root, key) => {
   const touched = [];
-  const envPath = join31(root, ".env");
+  const envPath = join32(root, ".env");
   const line = `${ENV_VAR}=${key}`;
-  const existing = existsSync29(envPath) ? readFileSync27(envPath, "utf8") : "";
+  const existing = existsSync30(envPath) ? readFileSync28(envPath, "utf8") : "";
   if (new RegExp(`^${ENV_VAR}=`, "m").test(existing)) {
-    writeFileSync23(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
+    writeFileSync24(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
   } else {
     const separator = !existing || existing.endsWith(`
 `) ? "" : `
@@ -223855,8 +224286,8 @@ var writeEnv = (root, key) => {
 `);
   }
   touched.push(".env");
-  const ignorePath = join31(root, ".gitignore");
-  const ignore = existsSync29(ignorePath) ? readFileSync27(ignorePath, "utf8") : "";
+  const ignorePath = join32(root, ".gitignore");
+  const ignore = existsSync30(ignorePath) ? readFileSync28(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l2) => l2.trim() === ".env")) {
     const separator = !ignore || ignore.endsWith(`
@@ -223955,8 +224386,8 @@ var pn = async (args) => {
 init_api();
 init_config();
 init_manifest();
-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";
+import { existsSync as existsSync31, mkdirSync as mkdirSync23, rmSync as rmSync10, writeFileSync as writeFileSync25 } from "node:fs";
+import { dirname as dirname16, join as join33 } from "node:path";
 init_types4();
 init_localFiles();
 init_util();
@@ -223979,9 +224410,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 = join32(root, ...path2.replace(/^\//, "").split("/"));
-      if (existsSync30(abs))
-        rmSync9(abs);
+      const abs = join33(root, ...path2.replace(/^\//, "").split("/"));
+      if (existsSync31(abs))
+        rmSync10(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -224018,18 +224449,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 = join32(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync22(dirname16(abs), { recursive: true });
+    const abs = join33(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync23(dirname16(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync24(abs, bytes);
+      writeFileSync25(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync24(abs, text);
+      writeFileSync25(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf3(asset.type), sha };
@@ -224042,8 +224473,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/scene.ts
 init_manifest();
-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";
+import { existsSync as existsSync33, readFileSync as readFileSync30, readdirSync as readdirSync14, statSync as statSync12, writeFileSync as writeFileSync27 } from "node:fs";
+import { basename as basename16, dirname as dirname17, join as join35, resolve as resolve17 } from "node:path";
 
 // src/compile/sceneCompile.ts
 init_localFiles();
@@ -224052,18 +224483,18 @@ init_distRoot();
 init_util();
 init_projectCompile();
 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";
+import { existsSync as existsSync32, mkdirSync as mkdirSync24, readFileSync as readFileSync29, writeFileSync as writeFileSync26 } from "node:fs";
+import { join as join34 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join33(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join34(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync31(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync32(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join33(distRoot, "runtime", "scene-harness.json");
-    if (existsSync31(vendored))
-      return JSON.parse(readFileSync28(vendored, "utf8"));
+    const vendored = join34(distRoot, "runtime", "scene-harness.json");
+    if (existsSync32(vendored))
+      return JSON.parse(readFileSync29(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
 };
@@ -224075,9 +224506,9 @@ 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: readFileSync28(file.absPath, "utf8") });
+      entries.push({ path: path2, type: "text", text: readFileSync29(file.absPath, "utf8") });
     } else if (/\.mat$/i.test(path2)) {
-      entries.push({ path: path2, type: "shader", text: readFileSync28(file.absPath, "utf8"), absPath: file.absPath });
+      entries.push({ path: path2, type: "shader", text: readFileSync29(file.absPath, "utf8"), absPath: file.absPath });
     } else {
       entries.push({ path: path2, type: "resource", fileSrc: "/project/" + rel(file.path) });
     }
@@ -224093,10 +224524,10 @@ var compileSceneEditor = async (opts) => {
         continue;
       const hash = createHash8("sha256").update(e2.text ?? "").digest("hex").slice(0, 16);
       const dir = shadersCacheDir(root);
-      mkdirSync23(dir, { recursive: true });
+      mkdirSync24(dir, { recursive: true });
       const liteName = `${hash}_webgl-lite.filamat`;
-      if (!existsSync31(join33(dir, liteName)))
-        writeFileSync25(join33(dir, liteName), JSON.stringify(buildLiteMaterialArtifact2(e2.text ?? "")));
+      if (!existsSync32(join34(dir, liteName)))
+        writeFileSync26(join34(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 }));
     }
@@ -224130,7 +224561,7 @@ var DEFAULT_PORT3 = 4488;
 var findAppRoot = (start) => {
   let dir = start;
   while (true) {
-    if (existsSync32(join34(dir, "app.json")))
+    if (existsSync33(join35(dir, "app.json")))
       return dir;
     const parent = dirname17(dir);
     if (parent === dir)
@@ -224149,10 +224580,10 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve16(process.cwd(), pathArg);
-      if (existsSync32(abs) && statSync11(abs).isDirectory())
+      const abs = resolve17(process.cwd(), pathArg);
+      if (existsSync33(abs) && statSync12(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync32(abs))
+      else if (abs.endsWith(".scene.ts") && existsSync33(abs))
         root = findAppRoot(dirname17(abs)) ?? dirname17(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
@@ -224160,15 +224591,15 @@ var getContext2 = (args) => {
       root = findAppRoot(root) ?? root;
     }
   }
-  return { root, manifest, name: manifest?.name ?? basename15(root) };
+  return { root, manifest, name: manifest?.name ?? basename16(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path2 = join34(root, ".mcp.json");
+  const path2 = join35(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync32(path2)) {
+  if (existsSync33(path2)) {
     try {
-      config = JSON.parse(readFileSync29(path2, "utf8"));
+      config = JSON.parse(readFileSync30(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -224181,17 +224612,17 @@ var writeMcpConfig2 = (root, port) => {
     return;
   }
   config.mcpServers["lecodes-scene"] = entry;
-  writeFileSync26(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync27(path2, JSON.stringify(config, null, 2) + `
 `);
   note(`${existing ? "updated" : "created"}   .mcp.json (lecodes-scene MCP → ${entry.url})`);
 };
 var countScenes = (dir) => {
   let n2 = 0;
-  for (const name of readdirSync13(dir)) {
+  for (const name of readdirSync14(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join34(dir, name);
-    if (statSync11(full).isDirectory())
+    const full = join35(dir, name);
+    if (statSync12(full).isDirectory())
       n2 += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n2++;
@@ -224236,9 +224667,9 @@ var scene = async (args) => {
 init_util();
 
 // src/cmgenTool.ts
-import { existsSync as existsSync33, readdirSync as readdirSync14 } from "node:fs";
+import { existsSync as existsSync34, readdirSync as readdirSync15 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join35, resolve as resolve17 } from "node:path";
+import { join as join36, resolve as resolve18 } from "node:path";
 init_util();
 var exeName2 = () => process.platform === "win32" ? "cmgen.exe" : "cmgen";
 var platformKey3 = () => {
@@ -224248,10 +224679,10 @@ var platformKey3 = () => {
     return "linux-x64";
   throw new CliError(process.platform === "darwin" ? "cmgen isn't published for macOS yet — build filament's host tools locally and set LECODES_CMGEN." : `cmgen isn't published for ${process.platform}.`);
 };
-var cacheRoot3 = () => join35(homedir8(), ".lecodes", "cmgen");
+var cacheRoot3 = () => join36(homedir8(), ".lecodes", "cmgen");
 var findCmgenIn = (dir) => {
-  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
-    const p2 = join35(dir, entry.name);
+  for (const entry of readdirSync15(dir, { withFileTypes: true })) {
+    const p2 = join36(dir, entry.name);
     if (entry.isFile() && entry.name === exeName2())
       return p2;
     if (entry.isDirectory()) {
@@ -224264,7 +224695,7 @@ var findCmgenIn = (dir) => {
 };
 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);
+    return readdirSync15(cacheRoot3(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("cmgen-")).map((e2) => e2.name.slice("cmgen-".length)).filter((v) => findCmgenIn(join36(cacheRoot3(), `cmgen-${v}`)) !== null).sort(semverNewer);
   } catch {
     return [];
   }
@@ -224286,19 +224717,19 @@ var downloadCmgen = async (version, versions, dest) => {
 var resolveCmgenExeCached = () => {
   const override = process.env.LECODES_CMGEN;
   if (override) {
-    if (!existsSync33(override))
+    if (!existsSync34(override))
       throw new CliError(`LECODES_CMGEN points at "${override}" which doesn't exist.`);
-    return resolve17(override);
+    return resolve18(override);
   }
   const cached = installedCmgenVersions()[0];
-  return cached ? findCmgenIn(join35(cacheRoot3(), `cmgen-${cached}`)) : null;
+  return cached ? findCmgenIn(join36(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}`);
+  const dir = join36(cacheRoot3(), `cmgen-${latest}`);
   await downloadCmgen(latest, versions, dir);
   const exe = findCmgenIn(dir);
   if (!exe)
@@ -224356,8 +224787,8 @@ var status3 = async (_args) => {
 };
 
 // src/commands/test.ts
-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";
+import { existsSync as existsSync35, mkdirSync as mkdirSync25, readFileSync as readFileSync31, readdirSync as readdirSync16 } from "node:fs";
+import { dirname as dirname18, resolve as resolve19 } from "node:path";
 init_manifest();
 init_util();
 var deriveDesignFlows = (meta, entryScreen) => {
@@ -224420,7 +224851,7 @@ var slug3 = (s2) => s2.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").
 var readFlowFile = (abs, displayName) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync30(abs, "utf8"));
+    raw = JSON.parse(readFileSync31(abs, "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read "${displayName}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -224475,40 +224906,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 = resolve18(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve18(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve19(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve19(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 = [resolve18(given), resolve18(testsDir, given), resolve18(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p2) => existsSync34(p2));
+      const candidates = [resolve19(given), resolve19(testsDir, given), resolve19(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p2) => existsSync35(p2));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync34(testsDir)) {
-    for (const f3 of readdirSync15(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve18(testsDir, f3), f3));
+  } else if (existsSync35(testsDir)) {
+    for (const f3 of readdirSync16(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve19(testsDir, f3), f3));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve18(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync34(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve19(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync35(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 && existsSync34(designMetaPath)) {
+  if (desktop2 && wantFlows && existsSync35(designMetaPath)) {
     note("Design-derived flows skipped with --desktop (they tap by name; run `lecodes test` headless for them).");
   }
-  if (!desktop2 && (wantFlows || flowsOnly) && existsSync34(designMetaPath)) {
+  if (!desktop2 && (wantFlows || flowsOnly) && existsSync35(designMetaPath)) {
     let meta;
     try {
-      meta = JSON.parse(readFileSync30(designMetaPath, "utf8"));
+      meta = JSON.parse(readFileSync31(designMetaPath, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read ${designMetaPath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -224540,16 +224971,16 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve18(root, flagStr(args, "artifacts") ?? resolve18(testsDir, ".artifacts"));
+  const artifactsRoot = resolve19(root, flagStr(args, "artifacts") ?? resolve19(testsDir, ".artifacts"));
   const results = [];
   const runNativeCase = async (kase) => {
-    const caseDir = resolve18(artifactsRoot, slug3(kase.name));
+    const caseDir = resolve19(artifactsRoot, slug3(kase.name));
     const plan = translateScenario(kase.steps, { outDir: caseDir, headroomFrames: nativeFrames });
     for (const st of plan.steps)
       if (st.screenshot)
-        mkdirSync24(dirname18(st.screenshot), { recursive: true });
-    mkdirSync24(caseDir, { recursive: true });
-    const finalPng = resolve18(caseDir, "final.png");
+        mkdirSync25(dirname18(st.screenshot), { recursive: true });
+    mkdirSync25(caseDir, { recursive: true });
+    const finalPng = resolve19(caseDir, "final.png");
     const { output } = await runDesktopRender(native.js, native.resources, {
       renderer: desktopRenderer,
       width: Number(flagStr(args, "width")) || kase.width || projectViewport?.width || 390,
@@ -224601,14 +225032,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve18(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve19(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) => resolve18(artifactsRoot, slug3(kase.name), p2))
+          artifacts: outcome.failureArtifacts.map((p2) => resolve19(artifactsRoot, slug3(kase.name), p2))
         };
       } finally {
         session.dispose();
@@ -224676,11 +225107,11 @@ init_config();
 init_manifest();
 init_types4();
 init_util();
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
 var types4 = async (args) => {
   const dirArg = args._[0];
-  const root = dirArg ? resolve19(dirArg) : (() => {
+  const root = dirArg ? resolve20(dirArg) : (() => {
     try {
       return findProjectRoot(process.cwd());
     } catch {
@@ -224739,23 +225170,23 @@ var types4 = async (args) => {
 };
 
 // src/index.ts
-import { existsSync as existsSync36, readFileSync as readFileSync32, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync34, realpathSync as realpathSync2 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname20, join as join37 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname21, join as join39 } 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 existsSync35, mkdirSync as mkdirSync25, readFileSync as readFileSync31, realpathSync, rmSync as rmSync10, symlinkSync } from "node:fs";
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync5, existsSync as existsSync36, mkdirSync as mkdirSync26, readFileSync as readFileSync32, realpathSync, rmSync as rmSync11, 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";
+import { basename as basename17, delimiter, dirname as dirname19, join as join37, resolve as resolve21, sep as sep2 } from "node:path";
 var isWin = process.platform === "win32";
 var HOME = homedir9();
 var safeRealpath = (p2) => {
   try {
     return realpathSync(p2);
   } catch {
-    return resolve20(p2);
+    return resolve21(p2);
   }
 };
 var onPath = (dir) => {
@@ -224772,24 +225203,24 @@ var onPath = (dir) => {
 };
 var install = async (args) => {
   const bundle = dirname19(process.execPath);
-  const exeName3 = basename16(process.execPath);
+  const exeName3 = basename17(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync35(join36(bundle, "runtime")) || !existsSync35(join36(bundle, chiselName))) {
+  if (!existsSync36(join37(bundle, "runtime")) || !existsSync36(join37(bundle, chiselName))) {
     throw new CliError("`lecodes install` only works from the packaged release build (the archive containing lecodes + " + "chisel + runtime/). You appear to be running from source or an npm install — install globally " + "with your package manager there instead.");
   }
-  const companions = [exeName3, chiselName, "runtime", "README.txt"].filter((f3) => existsSync35(join36(bundle, f3)));
+  const companions = [exeName3, chiselName, "runtime", "README.txt"].filter((f3) => existsSync36(join37(bundle, f3)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
 };
 var copyBundle = (bundle, target, companions) => {
-  mkdirSync25(target, { recursive: true });
+  mkdirSync26(target, { recursive: true });
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f3 of companions) {
-    const dest = join36(target, f3);
-    rmSync10(dest, { recursive: true, force: true });
-    cpSync4(join36(bundle, f3), dest, { recursive: true });
+    const dest = join37(target, f3);
+    rmSync11(dest, { recursive: true, force: true });
+    cpSync5(join37(bundle, f3), dest, { recursive: true });
   }
 };
 var permError = (e2, dir, system) => {
@@ -224801,41 +225232,41 @@ var permError = (e2, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  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");
+  const libDir = resolve21(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join37(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve21(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join37(HOME, ".local", "bin")));
+  const link2 = join37(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync2(join36(libDir, "lecodes"), 493);
-    chmodSync2(join36(libDir, "chisel"), 493);
+    chmodSync2(join37(libDir, "lecodes"), 493);
+    chmodSync2(join37(libDir, "chisel"), 493);
   } catch (e2) {
     throw permError(e2, libDir, system);
   }
   try {
-    mkdirSync25(binDir, { recursive: true });
-    rmSync10(link2, { force: true });
-    symlinkSync(join36(libDir, "lecodes"), link2);
+    mkdirSync26(binDir, { recursive: true });
+    rmSync11(link2, { force: true });
+    symlinkSync(join37(libDir, "lecodes"), link2);
   } catch (e2) {
     throw permError(e2, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link2 + " → " + join36(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join37(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
-  const shell = basename16(process.env.SHELL ?? "");
+  const shell = basename17(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join36(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join37(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join36(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join36(HOME, ".profile"), name: "~/.profile" };
+    return { file: join37(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join37(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 = existsSync35(file) ? readFileSync31(file, "utf8") : "";
+    const existing = existsSync36(file) ? readFileSync32(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -224873,7 +225304,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 = resolve20(flagStr(args, "dir") ?? join36(process.env.LOCALAPPDATA ?? join36(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve21(flagStr(args, "dir") ?? join37(process.env.LOCALAPPDATA ?? join37(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e2) {
@@ -224901,7 +225332,7 @@ var installWindows = (args, bundle, companions) => {
 var addToUserPathWindows = (dir) => {
   const script = "$d = $env:LECODES_INSTALL_DIR;" + "$p = [Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p = '' };" + "$parts = @($p.Split(';') | Where-Object { $_ -ne '' });" + "if ($parts -notcontains $d) { [Environment]::SetEnvironmentVariable('Path', (@($parts + $d) -join ';'), 'User') }";
   try {
-    execFileSync5("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
+    execFileSync7("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
     return true;
   } catch {
     return false;
@@ -224910,10 +225341,85 @@ var addToUserPathWindows = (dir) => {
 
 // src/index.ts
 init_util();
+
+// src/projectEnv.ts
+import { existsSync as existsSync37, readFileSync as readFileSync33 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname20, join as join38, resolve as resolve22 } from "node:path";
+var KEY_RE = /^(LECODES|CREATOR)_[A-Z0-9_]+$/;
+var parseDotEnv = (text) => {
+  const out = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const m = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+    if (!m)
+      continue;
+    const key = m[1];
+    let value = m[2];
+    if (value.startsWith('"')) {
+      const end = value.indexOf('"', 1);
+      value = (end < 0 ? value.slice(1) : value.slice(1, end)).replace(/\\n/g, `
+`).replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    } else if (value.startsWith("'")) {
+      const end = value.indexOf("'", 1);
+      value = end < 0 ? value.slice(1) : value.slice(1, end);
+    } else {
+      const hash = value.search(/\s#/);
+      value = (hash >= 0 ? value.slice(0, hash) : value).trim();
+    }
+    out[key] = value;
+  }
+  return out;
+};
+var applyDotEnv = (parsed, dir, env) => {
+  const out = {};
+  for (const [key, raw] of Object.entries(parsed)) {
+    if (!KEY_RE.test(key) || env[key] !== undefined)
+      continue;
+    let value = raw;
+    if (value.startsWith("./") || value.startsWith("../"))
+      value = resolve22(dir, value);
+    else if (value === "~" || value.startsWith("~/"))
+      value = join38(homedir10(), value.slice(1));
+    out[key] = value;
+  }
+  return out;
+};
+var findEnvRoot = (start) => {
+  let dir = resolve22(start);
+  while (true) {
+    if (existsSync37(join38(dir, "app.json")) || existsSync37(join38(dir, ".lecodes")))
+      return dir;
+    const parent = dirname20(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+};
+var loadProjectEnv = (cwd = process.cwd()) => {
+  try {
+    const root = findEnvRoot(cwd);
+    if (!root)
+      return [];
+    const file = join38(root, ".env");
+    if (!existsSync37(file))
+      return [];
+    const added = applyDotEnv(parseDotEnv(readFileSync33(file, "utf8")), root, process.env);
+    for (const [k, v] of Object.entries(added))
+      process.env[k] = v;
+    return Object.keys(added);
+  } catch {
+    return [];
+  }
+};
+
+// src/index.ts
 var STANDALONE = (() => {
-  const dir = dirname20(process.execPath);
+  const dir = dirname21(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync36(join37(dir, "runtime")) && existsSync36(join37(dir, chisel));
+  return existsSync38(join39(dir, "runtime")) && existsSync38(join39(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -224928,8 +225434,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join37(d, exe);
-      return existsSync36(cand) && realpathSync2(cand) === self2;
+      const cand = join39(d, exe);
+      return existsSync38(cand) && realpathSync2(cand) === self2;
     } catch {
       return false;
     }
@@ -225133,10 +225639,20 @@ ${c.bold("Commands:")}
                                           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'.
+                                          On macOS: a signed .app instead (the downloaded LeCodes
+                                          Desktop.app + the project inside it); app.json
+                                          desktop.macos = bundleId / buildNumber / category /
+                                          signing.identity / notarize.profile (a notarytool
+                                          keychain profile — notarized + stapled, so it opens
+                                          on any Mac without "Open Anyway").
                                           -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
+                                                         (macOS: a brief windowed run + snapshot)
+                                          --zip          also pack the result for sending
+                                          --sign <identity|adhoc>   macOS codesign identity
+                                          --notarize <profile> / --no-notarize   macOS
                                           --zip          <out>.zip, UTF-8/forward-slash entries
                                   update  move to the newest published release
                                           (cached in ~/.lecodes/renderer)
@@ -225251,7 +225767,10 @@ ${c.bold("Commands:")}
   pn keys [new|revoke]          Push keys for YOUR server: list, mint (owner only, shown once
                                   — 'new --env' banks it in .env), revoke <id>
 
-Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
+Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).
+A .env next to app.json is read at startup for LECODES_* / CREATOR_* keys (the shell's own
+environment wins; ./ paths resolve against the project; the file is never pushed) — e.g.
+LECODES_DESKTOP_EXE, LECODES_MATC, LECODES_NOTARY_PROFILE, LECODES_MACOS_SIGN_ID, LECODES_TOKEN.`;
 var commands = { init: init2, login, create, clone: clone3, link, status: status3, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn, desktop, shaders, assets, lightmap };
 if (STANDALONE)
   commands.install = install;
@@ -225265,15 +225784,15 @@ var OPTIONAL_PEERS = [
 var peerVersion = (name, probe) => {
   try {
     const require2 = createRequire4(import.meta.url);
-    let dir = dirname20(require2.resolve(probe));
+    let dir = dirname21(require2.resolve(probe));
     for (let depth = 0;depth < 16; depth++) {
-      const manifest = join37(dir, "package.json");
-      if (existsSync36(manifest)) {
-        const parsed = JSON.parse(readFileSync32(manifest, "utf8"));
+      const manifest = join39(dir, "package.json");
+      if (existsSync38(manifest)) {
+        const parsed = JSON.parse(readFileSync34(manifest, "utf8"));
         if (parsed.name === name)
           return parsed.version ?? "unknown";
       }
-      const parent = dirname20(dir);
+      const parent = dirname21(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -225298,6 +225817,7 @@ var printVersion = () => {
 var main = async () => {
   const argv = process.argv.slice(2);
   const command = argv[0];
+  loadProjectEnv();
   if (!command || command === "help" || command === "--help" || command === "-h") {
     log(HELP);
     return;