lecodes-cli 0.14.1 → 0.15.0

package/dist/index.js

@@ -864,6 +864,18 @@ var buildHeader = (name, code, opts = {}) => {
     header += `// icon: ${opts.icon}
 `;
   header += `// last-updated: ${new Date().toISOString()}
+`;
+  if (!code.includes("_creator.createScene") && !code.includes("_creator.createEntity"))
+    header += `// gl: disable
+`;
+  else if (code.includes("_creator.createEngine"))
+    header += `// gl: defer
+`;
+  if (code.includes("_creator2d."))
+    header += `// 2d: enable
+`;
+  if (code.includes("_creator.createARController"))
+    header += `// ar: enable
 `;
   const localAssets = new Set;
   for (const m of code.matchAll(/_creatorUtils\.fetchLocal\((.+?)\)/g)) {
@@ -882,17 +894,6 @@ var buildHeader = (name, code, opts = {}) => {
   if (opts.icons)
     header += `// icons: ${opts.icons}
 `;
-  if (!code.includes("_creator.createScene") && !code.includes("_creator.createEntity"))
-    header += `// gl: disable
-`;
-  else if (code.includes("_creator.createEngine"))
-    header += `// gl: defer
-`;
-  if (code.includes("_creator2d."))
-    header += `// 2d: enable
-`;
-  if (code.includes("_creator.createARController"))
-    header += "// ar: enable";
   header += `
 `;
   return header;
@@ -42820,65 +42821,65 @@ var init_esm30 = __esm(() => {
 });
 
 // src/types.ts
-import { dirname as dirname12, join as join16, relative as relative3, sep } from "node:path";
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname13, join as join18, relative as relative3, sep } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readdirSync as readdirSync8, readFileSync as readFileSync16, rmSync as rmSync5, statSync as statSync6, writeFileSync as writeFileSync14 } from "node:fs";
 var TSCONFIG, listBundleFiles = (dir, base = dir) => {
-  if (!existsSync15(dir))
+  if (!existsSync17(dir))
     return [];
   const out = [];
-  for (const name of readdirSync6(dir)) {
-    const path2 = join16(dir, name);
-    if (statSync4(path2).isDirectory())
+  for (const name of readdirSync8(dir)) {
+    const path2 = join18(dir, name);
+    if (statSync6(path2).isDirectory())
       out.push(...listBundleFiles(path2, base));
     else
       out.push(relative3(base, path2).split(sep).join("/"));
   }
   return out;
 }, pruneEmptyDirs = (dir, root) => {
-  if (!existsSync15(dir) || !statSync4(dir).isDirectory())
+  if (!existsSync17(dir) || !statSync6(dir).isDirectory())
     return;
-  for (const name of readdirSync6(dir))
-    pruneEmptyDirs(join16(dir, name), root);
-  if (dir !== root && readdirSync6(dir).length === 0)
-    rmSync3(dir, { recursive: true });
+  for (const name of readdirSync8(dir))
+    pruneEmptyDirs(join18(dir, name), root);
+  if (dir !== root && readdirSync8(dir).length === 0)
+    rmSync5(dir, { recursive: true });
 }, writeTypeBundle = (root, bundle) => {
-  const typesDir = join16(root, LECODES_DIR, "types");
+  const typesDir = join18(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 = join16(typesDir, path2);
+    const dest = join18(typesDir, path2);
     if (!before.has(path2))
       stats.added++;
-    else if (readFileSync15(dest, "utf8") !== text)
+    else if (readFileSync16(dest, "utf8") !== text)
       stats.updated++;
     else
       continue;
-    mkdirSync10(dirname12(dest), { recursive: true });
-    writeFileSync12(dest, text);
+    mkdirSync12(dirname13(dest), { recursive: true });
+    writeFileSync14(dest, text);
   }
   for (const path2 of before) {
     if (path2 in bundle)
       continue;
-    rmSync3(join16(typesDir, path2));
+    rmSync5(join18(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 = join16(root, LECODES_DIR, "types");
+  const typesDir = join18(root, LECODES_DIR, "types");
   const bundle = {};
   for (const path2 of listBundleFiles(typesDir))
-    bundle[path2] = readFileSync15(join16(typesDir, path2), "utf8");
+    bundle[path2] = readFileSync16(join18(typesDir, path2), "utf8");
   return bundle;
 }, materializeTypes = async (root, apiUrl) => writeTypeBundle(root, await getTypes(apiUrl)), readLocalTypeBundle = () => {
   const candidates = [
-    join16(distRoot, "runtime", "sdk-types.json"),
-    join16(distRoot, "..", "sdk", "dist", "types.json")
+    join18(distRoot, "runtime", "sdk-types.json"),
+    join18(distRoot, "..", "sdk", "dist", "types.json")
   ];
   for (const path2 of candidates) {
-    if (existsSync15(path2)) {
+    if (existsSync17(path2)) {
       try {
-        return JSON.parse(readFileSync15(path2, "utf8"));
+        return JSON.parse(readFileSync16(path2, "utf8"));
       } catch {}
     }
   }
@@ -42890,7 +42891,7 @@ var TSCONFIG, listBundleFiles = (dir, base = dir) => {
   writeTypeBundle(root, bundle);
   return true;
 }, writeTsconfig = (root) => {
-  writeFileSync12(join16(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+  writeFileSync14(join18(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
 };
 var init_types4 = __esm(() => {
   init_api();
@@ -42917,13 +42918,13 @@ var init_types4 = __esm(() => {
 
 // src/compile/designCompile.ts
 import { readFileSync as readFileSync17 } from "node:fs";
-import { basename as basename6 } from "node:path";
+import { basename as basename7 } 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(basename6(file.path));
+    const type = manifest?.files[file.path]?.type ?? classifyKind(basename7(file.path));
     if (type === "resource") {
       entries.push({
         path: file.path,
@@ -42979,7 +42980,7 @@ var init_designCompile = __esm(() => {
 
 // src/browserAuth.ts
 import { createServer } from "node:http";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { hostname } from "node:os";
 var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
@@ -43004,16 +43005,16 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     args = [url];
   }
   try {
-    const child = spawn3(cmd, args, { stdio: "ignore", detached: true });
+    const child = spawn4(cmd, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
 }, browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser) => {
   const state = randomBytes(16).toString("hex");
-  let resolve8;
+  let resolve9;
   let reject;
   const tokenPromise = new Promise((res, rej) => {
-    resolve8 = res;
+    resolve9 = res;
     reject = rej;
   });
   const server = createServer((req, res) => {
@@ -43031,7 +43032,7 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     }
     res.writeHead(200, { "content-type": "text/html" });
     res.end(SUCCESS_HTML);
-    resolve8(token);
+    resolve9(token);
   });
   await new Promise((res, rej) => {
     server.once("error", rej);
@@ -43532,8 +43533,8 @@ __export(exports_design, {
   flushDesignComments: () => flushDesignComments,
   design: () => design
 });
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync18, readdirSync as readdirSync10, writeFileSync as writeFileSync15, appendFileSync } from "node:fs";
-import { basename as basename7, join as join19 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync18, readdirSync as readdirSync11, writeFileSync as writeFileSync16, appendFileSync } from "node:fs";
+import { basename as basename8, join as join20 } from "node:path";
 var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   let root;
   let manifest;
@@ -43548,13 +43549,13 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   return {
     root,
     manifest,
-    name: manifest?.name ?? basename7(root),
+    name: manifest?.name ?? basename8(root),
     dirName,
-    designDir: join19(root, dirName),
+    designDir: join20(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 }, loadDesignServer = async (ctx, needs = []) => {
-  if (!existsSync19(ctx.designDir)) {
+  if (!existsSync20(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let mod;
@@ -43586,13 +43587,13 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
 `).find((l2) => l2.trim())?.trim() ?? "";
   return line.length > max ? line.slice(0, max - 1) + "…" : line;
 }, listScreens = (designDir) => {
-  const dir = join19(designDir, "screens");
-  if (!existsSync19(dir))
+  const dir = join20(designDir, "screens");
+  if (!existsSync20(dir))
     return [];
-  return readdirSync10(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
+  return readdirSync11(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
 }, PHONE_SIZE, readMetaFrames = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync18(join19(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync18(join20(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 {
@@ -43603,10 +43604,10 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     return { screens: {}, defaultSize: PHONE_SIZE };
   }
 }, writeMcpConfig = (ctx, port) => {
-  const path2 = join19(ctx.root, ".mcp.json");
+  const path2 = join20(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync19(path2)) {
+  if (existsSync20(path2)) {
     try {
       config = JSON.parse(readFileSync18(path2, "utf8"));
     } catch {
@@ -43621,7 +43622,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     return;
   }
   config.mcpServers["lecodes-design"] = entry;
-  writeFileSync15(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync16(path2, JSON.stringify(config, null, 2) + `
 `);
   log(`${c.green(existing ? "updated" : "created")}   .mcp.json (lecodes-design MCP → ${entry.url})`);
 }, init = async (ctx, args) => {
@@ -43630,26 +43631,26 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join19("shared", "tokens.ts"), TOKENS_TS],
-    [join19("shared", "tabs.ts"), TABS_TS],
-    [join19("screens", "home.ts"), HOME_SCREEN_TS]
+    [join20("shared", "tokens.ts"), TOKENS_TS],
+    [join20("shared", "tabs.ts"), TABS_TS],
+    [join20("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync14(join19(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync14(join19(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync15(join20(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync15(join20(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join19(ctx.designDir, rel);
-    if (existsSync19(abs)) {
+    const abs = join20(ctx.designDir, rel);
+    if (existsSync20(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
     }
-    writeFileSync15(abs, content);
+    writeFileSync16(abs, content);
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join19(ctx.root, ".lecodesignore");
+  const ignorePath = join20(ctx.root, ".lecodesignore");
   const ignoreLines = [`${ctx.dirName}/.snapshots/`, `${ctx.dirName}/comments/`];
-  const current = existsSync19(ignorePath) ? readFileSync18(ignorePath, "utf8") : "";
+  const current = existsSync20(ignorePath) ? readFileSync18(ignorePath, "utf8") : "";
   const present = new Set(current.split(/\r?\n/));
   const missing = ignoreLines.filter((line) => !present.has(line));
   if (missing.length) {
@@ -43664,8 +43665,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);
-  mkdirSync14(join19(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync15(join19(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync15(join20(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync16(join20(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.");
@@ -43713,16 +43714,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") ?? join19(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join20(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)
-    mkdirSync14(outDir, { recursive: true });
+    mkdirSync15(outDir, { recursive: true });
   for (const id of targets) {
     const [width, height] = frames.screens[id]?.size ?? frames.defaultSize;
     let plan = [{ state: undefined, bases: [id] }];
     if (discover) {
-      const { states, canonical } = discover(readFileSync18(join19(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync18(join20(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -43763,11 +43764,11 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
         for (const w of pngResult.warnings)
           warnErr(`${tag}: ${w}`);
       for (const base of bases) {
-        writeFileSync15(join19(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join19(outDir, `${base}.json`)}`);
+        writeFileSync16(join20(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join20(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync15(join19(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join19(outDir, `${base}.png`)}`);
+          writeFileSync16(join20(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join20(outDir, `${base}.png`)}`);
         }
       }
     }
@@ -44069,7 +44070,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 (!existsSync19(ctx.designDir))
+  if (!existsSync20(ctx.designDir))
     return null;
   const platform = optionalPlatform(ctx);
   if (!platform)
@@ -45211,7 +45212,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.14.1",
+  version: "0.15.0",
   dependencies: {
     "@letary/chisel": "^0.6.0",
     jimp: "^1.6.1"
@@ -45224,7 +45225,7 @@ var package_default = {
     sdk: "workspace:*"
   },
   peerDependencies: {
-    "lecodes-design": "^0.6.1",
+    "lecodes-design": "^0.8.0",
     "lecodes-renderer": "^0.8.2",
     "lecodes-3d-editor": "^0.2.0"
   },
@@ -45272,10 +45273,10 @@ var package_default = {
 // src/commands/app.ts
 init_manifest();
 init_config();
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { cpSync as cpSync2, existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync14, readdirSync as readdirSync5, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename5, dirname as dirname11, join as join15, resolve as resolve4 } from "node:path";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { cpSync as cpSync3, existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync15, readdirSync as readdirSync7, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename6, dirname as dirname12, join as join17, resolve as resolve6 } from "node:path";
 
 // src/commands/compile.ts
 init_api();
@@ -46359,7 +46360,7 @@ var readJson = (path) => {
   if (!existsSync10(path))
     return null;
   try {
-    return JSON.parse(readFileSync11(path, "utf8"));
+    return JSON.parse(readFileSync11(path, "utf8").replace(/^\uFEFF/, ""));
   } catch {
     throw new CliError(`Invalid JSON in ${path}`);
   }
@@ -47984,16 +47985,492 @@ 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 existsSync15, mkdirSync as mkdirSync10, readdirSync as readdirSync6, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
+import { basename as basename5, dirname as dirname11, join as join16, resolve as resolve5 } from "node:path";
+
+// src/desktopRenderer.ts
+init_util();
+import { createHash as createHash5 } from "node:crypto";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
+import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync9, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync14, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir5, tmpdir } from "node:os";
+import { join as join15, resolve as resolve4 } from "node:path";
+var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json";
+var DESKTOP_RENDERER_VERSION = "1.1.0";
+var semverNewer = (a2, b) => {
+  const pa = a2.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
+  for (let i2 = 0;i2 < 3; i2++)
+    if ((pb[i2] ?? 0) !== (pa[i2] ?? 0))
+      return (pb[i2] ?? 0) - (pa[i2] ?? 0);
+  return 0;
+};
+var platformKey = () => {
+  if (process.platform === "win32")
+    return "windows-x64";
+  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}.`);
+};
+var exeName = () => process.platform === "win32" ? "lecodes-desktop.exe" : "lecodes-desktop";
+var findExe = (dir) => {
+  const name = exeName();
+  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    const p2 = join15(dir, entry.name);
+    if (entry.isFile() && entry.name === name)
+      return p2;
+    if (entry.isDirectory()) {
+      const found = findExe(p2);
+      if (found)
+        return found;
+    }
+  }
+  return null;
+};
+var cacheRoot = () => join15(homedir5(), ".lecodes", "renderer");
+var currentFile = () => join15(cacheRoot(), "current.json");
+var installedDesktopVersions = () => {
+  try {
+    return readdirSync5(cacheRoot(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("desktop-")).map((e2) => e2.name.slice("desktop-".length)).filter((v) => findExe(join15(cacheRoot(), `desktop-${v}`)) !== null).sort(semverNewer);
+  } catch {
+    return [];
+  }
+};
+var selectedDesktopVersion = () => {
+  try {
+    const saved = JSON.parse(readFileSync14(currentFile(), "utf8")).version;
+    if (saved && /^\d+\.\d+\.\d+/.test(saved) && semverNewer(DESKTOP_RENDERER_VERSION, saved) > 0)
+      return saved;
+  } catch {}
+  return DESKTOP_RENDERER_VERSION;
+};
+var fetchDesktopManifest = async () => {
+  let manifest;
+  try {
+    const res = await fetch(MANIFEST_URL);
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    manifest = await res.json();
+  } catch (e2) {
+    throw new CliError(`Can't fetch the release manifest (${MANIFEST_URL}): ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+  const desktop = manifest.products?.desktop;
+  if (!desktop)
+    throw new CliError("The release manifest has no desktop product.");
+  return desktop;
+};
+var downloadDesktop = async (version, dest) => {
+  const key = platformKey();
+  const entry = (await fetchDesktopManifest()).versions.find((v) => v.version === version);
+  const file = entry?.files[key];
+  if (!file) {
+    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)…`);
+  let bytes;
+  try {
+    const res = await fetch(file.url);
+    if (!res.ok)
+      throw new Error(`HTTP ${res.status}`);
+    bytes = Buffer.from(await res.arrayBuffer());
+  } catch (e2) {
+    throw new CliError(`Download failed (${file.url}): ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+  const sha = createHash5("sha256").update(bytes).digest("hex");
+  if (sha !== file.sha256)
+    throw new CliError(`Downloaded archive is corrupt (sha256 mismatch) — try again.`);
+  mkdirSync9(cacheRoot(), { recursive: true });
+  const stage = mkdtempSync(join15(cacheRoot(), "dl-"));
+  try {
+    const archive = join15(stage, file.url.split("/").pop() ?? "archive");
+    writeFileSync11(archive, bytes);
+    const tar = spawnSync3("tar", ["-xf", archive, "-C", stage], { stdio: ["ignore", "ignore", "pipe"] });
+    if (tar.status !== 0)
+      throw new CliError(`Couldn't extract the renderer archive: ${tar.stderr?.toString() ?? "tar failed"}`);
+    rmSync2(archive);
+    if (!findExe(stage))
+      throw new CliError("The downloaded archive doesn't contain the desktop host binary.");
+    try {
+      renameSync2(stage, dest);
+    } catch {
+      if (!findExe(dest))
+        throw new CliError(`Couldn't move the renderer into ${dest}.`);
+    }
+  } finally {
+    rmSync2(stage, { recursive: true, force: true });
+  }
+};
+var resolveDesktopExe = async () => {
+  const override = process.env.LECODES_DESKTOP_EXE;
+  if (override) {
+    if (!existsSync14(override))
+      throw new CliError(`LECODES_DESKTOP_EXE points at "${override}" which doesn't exist.`);
+    return resolve4(override);
+  }
+  const version = selectedDesktopVersion();
+  const dir = join15(cacheRoot(), `desktop-${version}`);
+  let exe = existsSync14(dir) ? findExe(dir) : null;
+  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.`);
+  }
+  return exe;
+};
+var updateDesktop = async () => {
+  const { latest } = await fetchDesktopManifest();
+  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 = join15(cacheRoot(), `desktop-${latest}`);
+  const hadIt = existsSync14(dir) && findExe(dir) !== null;
+  if (!hadIt)
+    await downloadDesktop(latest, dir);
+  mkdirSync9(cacheRoot(), { recursive: true });
+  writeFileSync11(currentFile(), JSON.stringify({ version: latest }, null, 2));
+  if (latest === before && hadIt)
+    note(`Already up to date: LeCodes Desktop ${latest}.`);
+  else if (latest === before)
+    note(`Re-downloaded LeCodes Desktop ${latest}.`);
+  else
+    note(`Desktop renderer set to ${latest} (was ${before}).`);
+};
+var windowEnv = (opts) => {
+  const env = {};
+  const width = opts.width ?? (opts.height !== undefined ? 1280 : undefined);
+  const height = opts.height ?? (opts.width !== undefined ? 720 : undefined);
+  if (width && height)
+    env.CREATOR_WINDOW_SIZE = `${width}x${height}`;
+  if (opts.minWidth && opts.minHeight)
+    env.CREATOR_MIN_WINDOW_SIZE = `${opts.minWidth}x${opts.minHeight}`;
+  if (opts.title)
+    env.CREATOR_WINDOW_TITLE = opts.title;
+  if (opts.resizable === false)
+    env.CREATOR_WINDOW_FIXED = "1";
+  if (opts.fullscreen !== undefined)
+    env.CREATOR_WINDOW_FULLSCREEN = opts.fullscreen ? "1" : "0";
+  if (opts.scale === "fit")
+    env.CREATOR_UI_SCALE = "fit";
+  else if (typeof opts.scale === "number")
+    env.CREATOR_UI_SCALE = String(opts.scale);
+  return env;
+};
+var stageBundle = (js, resources) => {
+  const runDir = mkdtempSync(join15(tmpdir(), "lecodes-render-"));
+  writeFileSync11(join15(runDir, "app.js"), js);
+  for (const r2 of resources) {
+    if (r2.absPath && existsSync14(r2.absPath) && statSync3(r2.absPath).isFile()) {
+      copyFileSync(r2.absPath, join15(runDir, r2.name));
+    }
+  }
+  return runDir;
+};
+var runDesktopApp = async (js, resources, opts = {}) => {
+  const exe = await resolveDesktopExe();
+  const runDir = stageBundle(js, resources);
+  try {
+    const env = { ...process.env, ...windowEnv(opts) };
+    await new Promise((done, fail) => {
+      const child = spawn2(exe, [join15(runDir, "app.js")], { cwd: runDir, env, stdio: ["ignore", "inherit", "inherit"] });
+      child.on("error", (e2) => fail(new CliError(`Can't run the desktop host: ${e2.message}`)));
+      child.on("exit", (code) => {
+        if (code === 0 || code === null)
+          done();
+        else
+          fail(new CliError(`The desktop host exited with code ${code}.`));
+      });
+    });
+  } finally {
+    rmSync2(runDir, { recursive: true, force: true });
+  }
+};
+var runDesktopDev = async (url, opts = {}) => {
+  const exe = await resolveDesktopExe();
+  const env = { ...process.env, ...windowEnv(opts) };
+  await new Promise((done, fail) => {
+    const child = spawn2(exe, [url], { env, stdio: ["ignore", "ignore", "inherit"] });
+    child.on("error", (e2) => fail(new CliError(`Can't run the desktop host: ${e2.message}`)));
+    child.on("exit", () => done());
+  });
+};
+var runDesktopRender = async (js, resources, opts) => {
+  const exe = await resolveDesktopExe();
+  const runDir = stageBundle(js, resources);
+  try {
+    const appJs = join15(runDir, "app.js");
+    const outAbs = resolve4(opts.outPng);
+    await new Promise((done, fail) => {
+      const child = spawn2(exe, [appJs], {
+        cwd: runDir,
+        env: {
+          ...process.env,
+          CREATOR_DUMP_PNG: outAbs,
+          CREATOR_MAX_FRAMES: String(opts.frames),
+          CREATOR_WINDOW_SIZE: `${opts.width}x${opts.height}`,
+          CREATOR_HIDDEN: "1"
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const tail = [];
+      const sink = (d) => {
+        const text = String(d);
+        tail.push(text);
+        while (tail.length > 80)
+          tail.shift();
+        if (opts.logs)
+          process.stderr.write(text);
+      };
+      child.stdout.on("data", sink);
+      child.stderr.on("data", sink);
+      const killer = setTimeout(() => {
+        child.kill();
+        fail(new CliError(`The native render timed out after ${opts.timeoutMs}ms (raise --timeout, or lower --frames).`));
+      }, opts.timeoutMs);
+      child.on("error", (e2) => {
+        clearTimeout(killer);
+        fail(new CliError(`Can't run the desktop renderer: ${e2.message}`));
+      });
+      child.on("exit", (code) => {
+        clearTimeout(killer);
+        if (code === 0 && existsSync14(outAbs))
+          return done();
+        const detail = tail.length > 0 ? `
+${tail.join("").trimEnd()}` : "";
+        fail(new CliError(code === 0 ? `The renderer exited cleanly but produced no PNG — did the app open a screen?${detail}` : `The renderer exited with code ${code}.${detail}`));
+      });
+    });
+  } finally {
+    rmSync2(runDir, { recursive: true, force: true });
+  }
+};
+
+// src/commands/appDesktop.ts
+init_util();
+var mb = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+var dirSize = (dir) => readdirSync6(dir, { withFileTypes: true }).reduce((sum, e2) => {
+  const p2 = join16(dir, e2.name);
+  return sum + (e2.isDirectory() ? dirSize(p2) : statSync4(p2).size);
+}, 0);
+var initDesktop = async (args) => {
+  const root = projectRoot();
+  const existing = readJson(join16(root, "app.json")) ?? {};
+  const name = flagStr(args, "name") ?? existing.name ?? basename5(root);
+  const window2 = {
+    width: 1280,
+    height: 800,
+    minWidth: 640,
+    minHeight: 480,
+    ...existing.desktop?.window,
+    ...flagBool(args, "fullscreen") ? { fullscreen: true } : {}
+  };
+  const config = { ...existing, name, desktop: { ...existing.desktop, window: window2 } };
+  writeJson(join16(root, "app.json"), config);
+  log(`${c.green("written")}   app.json  (desktop.window ${window2.width}×${window2.height}${window2.fullscreen ? ", fullscreen" : ""})`);
+  log(`Next: ${c.bold("lecodes dev --desktop")} to develop, ${c.bold("lecodes app build desktop")} to package.`);
+};
+var cleanFileName = (name) => name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "").replace(/[. ]+$/, "").trim() || "app";
+var buildDesktop = async (args) => {
+  const root = projectRoot();
+  const config = readJson(join16(root, "app.json")) ?? {};
+  const name = (config.name ?? basename5(root)).trim() || "app";
+  const slug = flagStr(args, "slug") ?? cleanFileName(name);
+  const out = resolve5(root, flagStr(args, "o", "out") ?? join16(root, "dist", slug));
+  if (existsSync15(out)) {
+    const entries = readdirSync6(out);
+    const looksLikeBuild = entries.length === 0 || entries.includes("app.js");
+    if (!looksLikeBuild) {
+      throw new CliError(`${out} exists and doesn't look like a previous desktop build — pick another -o or clear it yourself.`);
+    }
+  }
+  if (config.desktop?.entry && flagStr(args, "entry") === undefined)
+    args.flags.entry = config.desktop.entry;
+  note(`Building "${name}" for desktop…`);
+  const { js, resources } = await buildBundle(args, { remotePatterns: config.resources?.remote ?? [] });
+  const wanted = new Set([...js.matchAll(/fetchLocal\("([^"]+)"\)/g)].map((m) => m[1]));
+  const shipped = resources.filter((r2) => !r2.remote && wanted.has(r2.name));
+  const byName = new Map;
+  for (const r2 of resources) {
+    if (r2.remote || !wanted.has(r2.name))
+      continue;
+    const set = byName.get(r2.name) ?? new Set;
+    set.add(r2.path);
+    byName.set(r2.name, set);
+  }
+  const collisions = [...byName.entries()].filter(([, paths]) => paths.size > 1);
+  if (collisions.length > 0) {
+    throw new CliError("Asset file names must be unique across the whole project — the bundle refers to assets " + `by BASENAME, so same-named files silently replace each other in the built app:
+` + collisions.map(([n2, paths]) => `  ${n2}
+` + [...paths].map((p2) => `    ${p2}`).join(`
+`)).join(`
+`));
+  }
+  const shippedNames = new Set(shipped.map((r2) => r2.name));
+  const missing = [...wanted].filter((n2) => !shippedNames.has(n2));
+  if (missing.length > 0) {
+    throw new CliError(`The bundle references assets with no local file: ${missing.join(", ")}`);
+  }
+  const exe = await resolveDesktopExe();
+  const hostDir = dirname11(exe);
+  const version = process.env.LECODES_DESKTOP_EXE ? "local build" : selectedDesktopVersion();
+  rmSync3(out, { recursive: true, force: true });
+  mkdirSync10(out, { recursive: true });
+  for (const entry of readdirSync6(hostDir, { withFileTypes: true })) {
+    const keep = entry.isFile() && entry.name.toLowerCase().endsWith(".dll") || entry.isDirectory() && (entry.name === "assets" || entry.name === "fonts");
+    if (keep)
+      cpSync2(join16(hostDir, entry.name), join16(out, entry.name), { recursive: true });
+  }
+  if (!existsSync15(join16(out, "assets", "initial.js"))) {
+    throw new CliError(`The host at ${hostDir} has no assets/initial.js next to it — a staged build can't boot. ` + `(LECODES_DESKTOP_EXE must point at an exe with its runtime assets/ beside it.)`);
+  }
+  const exeName2 = process.platform === "win32" ? `${cleanFileName(name)}.exe` : cleanFileName(name);
+  cpSync2(exe, join16(out, exeName2));
+  note(`  host: LeCodes Desktop ${version}`);
+  writeFileSync12(join16(out, "app.js"), js);
+  let assetBytes = 0, assetCount = 0;
+  for (const r2 of shipped) {
+    if (!r2.absPath || !existsSync15(r2.absPath) || !statSync4(r2.absPath).isFile()) {
+      warn(`asset "${r2.name}" (${r2.path}) has no local file — skipped`);
+      continue;
+    }
+    cpSync2(r2.absPath, join16(out, r2.name));
+    assetBytes += statSync4(r2.absPath).size;
+    assetCount++;
+  }
+  note(`  assets: ${assetCount} files, ${mb(assetBytes)}`);
+  writeJson(join16(out, "app.json"), { name, ...config.desktop ? { desktop: { window: config.desktop.window } } : {} });
+  if (config.icon) {
+    await writeIco(root, config, join16(out, "app.ico"));
+    note("  app.ico rendered from " + config.icon);
+  }
+  writeFileSync12(join16(out, "README.txt"), "\uFEFF" + readmeText(name, exeName2, version));
+  success(`Portable build: ${out}  (${mb(dirSize(out))})`);
+  if (flagBool(args, "probe"))
+    await probeBuild(out, exeName2, config, args);
+  if (flagBool(args, "zip"))
+    zipBuild(out);
+  if (!flagBool(args, "probe"))
+    note(`Tip: --probe renders the staged folder headless to verify exactly what ships.`);
+};
+var writeIco = async (root, config, dest) => {
+  const { image: image2 } = await loadIconMaster(root, config);
+  const sizes = [16, 24, 32, 48, 64, 256];
+  const pngs = [];
+  for (const s2 of sizes) {
+    const frame = image2.clone();
+    frame.resize({ w: s2, h: s2 });
+    pngs.push(Buffer.from(await frame.getBuffer("image/png")));
+  }
+  const header = Buffer.alloc(6 + sizes.length * 16);
+  header.writeUInt16LE(0, 0);
+  header.writeUInt16LE(1, 2);
+  header.writeUInt16LE(sizes.length, 4);
+  let offset = header.length;
+  sizes.forEach((s2, i2) => {
+    const e2 = 6 + i2 * 16;
+    header.writeUInt8(s2 === 256 ? 0 : s2, e2);
+    header.writeUInt8(s2 === 256 ? 0 : s2, e2 + 1);
+    header.writeUInt16LE(1, e2 + 4);
+    header.writeUInt16LE(32, e2 + 6);
+    header.writeUInt32LE(pngs[i2].length, e2 + 8);
+    header.writeUInt32LE(offset, e2 + 12);
+    offset += pngs[i2].length;
+  });
+  writeFileSync12(dest, Buffer.concat([header, ...pngs]));
+};
+var probeBuild = async (out, exeName2, config, args) => {
+  const win = config.desktop?.window;
+  const frames = Number(flagStr(args, "frames")) || 90;
+  const shot = join16(dirname11(out), `${basename5(out)}-probe.png`);
+  note(`Probe: hidden render of the staged folder (${frames} frames)…`);
+  await new Promise((done, fail) => {
+    const child = spawn3(join16(out, exeName2), [], {
+      cwd: out,
+      env: {
+        ...process.env,
+        CREATOR_HIDDEN: "1",
+        CREATOR_MAX_FRAMES: String(frames),
+        CREATOR_DUMP_PNG: shot,
+        CREATOR_WINDOW_SIZE: `${win?.width ?? 1280}x${win?.height ?? 720}`
+      },
+      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 — raise --frames headroom or check the app."));
+    }, 120000);
+    child.on("error", (e2) => {
+      clearTimeout(killer);
+      fail(new CliError(`Probe couldn't run: ${e2.message}`));
+    });
+    child.on("exit", (code) => {
+      clearTimeout(killer);
+      if (code === 0 && existsSync15(shot)) {
+        success(`Probe: ${shot}`);
+        done();
+      } else {
+        const detail = tail.length > 0 ? `
+${tail.join("").trimEnd()}` : "";
+        fail(new CliError(`Probe failed (exit ${code}).${detail}`));
+      }
+    });
+  });
+};
+var zipBuild = (out) => {
+  const zip = `${out}.zip`;
+  rmSync3(zip, { force: true });
+  note("Zipping…");
+  if (process.platform === "win32") {
+    const q = (s2) => s2.replaceAll("'", "''");
+    execFileSync3("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');`,
+      "Get-ChildItem $src -Recurse -File | ForEach-Object {",
+      "  $rel=$_.FullName.Substring($base.Length+1).Replace('\\','/');",
+      "  [void][System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile($zip,$_.FullName,$rel,'Optimal') };",
+      "$zip.Dispose()"
+    ].join(" ")], { stdio: ["ignore", "ignore", "pipe"] });
+  } else {
+    execFileSync3("zip", ["-rq", zip, basename5(out)], { cwd: dirname11(out) });
+  }
+  success(`Zip: ${zip} (${mb(statSync4(zip).size)})`);
+};
+var readmeText = (name, exeName2, version) => `${name}
+${"=".repeat(Math.max(name.length, 4))}
+
+A LeCodes desktop app. Nothing to install: unpack the WHOLE folder anywhere and run ${exeName2}.
+Keep the files together — the app reads its assets from this folder.
+
+On first run Windows may show a SmartScreen prompt (any unsigned app gets one):
+choose "More info", then "Run anyway".
+
+Requires 64-bit Windows 10/11.
+
+Built with LeCodes Desktop ${version}.
+`;
+
 // src/commands/app.ts
 var SDK_REPO = "letary/lecodes-ios-sdk";
 var SDK_MIN_VERSION = "1.2.0";
 var SDK_VARIANTS = ["core", "2d", "3d", "full"];
 var SDK_IDENTITY_VERSION = "1.6.0";
 var shellSdkVersion = (iosDir) => {
-  const path2 = join15(iosDir, "LeCodesRuntime", "Package.swift");
-  if (!existsSync14(path2))
+  const path2 = join17(iosDir, "LeCodesRuntime", "Package.swift");
+  if (!existsSync16(path2))
     return null;
-  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync14(path2, "utf8"));
+  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync15(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" };
@@ -48001,15 +48478,17 @@ var appInit = async (args) => {
   const platform = args._[1];
   if (platform === "android")
     return initAndroid(args);
+  if (platform === "desktop")
+    return initDesktop(args);
   if (platform !== "ios") {
-    throw new CliError(platform ? `Unsupported platform "${platform}" — use ios or android.` : "Usage: lecodes app init <ios|android> [--name <display name>] [--bundle-id <id>] [--team <team id>] [--variant auto|core|2d|3d|full] [--app-id <application id>] [--sdk <version|latest>]");
+    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 = join15(root, "ios");
-  if (existsSync14(iosDir)) {
+  const iosDir = join17(root, "ios");
+  if (existsSync16(iosDir)) {
     throw new CliError("ios/ already exists — run `lecodes app sync` to update it.");
   }
-  const existing = readJson(join15(root, "app.json")) ?? {};
+  const existing = readJson(join17(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}")`);
@@ -48017,7 +48496,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 ?? basename5(root);
+  const name = flagStr(args, "name") ?? existing.name ?? basename6(root);
   const config = {
     ...existing,
     name,
@@ -48031,7 +48510,7 @@ var appInit = async (args) => {
       buildNumber: existing.ios?.buildNumber ?? 1
     }
   };
-  writeJson(join15(root, "app.json"), config);
+  writeJson(join17(root, "app.json"), config);
   log(`${c.green("written")}   app.json`);
   ensureShellIgnored(root, "ios");
   const identity = {
@@ -48042,9 +48521,9 @@ var appInit = async (args) => {
     buildNumber: config.ios.buildNumber
   };
   const write = (rel, content) => {
-    const abs = join15(iosDir, rel);
-    mkdirSync9(dirname11(abs), { recursive: true });
-    writeFileSync11(abs, content);
+    const abs = join17(iosDir, rel);
+    mkdirSync11(dirname12(abs), { recursive: true });
+    writeFileSync13(abs, content);
     log(`${c.green("created")}   ios/${rel}`);
   };
   write("README.md", IOS_README);
@@ -48099,23 +48578,23 @@ var ensureSdkResourcesBundle = async (sdkVersion) => {
   const override = process.env.LECODES_SDK_RESOURCES;
   if (override) {
     note(`Using local resources bundle ${override} (LECODES_SDK_RESOURCES)`);
-    return resolve4(override);
+    return resolve6(override);
   }
-  const dir = join15(homedir5(), ".lecodes", "sdk-resources", sdkVersion);
-  const bundle = join15(dir, "LeCodesSDKResources.bundle");
-  if (existsSync14(bundle))
+  const dir = join17(homedir6(), ".lecodes", "sdk-resources", sdkVersion);
+  const bundle = join17(dir, "LeCodesSDKResources.bundle");
+  if (existsSync16(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}`);
-  mkdirSync9(dir, { recursive: true });
-  const zip = join15(dir, "LeCodesSDKResources.bundle.zip");
-  writeFileSync11(zip, new Uint8Array(await res.arrayBuffer()));
-  execFileSync3("ditto", ["-x", "-k", zip, dir]);
-  rmSync2(zip);
-  if (!existsSync14(bundle))
+  mkdirSync11(dir, { recursive: true });
+  const zip = join17(dir, "LeCodesSDKResources.bundle.zip");
+  writeFileSync13(zip, new Uint8Array(await res.arrayBuffer()));
+  execFileSync4("ditto", ["-x", "-k", zip, dir]);
+  rmSync4(zip);
+  if (!existsSync16(bundle))
     throw new CliError(`No LeCodesSDKResources.bundle inside the release asset ${url}`);
   return bundle;
 };
@@ -48140,13 +48619,13 @@ var resolveUpdateUrl = (update, root) => {
 };
 var appSync = async (args) => {
   const root = projectRoot();
-  const config = readJson(join15(root, "app.json"));
+  const config = readJson(join17(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 && existsSync14(join15(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync14(join15(root, "android"));
+  const hasIos = !!config?.ios && existsSync16(join17(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync16(join17(root, "android"));
   if (platform === "ios" && !hasIos)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   if (platform === "android" && !hasAndroid)
@@ -48161,7 +48640,7 @@ var appSync = async (args) => {
     await syncAndroid(root, config, iosArtifacts);
 };
 var syncIos = async (root, config) => {
-  const iosDir = join15(root, "ios");
+  const iosDir = join17(root, "ios");
   if (!config.ios)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   const requestedVariant = config.ios.variant ?? "auto";
@@ -48171,14 +48650,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 = join15(root, "plugins.lock.json");
+  const lockPath = join17(root, "plugins.lock.json");
   const oldLock = readJson(lockPath)?.plugins ?? {};
   const pluginSpecs = Object.entries(config.plugins ?? {});
   const runtimePlugins = [];
   const infoValues = {};
   const entitlementValues = {};
   const newLock = {};
-  const sourcesDir = join15(iosDir, "LeCodesRuntime", "Sources");
+  const sourcesDir = join17(iosDir, "LeCodesRuntime", "Sources");
   for (const [id, spec] of pluginSpecs) {
     const plugin = resolvePlugin(id, spec, oldLock[id], "ios");
     const ios = plugin.manifest.ios;
@@ -48186,12 +48665,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 = join15(plugin.dir, ios.sources ?? "ios");
-    if (!existsSync14(src))
+    const src = join17(plugin.dir, ios.sources ?? "ios");
+    if (!existsSync16(src))
       throw new CliError(`Plugin "${id}": sources dir ${src} missing`);
-    const dest = join15(sourcesDir, module);
-    rmSync2(dest, { recursive: true, force: true });
-    cpSync2(src, dest, { recursive: true });
+    const dest = join17(sourcesDir, module);
+    rmSync4(dest, { recursive: true, force: true });
+    cpSync3(src, dest, { recursive: true });
     if (ios.minSdk && VERSION_RE.test(ios.minSdk) && cmpVersion(sdkVersion, ios.minSdk) < 0) {
       throw new CliError(`Plugin "${id}" needs lecodes-ios-sdk ${ios.minSdk} but the shell links ${sdkVersion} — run \`lecodes app update\` (or set app.json ios.sdk).`);
     }
@@ -48206,9 +48685,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 existsSync14(sourcesDir) ? readdirSync5(sourcesDir) : []) {
-    if (!keep.has(entry) && statSync3(join15(sourcesDir, entry)).isDirectory()) {
-      rmSync2(join15(sourcesDir, entry), { recursive: true });
+  for (const entry of existsSync16(sourcesDir) ? readdirSync7(sourcesDir) : []) {
+    if (!keep.has(entry) && statSync5(join17(sourcesDir, entry)).isDirectory()) {
+      rmSync4(join17(sourcesDir, entry), { recursive: true });
       log(`${c.yellow("removed")}   ios/LeCodesRuntime/Sources/${entry}  (plugin uninstalled)`);
     }
   }
@@ -48216,11 +48695,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 = join15(iosDir, "App", "Resources");
-  rmSync2(resourcesDir, { recursive: true, force: true });
-  mkdirSync9(resourcesDir, { recursive: true });
-  const resources = await compileShell({ _: [], flags: { o: join15(resourcesDir, "app.js") } }, { remotePatterns });
-  const bundleJs = readFileSync14(join15(resourcesDir, "app.js"), "utf8");
+  const resourcesDir = join17(iosDir, "App", "Resources");
+  rmSync4(resourcesDir, { recursive: true, force: true });
+  mkdirSync11(resourcesDir, { recursive: true });
+  const resources = await compileShell({ _: [], flags: { o: join17(resourcesDir, "app.js") } }, { remotePatterns });
+  const bundleJs = readFileSync15(join17(resourcesDir, "app.js"), "utf8");
   const { variant, detected } = resolveVariant(requestedVariant, bundleJs);
   const WHY = {
     core: "UI only",
@@ -48234,8 +48713,8 @@ var syncIos = async (root, config) => {
   const sdkProvided = new Set;
   if (variant === "3d" || variant === "full") {
     const sdkResources = await ensureSdkResourcesBundle(sdkVersion);
-    cpSync2(sdkResources, join15(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
-    for (const f3 of readdirSync5(sdkResources))
+    cpSync3(sdkResources, join17(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
+    for (const f3 of readdirSync7(sdkResources))
       if (f3 !== "Info.plist")
         sdkProvided.add(f3);
     log(`${c.green("resources")} LeCodesSDKResources.bundle (filament) → ios/App/Resources/`);
@@ -48262,7 +48741,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}`);
-    cpSync2(candidates[0].absPath, join15(resourcesDir, name));
+    cpSync3(candidates[0].absPath, join17(resourcesDir, name));
     embedded++;
   }
   if (embedded > 0)
@@ -48282,20 +48761,20 @@ var syncIos = async (root, config) => {
   }
   if (shellUuid)
     log(`${c.green("identity")}  project ${shellUuid} baked into the shell (world identity)`);
-  writeFileSync11(join15(iosDir, "README.md"), IOS_README);
-  writeFileSync11(join15(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
-  writeFileSync11(join15(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins, shellUuid));
+  writeFileSync13(join17(iosDir, "README.md"), IOS_README);
+  writeFileSync13(join17(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
+  writeFileSync13(join17(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins, shellUuid));
   const mergedKeys = {};
   for (const [key, values] of Object.entries(infoValues))
     mergedKeys[key] = [...new Set(values)].join(" ");
   const updateUrl = resolveUpdateUrl(config.update, root);
-  writeFileSync11(join15(iosDir, "App", "Info.plist"), infoPlistTemplate(mergedKeys, updateUrl));
+  writeFileSync13(join17(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`);
-  if (pluginSpecs.length > 0 || existsSync14(lockPath))
+  if (pluginSpecs.length > 0 || existsSync16(lockPath))
     writeJson(lockPath, { plugins: newLock });
-  const pbxPath = join15(iosDir, "App.xcodeproj", "project.pbxproj");
-  let pbx = readFileSync14(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 = join17(iosDir, "App.xcodeproj", "project.pbxproj");
+  let pbx = readFileSync15(pbxPath, "utf8").replace(/MARKETING_VERSION = [^;]+;/g, `MARKETING_VERSION = ${config.version ?? "1.0.0"};`).replace(/CURRENT_PROJECT_VERSION = [^;]+;/g, `CURRENT_PROJECT_VERSION = ${config.ios.buildNumber ?? 1};`);
   const mergedEntitlements = {};
   for (const [key, values] of Object.entries(entitlementValues)) {
     if (values.every((v) => Array.isArray(v))) {
@@ -48316,7 +48795,7 @@ var syncIos = async (root, config) => {
   }
   const hasEntitlements = Object.keys(mergedEntitlements).length > 0;
   if (pbx.includes("CODE_SIGN_ENTITLEMENTS") || hasEntitlements) {
-    writeFileSync11(join15(iosDir, "App", "App.entitlements"), entitlementsTemplate(mergedEntitlements));
+    writeFileSync13(join17(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")) {
@@ -48332,7 +48811,7 @@ $2Info.plist,`);
       }
     }
   }
-  writeFileSync11(pbxPath, pbx);
+  writeFileSync13(pbxPath, pbx);
   if (config.icon) {
     await writeIosAppIcon(iosDir, await loadIconMaster(root, config));
   }
@@ -48344,7 +48823,7 @@ $2Info.plist,`);
 var appPlugin = async (args) => {
   const sub = args._[1];
   const root = projectRoot();
-  const configPath = join15(root, "app.json");
+  const configPath = join17(root, "app.json");
   const config = readJson(configPath);
   if (!config)
     throw new CliError("No app.json here — run `lecodes app init <ios|android>` first.");
@@ -48355,7 +48834,7 @@ var appPlugin = async (args) => {
       log("No plugins installed.");
       return;
     }
-    const lock = readJson(join15(root, "plugins.lock.json"))?.plugins ?? {};
+    const lock = readJson(join17(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}`);
@@ -48408,14 +48887,14 @@ var exportOptionsPlist = (method, teamId, destination) => `<?xml version="1.0" e
 `;
 var requireShell = () => {
   const root = projectRoot();
-  const config = readJson(join15(root, "app.json"));
-  if (!config?.ios || !existsSync14(join15(root, "ios"))) {
+  const config = readJson(join17(root, "app.json"));
+  if (!config?.ios || !existsSync16(join17(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(join15(root, "ios"))] : ["lecodes-android-sdk", ANDROID_SDK_REPO, ANDROID_SDK_MIN_VERSION, () => shellSdkVersionAndroid(join15(root, "android"))];
+  const [label, repo, minVersion, shellVersion] = platform === "ios" ? ["lecodes-ios-sdk", SDK_REPO, SDK_MIN_VERSION, () => shellSdkVersion(join17(root, "ios"))] : ["lecodes-android-sdk", ANDROID_SDK_REPO, ANDROID_SDK_MIN_VERSION, () => shellSdkVersionAndroid(join17(root, "android"))];
   const section = config[platform];
   const wanted = flagStr(args, "sdk");
   let changed = false;
@@ -48446,19 +48925,19 @@ var updateSdkPin = async (root, config, args, checkOnly, platform) => {
   }
   if (!checkOnly && nextPin !== pin) {
     section.sdk = nextPin;
-    writeJson(join15(root, "app.json"), config);
+    writeJson(join17(root, "app.json"), config);
   }
   return changed;
 };
 var appUpdate = async (args) => {
   const root = projectRoot();
-  const config = readJson(join15(root, "app.json"));
+  const config = readJson(join17(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 && existsSync14(join15(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync14(join15(root, "android"));
+  const hasIos = !!config?.ios && existsSync16(join17(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync16(join17(root, "android"));
   if (platform === "ios" && !hasIos)
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   if (platform === "android" && !hasAndroid)
@@ -48476,7 +48955,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 = join15(root, "plugins.lock.json");
+  const lockPath = join17(root, "plugins.lock.json");
   const lock = readJson(lockPath)?.plugins ?? {};
   const specs = Object.entries(config.plugins ?? {});
   if (specs.length > 0 && !flagBool(args, "no-plugins")) {
@@ -48505,7 +48984,7 @@ var appUpdate = async (args) => {
       log(`${c.green("plugin")}    ${id} ${entry?.tag ?? "—"} → ${c.bold(tag)}`);
       changed = true;
     }
-    if (!checkOnly && existsSync14(lockPath))
+    if (!checkOnly && existsSync16(lockPath))
       writeJson(lockPath, { plugins: kept });
   }
   log("");
@@ -48525,9 +49004,9 @@ var appUpdate = async (args) => {
 };
 var appDoctor = async (_args) => {
   const root = projectRoot();
-  const config = readJson(join15(root, "app.json"));
-  const hasIos = !!config?.ios && existsSync14(join15(root, "ios"));
-  const hasAndroid = !!config?.android && existsSync14(join15(root, "android"));
+  const config = readJson(join17(root, "app.json"));
+  const hasIos = !!config?.ios && existsSync16(join17(root, "ios"));
+  const hasAndroid = !!config?.android && existsSync16(join17(root, "android"));
   if (!hasIos && !hasAndroid) {
     throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
   }
@@ -48538,14 +49017,14 @@ var appDoctor = async (_args) => {
       failed++;
   };
   if (config?.icon) {
-    check(existsSync14(join15(root, config.icon)), `Icon master ${config.icon}`, `app.json "icon" points at a missing file — sync will fail`);
+    check(existsSync16(join17(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(join15(root, "plugins.lock.json"))?.plugins ?? {};
+      const lock = readJson(join17(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`");
@@ -48564,22 +49043,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 = join15(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
-  const hasIcon = existsSync14(iconDir) && readdirSync5(iconDir).some((f3) => f3.endsWith(".png"));
+  const iconDir = join17(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
+  const hasIcon = existsSync16(iconDir) && readdirSync7(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 = join15(root, "ios", "App", "Resources", "app.js");
-  check(existsSync14(bundle), "Bundled app.js", "run `lecodes app sync`");
+  const bundle = join17(root, "ios", "App", "Resources", "app.js");
+  check(existsSync16(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 (existsSync14(bundle) && validVariant) {
-    const { variant } = resolveVariant(requestedVariant, readFileSync14(bundle, "utf8"));
-    const pkg = readFileSync14(join15(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
+  if (existsSync16(bundle) && validVariant) {
+    const { variant } = resolveVariant(requestedVariant, readFileSync15(bundle, "utf8"));
+    const pkg = readFileSync15(join17(root, "ios", "LeCodesRuntime", "Package.swift"), "utf8");
     const needsResources = variant === "3d" || variant === "full";
-    const hasResources = existsSync14(join15(root, "ios", "App", "Resources", "LeCodesSDKResources.bundle"));
+    const hasResources = existsSync16(join17(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(join15(root, "ios"));
+  const linked = shellSdkVersion(join17(root, "ios"));
   const pin = config.ios.sdk ?? "latest";
   check(!!linked, `SDK ${linked ?? "version unreadable"}`, "run `lecodes app sync`");
   if (linked && pin !== "latest") {
@@ -48591,24 +49070,24 @@ 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(join15(root, "plugins.lock.json"))?.plugins ?? {};
+  const lock = readJson(join17(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 = join15(root, "ios", "App.xcodeproj", "project.pbxproj");
-  if (existsSync14(pbxFile) && readFileSync14(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
-    check(existsSync14(join15(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
+  const pbxFile = join17(root, "ios", "App.xcodeproj", "project.pbxproj");
+  if (existsSync16(pbxFile) && readFileSync15(pbxFile, "utf8").includes("CODE_SIGN_ENTITLEMENTS")) {
+    check(existsSync16(join17(root, "ios", "App", "App.entitlements")), "App/App.entitlements present", "run `lecodes app sync`");
   }
   if (wanted.includes("push")) {
-    const runtimeSwift = join15(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
-    const baked = existsSync14(runtimeSwift) && readFileSync14(runtimeSwift, "utf8").includes("bootProjectUuid");
+    const runtimeSwift = join17(root, "ios", "LeCodesRuntime", "Sources", "LeCodesRuntime", "LeCodesRuntime.swift");
+    const baked = existsSync16(runtimeSwift) && readFileSync15(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 = readFileSync14(join15(root, "ios", "App", "Info.plist"), "utf8");
+    const plist = readFileSync15(join17(root, "ios", "App", "Info.plist"), "utf8");
     check(plist.includes("<key>LeCodesUpdateURL</key>"), "OTA update URL in Info.plist", "run `lecodes app sync`", false);
   }
-  const asc = readJson(join15(homedir5(), ".lecodes", "asc.json"));
+  const asc = readJson(join17(homedir6(), ".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";
@@ -48616,8 +49095,10 @@ var appBuild = async (args) => {
   const platform = args._[1];
   if (platform === "android")
     return buildAndroid(args);
+  if (platform === "desktop")
+    return buildDesktop(args);
   if (platform !== undefined && platform !== "ios") {
-    throw new CliError(`Unknown platform "${platform}" — use ios or android.`);
+    throw new CliError(`Unknown platform "${platform}" — use ios, android or desktop.`);
   }
   const { root, config } = requireShell();
   const configuration = flagStr(args, "configuration") ?? "Release";
@@ -48642,8 +49123,8 @@ var appBuild = async (args) => {
   success(`Archive: ios/build/App.xcarchive`);
   if (flagBool(args, "no-export"))
     return;
-  const optionsPath = join15(root, "ios", "build", "ExportOptions.plist");
-  writeFileSync11(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
+  const optionsPath = join17(root, "ios", "build", "ExportOptions.plist");
+  writeFileSync13(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
   note(`Exporting (.ipa, method ${method})…`);
   runTool(root, "xcodebuild", [
     "-exportArchive",
@@ -48662,10 +49143,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 (!existsSync14(join15(root, ARCHIVE_PATH))) {
+  if (!existsSync16(join17(root, ARCHIVE_PATH))) {
     throw new CliError("No archive at ios/build/App.xcarchive — run `lecodes app build ios` first.");
   }
-  const ascPath = join15(homedir5(), ".lecodes", "asc.json");
+  const ascPath = join17(homedir6(), ".lecodes", "asc.json");
   const stored = readJson(ascPath) ?? {};
   const keyPath = flagStr(args, "key-path") ?? stored.keyPath;
   const keyId = flagStr(args, "key-id") ?? stored.keyId;
@@ -48674,15 +49155,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 (!existsSync14(keyPath))
+  if (!existsSync16(keyPath))
     throw new CliError(`API key file not found: ${keyPath}`);
   if (flagStr(args, "key-path")) {
-    mkdirSync9(dirname11(ascPath), { recursive: true });
+    mkdirSync11(dirname12(ascPath), { recursive: true });
     writeJson(ascPath, { keyPath, keyId, issuerId });
     note("Stored the key reference in ~/.lecodes/asc.json");
   }
-  const optionsPath = join15(root, "ios", "build", "UploadOptions.plist");
-  writeFileSync11(optionsPath, exportOptionsPlist("app-store-connect", config.ios.teamId ?? "", "upload"));
+  const optionsPath = join17(root, "ios", "build", "UploadOptions.plist");
+  writeFileSync13(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",
@@ -48693,14 +49174,14 @@ var appUpload = async (args) => {
     "-exportPath",
     "ios/build/upload",
     "-authenticationKeyPath",
-    resolve4(keyPath),
+    resolve6(keyPath),
     "-authenticationKeyID",
     keyId,
     "-authenticationKeyIssuerID",
     issuerId,
     "-allowProvisioningUpdates"
   ]);
-  const configPath = join15(root, "app.json");
+  const configPath = join17(root, "app.json");
   const fresh = readJson(configPath);
   fresh.ios.buildNumber = (fresh.ios.buildNumber ?? 1) + 1;
   writeJson(configPath, fresh);
@@ -48711,19 +49192,19 @@ var appOpen = async (args) => {
   const root = projectRoot();
   let platform = args._[1];
   if (!platform) {
-    const hasIos = existsSync14(join15(root, "ios"));
-    const hasAndroid = existsSync14(join15(root, "android"));
+    const hasIos = existsSync16(join17(root, "ios"));
+    const hasAndroid = existsSync16(join17(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 = join15(root, "ios", "App.xcodeproj");
-    if (!existsSync14(proj))
+    const proj = join17(root, "ios", "App.xcodeproj");
+    if (!existsSync16(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.");
-    execFileSync3("open", [proj], { stdio: "ignore" });
+    execFileSync4("open", [proj], { stdio: "ignore" });
     success("Opened ios/App.xcodeproj in Xcode.");
     return;
   }
@@ -48749,15 +49230,15 @@ var app = async (args) => {
     return appUpload(args);
   if (sub === "open")
     return appOpen(args);
-  throw new CliError("Usage: lecodes app <init ios|android | sync | update | open | plugin list|add|remove | doctor | build ios|android | upload ios> — see `lecodes help`.");
+  throw new CliError("Usage: lecodes app <init ios|android|desktop | sync | update | open | plugin list|add|remove | doctor | build ios|android|desktop | upload ios> — see `lecodes help`.");
 };
 
 // src/commands/clone.ts
 init_api();
 init_config();
 init_manifest();
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readdirSync as readdirSync7 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, readdirSync as readdirSync9 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
 init_types4();
 init_ignore();
 init_util();
@@ -48778,11 +49259,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 = resolve5(dir);
-  if (existsSync16(root) && readdirSync7(root).length > 0) {
+  const root = resolve7(dir);
+  if (existsSync18(root) && readdirSync9(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync11(root, { recursive: true });
+  mkdirSync13(root, { recursive: true });
   info(c.dim(`Fetching project ${c.bold(project.name)}…`));
   const files = await materializeAssets(root, project, apiUrl, token, progress);
   endProgress();
@@ -48804,8 +49285,8 @@ init_config();
 init_manifest();
 init_types4();
 init_ignore();
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readdirSync as readdirSync8, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join17, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14, readdirSync as readdirSync10, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join19, resolve as resolve8 } from "node:path";
 
 // src/commands/projectTemplates.ts
 var appClaudeMd = (name) => `# ${name} — LeCodes app
@@ -48861,11 +49342,28 @@ optional \`expect\` (\`screen\`, \`node\`/\`notNode\`, \`text\`/\`notText\`,
   with \`"fixtures": "fixtures.json"\` in its envelope.
 - \`fill\` fills every empty input — use it before tapping a disabled-until-filled submit.
 
+## SDK documentation
+
+\`.lecodes/types/\` is the exact API surface (signatures only). For semantics and examples,
+fetch the docs — they are served as raw markdown for AI tools:
+
+- https://le.codes/llms.txt — the docs map; fetch it first to find the right page
+- https://le.codes/en/docs/api/<area>/<page>.md — one reference page as raw markdown
+  (e.g. \`ui/styling.md\`, \`2d/scene2d.md\`, \`3d/scene.md\`, \`runtime/storage.md\`)
+- https://le.codes/en/docs/guide/<page>.md — guide pages (project anatomy, CLI, tracks)
+- https://le.codes/llms-full.txt — everything in one file (large; prefer per-page)
+
+Always fetch the \`.md\` URLs — the HTML routes are a JS app and return an empty shell.
+
 ## Other commands
 
 \`lecodes dev\` (run on a device with hot reload + QR), \`lecodes compile -o app.js\`
 (single-file bundle), \`lecodes design\` (screen-design board — the living spec).
 `;
+var CLAUDE_SETTINGS = JSON.stringify({
+  permissions: { allow: ["WebFetch(domain:le.codes)"] }
+}, null, 2) + `
+`;
 var STARTER_FLOW = `{
   "name": "counter",
   "steps": [
@@ -48895,19 +49393,21 @@ var create = async (args) => {
   if (!name)
     throw new CliError("Usage: lecodes create <name> [directory]");
   const dir = args._[1] ?? slug2(name);
-  const root = resolve6(dir);
-  if (existsSync17(root) && readdirSync8(root).length > 0) {
+  const root = resolve8(dir);
+  if (existsSync19(root) && readdirSync10(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync12(root, { recursive: true });
+  mkdirSync14(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);
-  writeFileSync13(join17(root, "main.ts"), STARTER);
-  writeFileSync13(join17(root, "CLAUDE.md"), appClaudeMd(name));
+  writeFileSync15(join19(root, "main.ts"), STARTER);
+  writeFileSync15(join19(root, "CLAUDE.md"), appClaudeMd(name));
+  mkdirSync14(join19(root, ".claude"), { recursive: true });
+  writeFileSync15(join19(root, ".claude", "settings.json"), CLAUDE_SETTINGS);
   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)}/`);
@@ -48917,260 +49417,18 @@ var create = async (args) => {
 // src/commands/desktop.ts
 init_util();
 init_manifest();
-
-// src/desktopRenderer.ts
-init_util();
-import { createHash as createHash5 } from "node:crypto";
-import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync13, mkdtempSync, readdirSync as readdirSync9, readFileSync as readFileSync16, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync5, writeFileSync as writeFileSync14 } from "node:fs";
-import { homedir as homedir6, tmpdir } from "node:os";
-import { join as join18, resolve as resolve7 } from "node:path";
-var MANIFEST_URL = "https://storage.yandexcloud.net/le-codes/releases/versions.json";
-var DESKTOP_RENDERER_VERSION = "1.1.0";
-var semverNewer = (a2, b) => {
-  const pa = a2.split(/[.-]/).map(Number), pb = b.split(/[.-]/).map(Number);
-  for (let i2 = 0;i2 < 3; i2++)
-    if ((pb[i2] ?? 0) !== (pa[i2] ?? 0))
-      return (pb[i2] ?? 0) - (pa[i2] ?? 0);
-  return 0;
-};
-var platformKey = () => {
-  if (process.platform === "win32")
-    return "windows-x64";
-  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}.`);
-};
-var exeName = () => process.platform === "win32" ? "lecodes-desktop.exe" : "lecodes-desktop";
-var findExe = (dir) => {
-  const name = exeName();
-  for (const entry of readdirSync9(dir, { withFileTypes: true })) {
-    const p2 = join18(dir, entry.name);
-    if (entry.isFile() && entry.name === name)
-      return p2;
-    if (entry.isDirectory()) {
-      const found = findExe(p2);
-      if (found)
-        return found;
-    }
-  }
-  return null;
-};
-var cacheRoot = () => join18(homedir6(), ".lecodes", "renderer");
-var currentFile = () => join18(cacheRoot(), "current.json");
-var installedDesktopVersions = () => {
-  try {
-    return readdirSync9(cacheRoot(), { withFileTypes: true }).filter((e2) => e2.isDirectory() && e2.name.startsWith("desktop-")).map((e2) => e2.name.slice("desktop-".length)).filter((v) => findExe(join18(cacheRoot(), `desktop-${v}`)) !== null).sort(semverNewer);
-  } catch {
-    return [];
-  }
-};
-var selectedDesktopVersion = () => {
-  try {
-    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 = async () => {
-  let manifest;
-  try {
-    const res = await fetch(MANIFEST_URL);
-    if (!res.ok)
-      throw new Error(`HTTP ${res.status}`);
-    manifest = await res.json();
-  } catch (e2) {
-    throw new CliError(`Can't fetch the release manifest (${MANIFEST_URL}): ${e2 instanceof Error ? e2.message : String(e2)}`);
-  }
-  const desktop = manifest.products?.desktop;
-  if (!desktop)
-    throw new CliError("The release manifest has no desktop product.");
-  return desktop;
-};
-var downloadDesktop = async (version, dest) => {
-  const key = platformKey();
-  const entry = (await fetchDesktopManifest()).versions.find((v) => v.version === version);
-  const file = entry?.files[key];
-  if (!file) {
-    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)…`);
-  let bytes;
-  try {
-    const res = await fetch(file.url);
-    if (!res.ok)
-      throw new Error(`HTTP ${res.status}`);
-    bytes = Buffer.from(await res.arrayBuffer());
-  } catch (e2) {
-    throw new CliError(`Download failed (${file.url}): ${e2 instanceof Error ? e2.message : String(e2)}`);
-  }
-  const sha = createHash5("sha256").update(bytes).digest("hex");
-  if (sha !== file.sha256)
-    throw new CliError(`Downloaded archive is corrupt (sha256 mismatch) — try again.`);
-  mkdirSync13(cacheRoot(), { recursive: true });
-  const stage = mkdtempSync(join18(cacheRoot(), "dl-"));
-  try {
-    const archive = join18(stage, file.url.split("/").pop() ?? "archive");
-    writeFileSync14(archive, bytes);
-    const tar = spawnSync3("tar", ["-xf", archive, "-C", stage], { stdio: ["ignore", "ignore", "pipe"] });
-    if (tar.status !== 0)
-      throw new CliError(`Couldn't extract the renderer archive: ${tar.stderr?.toString() ?? "tar failed"}`);
-    rmSync4(archive);
-    if (!findExe(stage))
-      throw new CliError("The downloaded archive doesn't contain the desktop host binary.");
-    try {
-      renameSync2(stage, dest);
-    } catch {
-      if (!findExe(dest))
-        throw new CliError(`Couldn't move the renderer into ${dest}.`);
-    }
-  } finally {
-    rmSync4(stage, { recursive: true, force: true });
-  }
-};
-var resolveDesktopExe = async () => {
-  const override = process.env.LECODES_DESKTOP_EXE;
-  if (override) {
-    if (!existsSync18(override))
-      throw new CliError(`LECODES_DESKTOP_EXE points at "${override}" which doesn't exist.`);
-    return resolve7(override);
-  }
-  const version = selectedDesktopVersion();
-  const dir = join18(cacheRoot(), `desktop-${version}`);
-  let exe = existsSync18(dir) ? findExe(dir) : null;
-  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.`);
-  }
-  return exe;
-};
-var updateDesktop = async () => {
-  const { latest } = await fetchDesktopManifest();
-  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(cacheRoot(), `desktop-${latest}`);
-  const hadIt = existsSync18(dir) && findExe(dir) !== null;
-  if (!hadIt)
-    await downloadDesktop(latest, dir);
-  mkdirSync13(cacheRoot(), { recursive: true });
-  writeFileSync14(currentFile(), JSON.stringify({ version: latest }, null, 2));
-  if (latest === before && hadIt)
-    note(`Already up to date: LeCodes Desktop ${latest}.`);
-  else if (latest === before)
-    note(`Re-downloaded LeCodes Desktop ${latest}.`);
-  else
-    note(`Desktop renderer set to ${latest} (was ${before}).`);
-};
-var windowEnv = (opts) => {
-  const env = {};
-  const width = opts.width ?? (opts.height !== undefined ? 1280 : undefined);
-  const height = opts.height ?? (opts.width !== undefined ? 720 : undefined);
-  if (width && height)
-    env.CREATOR_WINDOW_SIZE = `${width}x${height}`;
-  if (opts.minWidth && opts.minHeight)
-    env.CREATOR_MIN_WINDOW_SIZE = `${opts.minWidth}x${opts.minHeight}`;
-  if (opts.title)
-    env.CREATOR_WINDOW_TITLE = opts.title;
-  if (opts.resizable === false)
-    env.CREATOR_WINDOW_FIXED = "1";
-  return env;
-};
-var stageBundle = (js, resources) => {
-  const runDir = mkdtempSync(join18(tmpdir(), "lecodes-render-"));
-  writeFileSync14(join18(runDir, "app.js"), js);
-  for (const r2 of resources) {
-    if (r2.absPath && existsSync18(r2.absPath) && statSync5(r2.absPath).isFile()) {
-      copyFileSync(r2.absPath, join18(runDir, r2.name));
-    }
-  }
-  return runDir;
-};
-var runDesktopApp = async (js, resources, opts = {}) => {
-  const exe = await resolveDesktopExe();
-  const runDir = stageBundle(js, resources);
-  try {
-    const env = { ...process.env, ...windowEnv(opts) };
-    await new Promise((done, fail) => {
-      const child = spawn2(exe, [join18(runDir, "app.js")], { cwd: runDir, env, stdio: ["ignore", "inherit", "inherit"] });
-      child.on("error", (e2) => fail(new CliError(`Can't run the desktop host: ${e2.message}`)));
-      child.on("exit", (code) => {
-        if (code === 0 || code === null)
-          done();
-        else
-          fail(new CliError(`The desktop host exited with code ${code}.`));
-      });
-    });
-  } finally {
-    rmSync4(runDir, { recursive: true, force: true });
-  }
-};
-var runDesktopDev = async (url, opts = {}) => {
-  const exe = await resolveDesktopExe();
-  const env = { ...process.env, ...windowEnv(opts) };
-  await new Promise((done, fail) => {
-    const child = spawn2(exe, [url], { env, stdio: ["ignore", "ignore", "inherit"] });
-    child.on("error", (e2) => fail(new CliError(`Can't run the desktop host: ${e2.message}`)));
-    child.on("exit", () => done());
-  });
-};
-var runDesktopRender = async (js, resources, opts) => {
-  const exe = await resolveDesktopExe();
-  const runDir = stageBundle(js, resources);
-  try {
-    const appJs = join18(runDir, "app.js");
-    const outAbs = resolve7(opts.outPng);
-    await new Promise((done, fail) => {
-      const child = spawn2(exe, [appJs], {
-        cwd: runDir,
-        env: {
-          ...process.env,
-          CREATOR_DUMP_PNG: outAbs,
-          CREATOR_MAX_FRAMES: String(opts.frames),
-          CREATOR_WINDOW_SIZE: `${opts.width}x${opts.height}`,
-          CREATOR_HIDDEN: "1"
-        },
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      const tail = [];
-      const sink = (d) => {
-        const text = String(d);
-        tail.push(text);
-        while (tail.length > 80)
-          tail.shift();
-        if (opts.logs)
-          process.stderr.write(text);
-      };
-      child.stdout.on("data", sink);
-      child.stderr.on("data", sink);
-      const killer = setTimeout(() => {
-        child.kill();
-        fail(new CliError(`The native render timed out after ${opts.timeoutMs}ms (raise --timeout, or lower --frames).`));
-      }, opts.timeoutMs);
-      child.on("error", (e2) => {
-        clearTimeout(killer);
-        fail(new CliError(`Can't run the desktop renderer: ${e2.message}`));
-      });
-      child.on("exit", (code) => {
-        clearTimeout(killer);
-        if (code === 0 && existsSync18(outAbs))
-          return done();
-        const detail = tail.length > 0 ? `
-${tail.join("").trimEnd()}` : "";
-        fail(new CliError(code === 0 ? `The renderer exited cleanly but produced no PNG — did the app open a screen?${detail}` : `The renderer exited with code ${code}.${detail}`));
-      });
-    });
-  } finally {
-    rmSync4(runDir, { recursive: true, force: true });
+var resolveScale = (flag, cfg) => {
+  const raw = flag ?? cfg;
+  if (raw === undefined || raw === "system")
+    return;
+  if (raw === "fit")
+    return "fit";
+  const n2 = Number(raw);
+  if (!Number.isFinite(n2) || n2 < 0.5 || n2 > 4) {
+    throw new CliError(`scale must be a number 0.5..4, "fit" or "system" (got "${raw}")`);
   }
+  return n2;
 };
-
-// src/commands/desktop.ts
 var run = async (args) => {
   let root;
   try {
@@ -49188,7 +49446,9 @@ var run = async (args) => {
     minWidth: win?.minWidth,
     minHeight: win?.minHeight,
     resizable: win?.resizable,
-    title: flagStr(args, "title") ?? win?.title ?? appCfg?.name
+    title: flagStr(args, "title") ?? win?.title ?? appCfg?.name,
+    fullscreen: flagBool(args, "fullscreen") ? true : flagBool(args, "windowed") ? false : win?.fullscreen,
+    scale: resolveScale(flagStr(args, "scale"), win?.scale)
   });
 };
 var status = async () => {
@@ -49224,15 +49484,15 @@ init_design();
 // src/commands/dev.ts
 init_manifest();
 init_ignore();
-import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync19, watch, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync16, readFileSync as readFileSync19, watch, writeFileSync as writeFileSync17 } from "node:fs";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { basename as basename8, join as join20 } from "node:path";
+import { basename as basename9, join as join21 } from "node:path";
 
 // src/dev/devServer.ts
 init_localFiles();
 import { createServer as createServer2 } from "node:http";
-import { createReadStream, statSync as statSync6 } from "node:fs";
+import { createReadStream, statSync as statSync7 } from "node:fs";
 init_projectCompile();
 init_fonts();
 init_assetIcons();
@@ -49500,14 +49760,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((resolve8) => {
+var readBody = (req) => new Promise((resolve9) => {
   let body = "";
   req.on("data", (c4) => {
     if (body.length < 256 * 1024)
       body += c4.toString("utf8");
   });
-  req.on("end", () => resolve8(body));
-  req.on("error", () => resolve8(body));
+  req.on("end", () => resolve9(body));
+  req.on("error", () => resolve9(body));
 });
 var startDevServer = async (options) => {
   const { root, manifest, name, origin, token, entryOverride } = options;
@@ -49607,7 +49867,7 @@ var startDevServer = async (options) => {
         return sendText(res, 400, "text/plain", "Bad path");
       }
       const abs = resolveLocalPath(root, key);
-      if (!abs || !statSync6(abs).isFile())
+      if (!abs || !statSync7(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);
@@ -49650,11 +49910,11 @@ var startDevServer = async (options) => {
     if (conn)
       clients.add(conn);
   });
-  await new Promise((resolve8, reject) => {
+  await new Promise((resolve9, reject) => {
     server.once("error", reject);
     server.listen(options.port, options.bind ?? "0.0.0.0", () => {
       server.removeListener("error", reject);
-      resolve8();
+      resolve9();
     });
   });
   const address = server.address();
@@ -49702,24 +49962,24 @@ var lanCandidates = () => {
   return out.sort((x2, y2) => x2.rank - y2.rank).map(({ address, iface }) => ({ address, iface }));
 };
 var loadDevToken = (root) => {
-  const path2 = join20(root, LECODES_DIR, "dev.json");
+  const path2 = join21(root, LECODES_DIR, "dev.json");
   try {
     const token2 = JSON.parse(readFileSync19(path2, "utf8")).token;
     if (token2 && /^[a-z0-9]{8,}$/.test(token2))
       return token2;
   } catch {}
   const token = randomBytes2(6).toString("hex");
-  mkdirSync15(join20(root, LECODES_DIR), { recursive: true });
-  writeFileSync16(path2, JSON.stringify({ token }, null, 2) + `
+  mkdirSync16(join21(root, LECODES_DIR), { recursive: true });
+  writeFileSync17(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((resolve8) => qrcode.generate(url, { small: true }, (out) => {
+    await new Promise((resolve9) => qrcode.generate(url, { small: true }, (out) => {
       log(out);
-      resolve8();
+      resolve9();
     }));
   } catch {
     note("(couldn't render a QR code — open the URL below on the device)");
@@ -49735,7 +49995,7 @@ var dev = async (args) => {
     root = process.cwd();
     manifest = null;
   }
-  const name = manifest?.name ?? basename8(root);
+  const name = manifest?.name ?? basename9(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).");
   }
@@ -49827,7 +50087,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 (existsSync20(join20(root, LECODES_DIR, "manifest.json")))
+  if (existsSync21(join21(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.`);
@@ -49841,7 +50101,8 @@ ${result.error}`);
       minWidth: win?.minWidth,
       minHeight: win?.minHeight,
       resizable: win?.resizable,
-      title: win?.title ?? appCfg?.name ?? name
+      title: win?.title ?? appCfg?.name ?? name,
+      scale: resolveScale(undefined, win?.scale)
     }).then(() => note("Desktop window closed — the dev server keeps running (Ctrl+C to stop)."), (e2) => warnErr(`Desktop host: ${e2 instanceof Error ? e2.message : String(e2)}`));
   }
 };
@@ -49855,7 +50116,7 @@ init_localFiles();
 // src/serverDiff.ts
 init_localFiles();
 import { readFileSync as readFileSync20 } from "node:fs";
-import { basename as basename9 } from "node:path";
+import { basename as basename10 } from "node:path";
 var isTextAsset = (t2) => t2 === "text" || t2 === "shader" || t2 === "scene";
 var computeServerDiff = (project, scan2) => {
   const pathById = buildPaths(project.assets);
@@ -49872,7 +50133,7 @@ var computeServerDiff = (project, scan2) => {
     const server = serverByPath.get(path2);
     const local = localByPath.get(path2);
     if (local && !server) {
-      const text = isTextKind(classifyKind(basename9(path2)));
+      const text = isTextKind(classifyKind(basename10(path2)));
       entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync20(local.absPath, "utf8") : undefined });
       continue;
     }
@@ -50047,8 +50308,8 @@ var statusLabel = (e2) => e2.status === "added" ? c.green("  added    ") : e2.st
 init_manifest();
 init_types4();
 init_ignore();
-import { existsSync as existsSync21, mkdirSync as mkdirSync16, writeFileSync as writeFileSync17 } from "node:fs";
-import { basename as basename10, dirname as dirname13, join as join21, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18 } from "node:fs";
+import { basename as basename11, dirname as dirname14, join as join22, resolve as resolve9 } from "node:path";
 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\`.
@@ -50153,18 +50414,18 @@ Full command list: \`lecodes --help\`.
 `;
 var init2 = async (args) => {
   const dirArg = (args._[0] ?? ".").replace(/[/\\]+$/, "") || ".";
-  const root = resolve8(dirArg);
-  const name = basename10(root);
-  mkdirSync16(root, { recursive: true });
+  const root = resolve9(dirArg);
+  const name = basename11(root);
+  mkdirSync17(root, { recursive: true });
   let created = 0;
   const write = (rel, content) => {
-    const abs = join21(root, rel);
-    if (existsSync21(abs)) {
+    const abs = join22(root, rel);
+    if (existsSync22(abs)) {
       note(`kept      ${rel}`);
       return;
     }
-    mkdirSync16(dirname13(abs), { recursive: true });
-    writeFileSync17(abs, content);
+    mkdirSync17(dirname14(abs), { recursive: true });
+    writeFileSync18(abs, content);
     log(`${c.green("created")}   ${rel}`);
     created++;
   };
@@ -50174,6 +50435,7 @@ var init2 = async (args) => {
   if (forDesktop)
     write("app.json", appJsonDesktop(name));
   write("CLAUDE.md", appClaudeMd(name));
+  write(".claude/settings.json", CLAUDE_SETTINGS);
   write("tests/counter.flow.json", STARTER_FLOW);
   write(".lecodesignore", DEFAULT_IGNORE_FILE);
   const wroteTypes = materializeTypesLocal(root);
@@ -50202,8 +50464,8 @@ init_config();
 init_ignore();
 init_localFiles();
 init_manifest();
-import { existsSync as existsSync22 } from "node:fs";
-import { basename as basename12, join as join22, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { basename as basename13, join as join23, resolve as resolve10 } from "node:path";
 init_types4();
 init_util();
 
@@ -50212,7 +50474,7 @@ init_api();
 init_config();
 init_manifest();
 init_localFiles();
-import { basename as basename11 } from "node:path";
+import { basename as basename12 } from "node:path";
 import { readFileSync as readFileSync21 } from "node:fs";
 init_util();
 var push = async (args) => {
@@ -50269,14 +50531,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan2.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename11(file.path));
+    const kind = source?.type ?? classifyKind(basename12(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
       entry.text = readFileSync21(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename11(file.path), readFileSync21(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename12(file.path), readFileSync21(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -50383,10 +50645,10 @@ var link = async (args) => {
   const apiUrl = requireApiUrl(config);
   const token = requireToken(config);
   const dirArg = args._[0];
-  const root = dirArg ? resolve9(dirArg) : process.cwd();
-  if (!existsSync22(root))
+  const root = dirArg ? resolve10(dirArg) : process.cwd();
+  if (!existsSync23(root))
     throw new CliError(`No such directory: ${root}`);
-  if (existsSync22(join22(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
+  if (existsSync23(join23(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;
@@ -50413,7 +50675,7 @@ var link = async (args) => {
     }
     name = project.name;
   } else {
-    name = flagStr(args, "name") ?? basename12(root);
+    name = flagStr(args, "name") ?? basename13(root);
     info(c.dim(`Creating project ${c.bold(name)}…`));
     uuid = (await createProject(apiUrl, token, name, flagStr(args, "team"))).uuid;
     files = {};
@@ -50462,8 +50724,8 @@ var login = async (args) => {
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync17, readFileSync as readFileSync22, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname14, resolve as resolve10 } from "node:path";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname15, resolve as resolve11 } from "node:path";
 
 // src/compile/headlessBundle.ts
 init_api();
@@ -50574,9 +50836,9 @@ var requireRenderer = async () => {
 };
 var fileScenarioIO = (dir) => ({
   write: (relPath, data) => {
-    const abs = resolve10(dir, relPath);
-    mkdirSync17(dirname14(abs), { recursive: true });
-    writeFileSync18(abs, data);
+    const abs = resolve11(dir, relPath);
+    mkdirSync18(dirname15(abs), { recursive: true });
+    writeFileSync19(abs, data);
   }
 });
 var resolveFixtures = (value, baseDir) => {
@@ -50584,7 +50846,7 @@ var resolveFixtures = (value, baseDir) => {
     return;
   let map = value;
   if (typeof value === "string") {
-    const abs = resolve10(baseDir, value);
+    const abs = resolve11(baseDir, value);
     try {
       map = JSON.parse(readFileSync22(abs, "utf8"));
     } catch (e2) {
@@ -50599,7 +50861,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path2) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync22(resolve10(path2), "utf8"));
+    raw = JSON.parse(readFileSync22(resolve11(path2), "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read scenario "${path2}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -50657,7 +50919,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 ? dirname14(resolve10(scriptFlag)) : ".");
+  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname15(resolve11(scriptFlag)) : ".");
   const flagFixtures = resolveFixtures(flagStr(args, "fixtures"), ".");
   const fixtures = envelopeFixtures || flagFixtures ? { ...envelopeFixtures, ...flagFixtures } : undefined;
   if (fixtures) {
@@ -50696,7 +50958,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) => resolve10(outDir, p2)).join(", ")}`));
+        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p2) => resolve11(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);
@@ -50718,7 +50980,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync18(resolve10(pngFlag), png2);
+      writeFileSync19(resolve11(pngFlag), png2);
       note(`Wrote ${pngFlag} (${png2.length} bytes, ${width}x${height})`);
     }
     return done((cb) => cb());
@@ -50733,7 +50995,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync18(resolve10(out), result.text);
+    writeFileSync19(resolve11(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -50748,8 +51010,8 @@ init_api();
 init_config();
 init_manifest();
 init_util();
-import { appendFileSync as appendFileSync2, existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join23 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join24 } from "node:path";
 var ENV_VAR = "LECODES_PUSH_KEY";
 var context = () => {
   const root = findProjectRoot(process.cwd());
@@ -50893,11 +51155,11 @@ var pnKeysList = async (ctx) => {
 };
 var writeEnv = (root, key) => {
   const touched = [];
-  const envPath = join23(root, ".env");
+  const envPath = join24(root, ".env");
   const line = `${ENV_VAR}=${key}`;
-  const existing = existsSync23(envPath) ? readFileSync23(envPath, "utf8") : "";
+  const existing = existsSync24(envPath) ? readFileSync23(envPath, "utf8") : "";
   if (new RegExp(`^${ENV_VAR}=`, "m").test(existing)) {
-    writeFileSync19(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
+    writeFileSync20(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
   } else {
     const separator = !existing || existing.endsWith(`
 `) ? "" : `
@@ -50906,8 +51168,8 @@ var writeEnv = (root, key) => {
 `);
   }
   touched.push(".env");
-  const ignorePath = join23(root, ".gitignore");
-  const ignore = existsSync23(ignorePath) ? readFileSync23(ignorePath, "utf8") : "";
+  const ignorePath = join24(root, ".gitignore");
+  const ignore = existsSync24(ignorePath) ? readFileSync23(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l2) => l2.trim() === ".env")) {
     const separator = !ignore || ignore.endsWith(`
@@ -51006,8 +51268,8 @@ var pn = async (args) => {
 init_api();
 init_config();
 init_manifest();
-import { existsSync as existsSync24, mkdirSync as mkdirSync18, rmSync as rmSync5, writeFileSync as writeFileSync20 } from "node:fs";
-import { dirname as dirname15, join as join24 } from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync19, rmSync as rmSync6, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname16, join as join25 } from "node:path";
 init_types4();
 init_localFiles();
 init_util();
@@ -51030,9 +51292,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 = join24(root, ...path2.replace(/^\//, "").split("/"));
-      if (existsSync24(abs))
-        rmSync5(abs);
+      const abs = join25(root, ...path2.replace(/^\//, "").split("/"));
+      if (existsSync25(abs))
+        rmSync6(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -51069,18 +51331,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 = join24(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync18(dirname15(abs), { recursive: true });
+    const abs = join25(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync19(dirname16(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync20(abs, bytes);
+      writeFileSync21(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync20(abs, text);
+      writeFileSync21(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf3(asset.type), sha };
@@ -51093,8 +51355,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/scene.ts
 init_manifest();
-import { existsSync as existsSync26, readFileSync as readFileSync25, readdirSync as readdirSync11, statSync as statSync7, writeFileSync as writeFileSync21 } from "node:fs";
-import { basename as basename13, dirname as dirname16, join as join26, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync12, statSync as statSync8, writeFileSync as writeFileSync22 } from "node:fs";
+import { basename as basename14, dirname as dirname17, join as join27, resolve as resolve12 } from "node:path";
 
 // src/compile/sceneCompile.ts
 init_localFiles();
@@ -51102,17 +51364,17 @@ init_ignore();
 init_distRoot();
 init_util();
 init_projectCompile();
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync24 } from "node:fs";
+import { join as join26 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join25(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join26(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync25(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync26(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join25(distRoot, "runtime", "scene-harness.json");
-    if (existsSync25(vendored))
+    const vendored = join26(distRoot, "runtime", "scene-harness.json");
+    if (existsSync26(vendored))
       return JSON.parse(readFileSync24(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
@@ -51167,22 +51429,22 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve11(process.cwd(), pathArg);
-      if (existsSync26(abs) && statSync7(abs).isDirectory())
+      const abs = resolve12(process.cwd(), pathArg);
+      if (existsSync27(abs) && statSync8(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync26(abs))
-        root = dirname16(abs);
+      else if (abs.endsWith(".scene.ts") && existsSync27(abs))
+        root = dirname17(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
     }
   }
-  return { root, manifest, name: manifest?.name ?? basename13(root) };
+  return { root, manifest, name: manifest?.name ?? basename14(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path2 = join26(root, ".mcp.json");
+  const path2 = join27(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync26(path2)) {
+  if (existsSync27(path2)) {
     try {
       config = JSON.parse(readFileSync25(path2, "utf8"));
     } catch {
@@ -51197,17 +51459,17 @@ var writeMcpConfig2 = (root, port) => {
     return;
   }
   config.mcpServers["lecodes-scene"] = entry;
-  writeFileSync21(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync22(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 readdirSync11(dir)) {
+  for (const name of readdirSync12(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join26(dir, name);
-    if (statSync7(full).isDirectory())
+    const full = join27(dir, name);
+    if (statSync8(full).isDirectory())
       n2 += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n2++;
@@ -51280,8 +51542,8 @@ var status2 = async (_args) => {
 };
 
 // src/commands/test.ts
-import { existsSync as existsSync27, readFileSync as readFileSync26, readdirSync as readdirSync12 } from "node:fs";
-import { dirname as dirname17, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync26, readdirSync as readdirSync13 } from "node:fs";
+import { dirname as dirname18, resolve as resolve13 } from "node:path";
 init_util();
 var deriveDesignFlows = (meta, entryScreen) => {
   const edges = meta.edges ?? [];
@@ -51357,7 +51619,7 @@ var readFlowFile = (abs, displayName) => {
     name: file.name ?? displayName,
     kind: "file",
     steps: file.steps,
-    fixtures: resolveFixtures(file.fixtures, dirname17(abs)),
+    fixtures: resolveFixtures(file.fixtures, dirname18(abs)),
     width: file.width,
     height: file.height,
     settle: file.settle,
@@ -51369,34 +51631,34 @@ var test = async (args) => {
   const { js, warnings, useLocalAssets, root } = await compileHeadlessBundle(args);
   const renderer = await requireRenderer();
   const projectViewport = desktopDefaultViewport(root);
-  const testsDir = resolve12(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve12(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve13(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve13(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 = [resolve12(given), resolve12(testsDir, given), resolve12(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p2) => existsSync27(p2));
+      const candidates = [resolve13(given), resolve13(testsDir, given), resolve13(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p2) => existsSync28(p2));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync27(testsDir)) {
-    for (const f3 of readdirSync12(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve12(testsDir, f3), f3));
+  } else if (existsSync28(testsDir)) {
+    for (const f3 of readdirSync13(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve13(testsDir, f3), f3));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve12(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync27(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve13(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync28(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 ((wantFlows || flowsOnly) && existsSync27(designMetaPath)) {
+  if ((wantFlows || flowsOnly) && existsSync28(designMetaPath)) {
     let meta;
     try {
       meta = JSON.parse(readFileSync26(designMetaPath, "utf8"));
@@ -51431,7 +51693,7 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve12(root, flagStr(args, "artifacts") ?? resolve12(testsDir, ".artifacts"));
+  const artifactsRoot = resolve13(root, flagStr(args, "artifacts") ?? resolve13(testsDir, ".artifacts"));
   const results = [];
   for (const kase of cases) {
     const flagSettle = flagStr(args, "settle");
@@ -51449,14 +51711,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve12(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve13(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) => resolve12(artifactsRoot, slug3(kase.name), p2))
+          artifacts: outcome.failureArtifacts.map((p2) => resolve13(artifactsRoot, slug3(kase.name), p2))
         };
       } finally {
         session.dispose();
@@ -51518,11 +51780,11 @@ init_config();
 init_manifest();
 init_types4();
 init_util();
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
 var types4 = async (args) => {
   const dirArg = args._[0];
-  const root = dirArg ? resolve13(dirArg) : (() => {
+  const root = dirArg ? resolve14(dirArg) : (() => {
     try {
       return findProjectRoot(process.cwd());
     } catch {
@@ -51581,23 +51843,23 @@ var types4 = async (args) => {
 };
 
 // src/index.ts
-import { existsSync as existsSync29, readFileSync as readFileSync28, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync28, realpathSync as realpathSync2 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname19, join as join28 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname20, join as join29 } from "node:path";
 
 // src/commands/install.ts
 init_util();
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync3, existsSync as existsSync28, mkdirSync as mkdirSync19, readFileSync as readFileSync27, realpathSync, rmSync as rmSync6, symlinkSync } from "node:fs";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { appendFileSync as appendFileSync3, chmodSync as chmodSync2, cpSync as cpSync4, existsSync as existsSync29, mkdirSync as mkdirSync20, readFileSync as readFileSync27, realpathSync, rmSync as rmSync7, symlinkSync } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename14, delimiter, dirname as dirname18, join as join27, resolve as resolve14, sep as sep2 } from "node:path";
+import { basename as basename15, delimiter, dirname as dirname19, join as join28, resolve as resolve15, sep as sep2 } from "node:path";
 var isWin = process.platform === "win32";
 var HOME = homedir7();
 var safeRealpath = (p2) => {
   try {
     return realpathSync(p2);
   } catch {
-    return resolve14(p2);
+    return resolve15(p2);
   }
 };
 var onPath = (dir) => {
@@ -51613,25 +51875,25 @@ var onPath = (dir) => {
   });
 };
 var install = async (args) => {
-  const bundle = dirname18(process.execPath);
-  const exeName2 = basename14(process.execPath);
+  const bundle = dirname19(process.execPath);
+  const exeName2 = basename15(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync28(join27(bundle, "runtime")) || !existsSync28(join27(bundle, chiselName))) {
+  if (!existsSync29(join28(bundle, "runtime")) || !existsSync29(join28(bundle, chiselName))) {
     throw new CliError("`lecodes install` only works from the packaged release build (the archive containing lecodes + " + "chisel + runtime/). You appear to be running from source or an npm install — install globally " + "with your package manager there instead.");
   }
-  const companions = [exeName2, chiselName, "runtime", "README.txt"].filter((f3) => existsSync28(join27(bundle, f3)));
+  const companions = [exeName2, chiselName, "runtime", "README.txt"].filter((f3) => existsSync29(join28(bundle, f3)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
 };
 var copyBundle = (bundle, target, companions) => {
-  mkdirSync19(target, { recursive: true });
+  mkdirSync20(target, { recursive: true });
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f3 of companions) {
-    const dest = join27(target, f3);
-    rmSync6(dest, { recursive: true, force: true });
-    cpSync3(join27(bundle, f3), dest, { recursive: true });
+    const dest = join28(target, f3);
+    rmSync7(dest, { recursive: true, force: true });
+    cpSync4(join28(bundle, f3), dest, { recursive: true });
   }
 };
 var permError = (e2, dir, system) => {
@@ -51643,41 +51905,41 @@ var permError = (e2, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  const libDir = resolve14(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join27(HOME, ".local", "lib", "lecodes-cli")));
-  const binDir = resolve14(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join27(HOME, ".local", "bin")));
-  const link2 = join27(binDir, "lecodes");
+  const libDir = resolve15(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join28(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve15(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join28(HOME, ".local", "bin")));
+  const link2 = join28(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync2(join27(libDir, "lecodes"), 493);
-    chmodSync2(join27(libDir, "chisel"), 493);
+    chmodSync2(join28(libDir, "lecodes"), 493);
+    chmodSync2(join28(libDir, "chisel"), 493);
   } catch (e2) {
     throw permError(e2, libDir, system);
   }
   try {
-    mkdirSync19(binDir, { recursive: true });
-    rmSync6(link2, { force: true });
-    symlinkSync(join27(libDir, "lecodes"), link2);
+    mkdirSync20(binDir, { recursive: true });
+    rmSync7(link2, { force: true });
+    symlinkSync(join28(libDir, "lecodes"), link2);
   } catch (e2) {
     throw permError(e2, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link2 + " → " + join27(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join28(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
-  const shell = basename14(process.env.SHELL ?? "");
+  const shell = basename15(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join27(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join28(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join27(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join27(HOME, ".profile"), name: "~/.profile" };
+    return { file: join28(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join28(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 = existsSync28(file) ? readFileSync27(file, "utf8") : "";
+    const existing = existsSync29(file) ? readFileSync27(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -51715,7 +51977,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 = resolve14(flagStr(args, "dir") ?? join27(process.env.LOCALAPPDATA ?? join27(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve15(flagStr(args, "dir") ?? join28(process.env.LOCALAPPDATA ?? join28(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e2) {
@@ -51743,7 +52005,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 {
-    execFileSync4("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
+    execFileSync5("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
     return true;
   } catch {
     return false;
@@ -51753,9 +52015,9 @@ var addToUserPathWindows = (dir) => {
 // src/index.ts
 init_util();
 var STANDALONE = (() => {
-  const dir = dirname19(process.execPath);
+  const dir = dirname20(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync29(join28(dir, "runtime")) && existsSync29(join28(dir, chisel));
+  return existsSync30(join29(dir, "runtime")) && existsSync30(join29(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -51770,8 +52032,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join28(d, exe);
-      return existsSync29(cand) && realpathSync2(cand) === self2;
+      const cand = join29(d, exe);
+      return existsSync30(cand) && realpathSync2(cand) === self2;
     } catch {
       return false;
     }
@@ -51925,7 +52187,11 @@ ${c.bold("Commands:")}
                                   run     compile the current project and open it in a real
                                           desktop window (size/min-size/title default from
                                           app.json's desktop block; --width/--height/--title
-                                          override; --entry overrides the entrypoint)
+                                          override; --fullscreen/--windowed override the
+                                          app.json fullscreen; --scale <0.5..4|fit> overrides
+                                          the display scale — "fit" sizes a 1080p-designed app
+                                          to the monitor with the density raised to match;
+                                          --entry overrides the entrypoint)
                                   update  move to the newest published release
                                           (cached in ~/.lecodes/renderer)
   scene [path]                  LeCodes Scene Editor — visually edit a .scene.ts (tree, inspector,
@@ -51934,8 +52200,10 @@ ${c.bold("Commands:")}
                                   --port <n>         editor-server port (default 4488)
                                   --no-open          don't open the browser
                                   --no-mcp           don't register the MCP server in .mcp.json
-  app init <ios|android>        Generate a native shell in <project>/ios/ or <project>/android/
-                                  (offline-first: runs the bundled app.js; never pushed to LeCodes)
+  app init <ios|android|desktop>  Generate a native shell in <project>/ios/ or <project>/android/
+                                  (offline-first: runs the bundled app.js; never pushed to LeCodes).
+                                  desktop: no shell needed — writes app.json's desktop block
+                                  (window size; --fullscreen for kiosks)
                                   --name <s>         display name (default: app.json / folder name)
                                   --bundle-id <id>   iOS bundle identifier
                                   --app-id <id>      Android applicationId (default com.example.<slug>)
@@ -51977,6 +52245,15 @@ ${c.bold("Commands:")}
                                   --configuration <c>  Release (default) or Debug
                                   --no-aab             skip the .aab (APK only)
                                   --no-sync            skip the lecodes app sync step
+  app build desktop             Stage a portable desktop app folder (default dist/<name>/):
+                                  the cached host renamed to <Name>.exe + app.js + every asset +
+                                  app.json (the host ≥1.3.0 reads title/size/fullscreen from it)
+                                  + app.ico from app.json "icon". Duplicate asset basenames are
+                                  a build error (they silently alias in the bundle).
+                                  -o <dir>             output folder (default dist/<name>)
+                                  --slug <name>        folder/zip name override (e.g. Latin-only)
+                                  --probe              headless-render the staged folder to a PNG
+                                  --zip                <out>.zip, UTF-8/forward-slash entries
   app upload ios                Upload the archive to App Store Connect (then bumps buildNumber)
                                   --key-path <p8> --key-id <id> --issuer-id <id>
                                                        ASC API key; stored in ~/.lecodes/asc.json
@@ -52003,15 +52280,15 @@ var OPTIONAL_PEERS = [
 var peerVersion = (name, probe) => {
   try {
     const require2 = createRequire4(import.meta.url);
-    let dir = dirname19(require2.resolve(probe));
+    let dir = dirname20(require2.resolve(probe));
     for (let depth = 0;depth < 16; depth++) {
-      const manifest = join28(dir, "package.json");
-      if (existsSync29(manifest)) {
+      const manifest = join29(dir, "package.json");
+      if (existsSync30(manifest)) {
         const parsed = JSON.parse(readFileSync28(manifest, "utf8"));
         if (parsed.name === name)
           return parsed.version ?? "unknown";
       }
-      const parent = dirname19(dir);
+      const parent = dirname20(dir);
       if (parent === dir)
         break;
       dir = parent;