lecodes-cli 0.12.0 → 0.13.1

package/dist/index.js

@@ -42916,7 +42916,7 @@ var init_types4 = __esm(() => {
 });
 
 // src/compile/designCompile.ts
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 import { basename as basename6 } from "node:path";
 var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) => {
   const { root, manifest, designDir, designKey, screenId, state } = opts;
@@ -42934,7 +42934,7 @@ var LOCAL_ASSET_SCHEME = "lecodesfile://", compileDesignScreen = async (opts) =>
     } else if (type === "shader") {
       entries.push({ path: file.path, type, shaders: [] });
     } else {
-      entries.push({ path: file.path, type, text: readFileSync16(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync17(file.absPath, "utf8") });
     }
   }
   const invoke = state !== undefined ? `screen(${JSON.stringify(state)})` : "screen()";
@@ -42979,7 +42979,7 @@ var init_designCompile = __esm(() => {
 
 // src/browserAuth.ts
 import { createServer } from "node:http";
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } 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 +43004,16 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     args = [url];
   }
   try {
-    const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
+    const child = spawn3(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 resolve7;
+  let resolve8;
   let reject;
   const tokenPromise = new Promise((res, rej) => {
-    resolve7 = res;
+    resolve8 = res;
     reject = rej;
   });
   const server = createServer((req, res) => {
@@ -43031,7 +43031,7 @@ var SUCCESS_HTML = `<!doctype html><meta charset="utf-8"><title>lecodes</title>
     }
     res.writeHead(200, { "content-type": "text/html" });
     res.end(SUCCESS_HTML);
-    resolve7(token);
+    resolve8(token);
   });
   await new Promise((res, rej) => {
     server.once("error", rej);
@@ -43469,23 +43469,28 @@ overlap, unreadable contrast, off-screen content) before reporting back.
 ## Comments are the task list
 
 Reviewers pin comments to the board — on a screen, on the state it was showing, usually on a named
-element ("the \`submit\` button on \`checkout@empty\`"). They live in \`comments.json\`; read them with
-the \`design_comments\` tool (or \`lecodes design comments\`), which is the closest thing this design
-has to a backlog. **Open threads are the work.** A comment tells you which file to open and what to
-change in it, so start a turn there rather than asking what to do next.
+element ("the \`submit\` button on \`checkout@empty\`"). Each thread is one file under \`comments/\`;
+read them with the \`design_comments\` tool (or \`lecodes design comments\`), which is the closest
+thing this design has to a backlog. **Open threads are the work.** A comment tells you which file to
+open and what to change in it, so start a turn there rather than asking what to do next.
 
 When you've actually made the change, close the thread with \`resolve_comment\` (thread number, plus a
 short reply saying what you did — the reviewer sees it). Your reply goes out signed **Claude** and
 badged AI, because someone who asked a person for a change is owed the fact that a machine answered
 — so say what you changed, not that you'll look into it. Resolving without doing the work is worse
-than leaving it open: it hides the request from the person who made it. Never hand-edit
-\`comments.json\` to close something.
+than leaving it open: it hides the request from the person who made it. Never hand-edit the files in
+\`comments/\` to close something. To ask the reviewer something new, start a thread with
+\`comment_add\`.
 
 Most comments arrive from the **public share link**, where they're written by people who never see
-this repo. On a project cloned from the platform, \`lecodes design\` keeps the two ends reconciled
-while it runs: their comments appear in \`comments.json\` on their own, and your replies and resolves
-go back to them the same way. With the server down, \`lecodes design comments pull\` / \`push\` do it
-by hand. A thread you start here is local until you \`push\` it.
+this repo. On a project cloned from the platform, \`lecodes design\` mirrors their feedback into
+\`comments/\` on its own while it runs — but everything written here only goes OUT with the next
+\`lecodes push\`, together with (and after) the design it describes. So a resolve never reaches the
+reviewer before the change itself does; the work isn't delivered until that push runs. With the
+server down (no MCP), the same actions work from the terminal — \`lecodes design comments pull\`
+fetches the latest feedback, and \`lecodes design comments add / reply <n> / resolve <n>\` write the
+same store. Pass \`--ai\` so the write is signed as you rather than the developer; never write the
+JSON by hand (a message missing its \`pending\` flag is never delivered, and nothing warns).
 
 ## Workflow
 
@@ -43537,8 +43542,8 @@ __export(exports_design, {
   flushDesignComments: () => flushDesignComments,
   design: () => design
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync13, readFileSync as readFileSync17, readdirSync as readdirSync9, writeFileSync as writeFileSync14, appendFileSync } from "node:fs";
-import { basename as basename7, join as join18 } from "node:path";
+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";
 var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   let root;
   let manifest;
@@ -43555,11 +43560,11 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     manifest,
     name: manifest?.name ?? basename7(root),
     dirName,
-    designDir: join18(root, dirName),
+    designDir: join19(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 }, loadDesignServer = async (ctx, needs = []) => {
-  if (!existsSync18(ctx.designDir)) {
+  if (!existsSync19(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let mod;
@@ -43575,7 +43580,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   return mod;
 }, requirePlatform = (ctx, verb) => {
   if (!ctx.manifest) {
-    throw new CliError(`\`lecodes design comments ${verb}\` needs a cloned project. This folder is standalone, so ${ctx.dirName}/comments.json is already the only store — there is nothing to sync with.`);
+    throw new CliError(`\`lecodes design comments ${verb}\` needs a cloned project. This folder is standalone, so ${ctx.dirName}/comments/ is already the only store — there is nothing to sync with.`);
   }
   const config = loadConfig();
   return { apiUrl: requireApiUrl(config), token: requireToken(config), uuid: ctx.manifest.uuid };
@@ -43591,24 +43596,24 @@ 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 = join18(designDir, "screens");
-  if (!existsSync18(dir))
+  const dir = join19(designDir, "screens");
+  if (!existsSync19(dir))
     return [];
-  return readdirSync9(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
+  return readdirSync10(dir).filter((f3) => f3.endsWith(".ts") && !f3.startsWith(".")).map((f3) => f3.slice(0, -3)).sort();
 }, readMetaSizes = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync17(join18(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync18(join19(designDir, "meta.json"), "utf8"));
     return meta?.screens ?? {};
   } catch {
     return {};
   }
 }, writeMcpConfig = (ctx, port) => {
-  const path2 = join18(ctx.root, ".mcp.json");
+  const path2 = join19(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync18(path2)) {
+  if (existsSync19(path2)) {
     try {
-      config = JSON.parse(readFileSync17(path2, "utf8"));
+      config = JSON.parse(readFileSync18(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-design server by hand.");
       return;
@@ -43621,7 +43626,7 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     return;
   }
   config.mcpServers["lecodes-design"] = entry;
-  writeFileSync14(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync15(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 +43635,26 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join18("shared", "tokens.ts"), TOKENS_TS],
-    [join18("shared", "tabs.ts"), TABS_TS],
-    [join18("screens", "home.ts"), HOME_SCREEN_TS]
+    [join19("shared", "tokens.ts"), TOKENS_TS],
+    [join19("shared", "tabs.ts"), TABS_TS],
+    [join19("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync13(join18(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync13(join18(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync14(join19(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync14(join19(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join18(ctx.designDir, rel);
-    if (existsSync18(abs)) {
+    const abs = join19(ctx.designDir, rel);
+    if (existsSync19(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
     }
-    writeFileSync14(abs, content);
+    writeFileSync15(abs, content);
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join18(ctx.root, ".lecodesignore");
+  const ignorePath = join19(ctx.root, ".lecodesignore");
   const ignoreLines = [`${ctx.dirName}/.snapshots/`, `${ctx.dirName}/comments/`];
-  const current = existsSync18(ignorePath) ? readFileSync17(ignorePath, "utf8") : "";
+  const current = existsSync19(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 +43669,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);
-  mkdirSync13(join18(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync14(join18(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync14(join19(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync15(join19(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 +43718,16 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   killer.unref?.();
   const png2 = flagBool(args, "png") || flagStr(args, "png") !== undefined;
   const sizes = readMetaSizes(ctx.designDir);
-  const outDir = flagStr(args, "out-dir") ?? join18(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join19(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)
-    mkdirSync13(outDir, { recursive: true });
+    mkdirSync14(outDir, { recursive: true });
   for (const id of targets) {
     const [width, height] = sizes[id]?.size ?? [390, 844];
     let plan = [{ state: undefined, bases: [id] }];
     if (discover) {
-      const { states, canonical } = discover(readFileSync17(join18(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync18(join19(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -43763,11 +43768,11 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
         for (const w of pngResult.warnings)
           warnErr(`${tag}: ${w}`);
       for (const base of bases) {
-        writeFileSync14(join18(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join18(outDir, `${base}.json`)}`);
+        writeFileSync15(join19(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join19(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync14(join18(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join18(outDir, `${base}.png`)}`);
+          writeFileSync15(join19(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join19(outDir, `${base}.png`)}`);
         }
       }
     }
@@ -43942,11 +43947,17 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   const sub = args._[1];
   if (sub === "pull")
     return commentsPull(ctx);
+  if (sub === "add")
+    return commentsAdd(ctx, args);
+  if (sub === "reply")
+    return commentsReply(ctx, args);
+  if (sub === "resolve")
+    return commentsResolve(ctx, args);
   if (sub === "push") {
     throw new CliError("Comments go up with the design, not on their own — run `lecodes push`.\n" + "  (A reply that arrives before the change it describes is worse than one that arrives late.)");
   }
   if (sub !== undefined) {
-    throw new CliError(`Unknown comments subcommand "${sub}" (pull, or nothing to list).`);
+    throw new CliError(`Unknown comments subcommand "${sub}" (add, reply, resolve, pull, or nothing to list).`);
   }
   const designServer = await loadDesignServer(ctx);
   const all = flagBool(args, "all");
@@ -43987,6 +43998,56 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
     log("");
   }
   log(`${open} open · ${threads.length} total`);
+}, cliAuthor = (args) => flagBool(args, "ai") || process.env.CLAUDECODE ? { author: "Claude", origin: "ai" } : undefined, commentDelivery = (ctx) => optionalPlatform(ctx) ? "queued — it goes out with the next `lecodes push`, after the design it describes" : "saved — this folder is the record", findThreadByNumber = (designServer, ctx, raw) => {
+  const number = Number(raw);
+  if (!Number.isInteger(number) || number <= 0) {
+    throw new CliError(`"${String(raw ?? "")}" is not a thread number — see:  lecodes design comments`);
+  }
+  const thread = designServer.listDesignComments(ctx.designDir).threads.find((t2) => t2.number === number);
+  if (!thread)
+    throw new CliError(`No comment #${number} on this design — see:  lecodes design comments`);
+  return thread;
+}, commentsAdd = async (ctx, args) => {
+  const body = String(args._[2] ?? "").trim();
+  if (!body) {
+    throw new CliError('Usage: lecodes design comments add "<text>" [--screen <id>] [--state <s>] [--element <name>] [--ai]');
+  }
+  const designServer = await loadDesignServer(ctx, ["startThread", "readDesignState"]);
+  const screen2 = flagStr(args, "screen")?.trim() || undefined;
+  if (screen2) {
+    const ids = designServer.readDesignState(ctx.designDir).screens.map((s2) => s2.id);
+    if (!ids.includes(screen2)) {
+      throw new CliError(`No screen "${screen2}" in ${ctx.dirName}/ — the pin would point at nothing. Have: ${ids.join(", ") || "(none)"}.`);
+    }
+  }
+  const element = flagStr(args, "element")?.trim() || undefined;
+  const thread = designServer.startThread(ctx.designDir, {
+    anchor: {
+      screen: screen2,
+      state: flagStr(args, "state")?.trim() || undefined,
+      ...element ? { target: { name: element } } : {}
+    },
+    body,
+    ...cliAuthor(args)
+  }, { linked: !!optionalPlatform(ctx) });
+  log(`${c.green("✓")} ${threadRef(thread)} added — ${commentDelivery(ctx)}`);
+}, commentsReply = async (ctx, args) => {
+  const body = String(args._[3] ?? "").trim();
+  if (!body)
+    throw new CliError('Usage: lecodes design comments reply <number> "<text>" [--ai]');
+  const designServer = await loadDesignServer(ctx, ["replyToThread"]);
+  const thread = findThreadByNumber(designServer, ctx, args._[2]);
+  designServer.replyToThread(ctx.designDir, thread.id, body, cliAuthor(args));
+  log(`${c.green("✓")} replied to #${thread.number} — ${commentDelivery(ctx)}`);
+}, commentsResolve = async (ctx, args) => {
+  const designServer = await loadDesignServer(ctx, ["resolveThread", "replyToThread"]);
+  const thread = findThreadByNumber(designServer, ctx, args._[2]);
+  const reopen = flagBool(args, "reopen");
+  const reply = flagStr(args, "reply")?.trim();
+  if (reply)
+    designServer.replyToThread(ctx.designDir, thread.id, reply, cliAuthor(args));
+  designServer.resolveThread(ctx.designDir, thread.id, !reopen);
+  log(`${c.green("✓")} #${thread.number} ${reopen ? "reopened" : "resolved"} — ${commentDelivery(ctx)}`);
 }, threadRef = (thread) => thread.number === undefined ? "new" : `#${thread.number}`, reportMirror = (ctx, summary, open) => {
   const parts = [
     summary.added ? `+${summary.added} new` : null,
@@ -44011,7 +44072,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 (!existsSync18(ctx.designDir))
+  if (!existsSync19(ctx.designDir))
     return null;
   const platform = optionalPlatform(ctx);
   if (!platform)
@@ -44024,6 +44085,8 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   }
   if (typeof designServer.queuedThreads !== "function")
     return null;
+  if (typeof designServer.settleQueued !== "function" || designServer.settleQueued.length < 4)
+    return null;
   const queued = designServer.queuedThreads(ctx.designDir);
   if (queued.length === 0)
     return null;
@@ -44031,8 +44094,9 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
   const result = { sent: 0, threads: 0, failures: [] };
   for (const item of queued) {
     const { thread, pending } = item;
+    let upstream = null;
+    const delivered = { messageIds: new Set, resolve: false };
     try {
-      let upstream = null;
       if (pending.newThread) {
         const [opening, ...rest] = thread.messages;
         if (!opening)
@@ -44043,28 +44107,31 @@ var DEFAULT_DIR = "design", DEFAULT_PORT = 4477, getContext = (args) => {
           origin: opening.origin
         });
         result.sent++;
+        delivered.messageIds.add(opening.id);
         for (const message of rest) {
           upstream = await replyDesignComment(apiUrl, token, uuid, upstream.id, message.body, message.origin);
           result.sent++;
+          delivered.messageIds.add(message.id);
         }
       } else {
         for (const message of pending.messages) {
           upstream = await replyDesignComment(apiUrl, token, uuid, thread.id, message.body, message.origin);
           result.sent++;
+          delivered.messageIds.add(message.id);
         }
       }
       if (pending.resolve) {
-        const id = upstream?.id ?? thread.id;
-        upstream = await resolveDesignComment(apiUrl, token, uuid, id, thread.resolved);
+        upstream = await resolveDesignComment(apiUrl, token, uuid, upstream?.id ?? thread.id, thread.resolved);
         result.sent++;
+        delivered.resolve = true;
       }
-      if (!upstream)
-        continue;
-      designServer.settleQueued(ctx.designDir, item, upstream);
-      result.threads++;
     } catch (e2) {
       result.failures.push(`${threadRef(thread)}: ${errText(e2)}`);
     }
+    if (upstream) {
+      designServer.settleQueued(ctx.designDir, item, upstream, delivered);
+      result.threads++;
+    }
   }
   return result;
 }, COMMENT_SYNC_MS = 20000, startCommentSync = (ctx, designServer) => {
@@ -45146,7 +45213,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.12.0",
+  version: "0.13.1",
   dependencies: {
     "@letary/chisel": "^0.6.0",
     jimp: "^1.6.1"
@@ -45159,9 +45226,9 @@ var package_default = {
     sdk: "workspace:*"
   },
   peerDependencies: {
-    "lecodes-design": "^0.4.0",
-    "lecodes-renderer": "^0.7.1",
-    "lecodes-3d-editor": "^0.1.0"
+    "lecodes-design": "^0.5.0",
+    "lecodes-renderer": "^0.8.0",
+    "lecodes-3d-editor": "^0.2.0"
   },
   bin: {
     lecodes: "dist/index.js"
@@ -45336,6 +45403,23 @@ var compile2 = async (args) => {
 };
 var compileShell = (args, shell) => compileImpl(args, shell);
 var compileImpl = async (args, shell) => {
+  const { js, resources } = await buildBundle(args, shell);
+  const out = flagStr(args, "o", "out");
+  if (out && isNullSink(out)) {
+    note(`Discarded output (${out})`);
+  } else if (out) {
+    writeFileSync7(resolve(out), js);
+    note(`Wrote ${out} (${js.length} bytes)`);
+  } else {
+    process.stdout.write(js);
+    if (!js.endsWith(`
+`))
+      process.stdout.write(`
+`);
+  }
+  return resources;
+};
+var buildBundle = async (args, shell) => {
   let root;
   let manifest;
   try {
@@ -45412,25 +45496,13 @@ var compileImpl = async (args, shell) => {
   });
   for (const w of warnings)
     warnErr(w);
-  const out = flagStr(args, "o", "out");
-  if (out && isNullSink(out)) {
-    note(`Discarded output (${out})`);
-  } else if (out) {
-    writeFileSync7(resolve(out), js);
-    note(`Wrote ${out} (${js.length} bytes)`);
-  } else {
-    process.stdout.write(js);
-    if (!js.endsWith(`
-`))
-      process.stdout.write(`
-`);
-  }
-  return entries.filter((e) => e.type === "resource").map((e) => ({
+  const resources = entries.filter((e) => e.type === "resource").map((e) => ({
     path: e.path.replace(/^\//, ""),
     name: e.path.split(/[\\/]/).pop() ?? e.path,
     absPath: e.absPath,
     remote: !!e.remote
   }));
+  return { js, resources };
 };
 var previewLegacy = async (args) => {
   warnErr("'lecodes preview' is now 'lecodes compile' — the old name still works.");
@@ -48740,6 +48812,10 @@ from \`main.ts\`.
 \`\`\`
 lecodes render                    # semantic JSON of the launched UI (structure, text, names, values)
 lecodes render --png shot.png     # pixels (needs @napi-rs/canvas installed)
+lecodes render --desktop --png shot.png  # NATIVE render: real Filament 3D + UI + 2D composited —
+                                  # use this to SEE 3D scenes / procedural geometry (headless
+                                  # renders record 3D as JSON only). Windows/Linux; downloads
+                                  # the renderer on first use. --frames <n> for slow loads.
 lecodes render --script <file>    # drive the app through a scenario (format below)
 lecodes test                      # all tests/*.flow.json + design-derived flows; run before "done"
 \`\`\`
@@ -48829,21 +48905,290 @@ var create = async (args) => {
   info(c.dim(`  cd ${dir} — edit main.ts, then \`lecodes push -m "first commit"\` to save it`));
 };
 
+// src/commands/desktop.ts
+init_util();
+
+// 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 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 };
+    if (opts.width && opts.height)
+      env.CREATOR_WINDOW_SIZE = `${opts.width}x${opts.height}`;
+    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 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 });
+  }
+};
+
+// src/commands/desktop.ts
+var run = async (args) => {
+  const { js, resources } = await buildBundle(args);
+  const width = Number(flagStr(args, "width")) || undefined;
+  const height = Number(flagStr(args, "height")) || undefined;
+  note("Launching LeCodes Desktop… (close the window to return)");
+  await runDesktopApp(js, resources, { width, height });
+};
+var status = async () => {
+  const selected = selectedDesktopVersion();
+  const installed = installedDesktopVersions();
+  log(`renders with    ${selected}${installed.includes(selected) ? "" : c.dim("  (not downloaded yet — fetched on first render)")}`);
+  log(`CLI minimum     ${DESKTOP_RENDERER_VERSION}`);
+  log(`downloaded      ${installed.length > 0 ? installed.join(", ") : c.dim("none")}   ${c.dim("(~/.lecodes/renderer)")}`);
+  if (process.env.LECODES_DESKTOP_EXE)
+    log(`override        LECODES_DESKTOP_EXE=${process.env.LECODES_DESKTOP_EXE}`);
+  try {
+    const { latest } = await fetchDesktopManifest();
+    const hint = semverNewer(selected, latest) > 0 ? c.yellow("(newer — run `lecodes desktop update`)") : latest === selected ? c.dim("(up to date)") : c.dim("(older than the CLI's minimum — this desktop release isn't published yet)");
+    log(`published       ${latest}   ${hint}`);
+  } catch {
+    log(`published       ${c.dim("unknown (couldn't reach the release manifest)")}`);
+  }
+};
+var desktop = async (args) => {
+  const sub = args._[0];
+  if (sub === undefined)
+    return status();
+  if (sub === "run")
+    return run(args);
+  if (sub === "update")
+    return updateDesktop();
+  throw new CliError(`Unknown subcommand "desktop ${sub}". Use \`lecodes desktop\` (status), \`lecodes desktop run\` or \`lecodes desktop update\`.`);
+};
+
 // src/index.ts
 init_design();
 
 // src/commands/dev.ts
 init_manifest();
 init_ignore();
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync18, watch, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync19, watch, writeFileSync as writeFileSync16 } from "node:fs";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { basename as basename8, join as join19 } from "node:path";
+import { basename as basename8, join as join20 } from "node:path";
 
 // src/dev/devServer.ts
 init_localFiles();
 import { createServer as createServer2 } from "node:http";
-import { createReadStream, statSync as statSync5 } from "node:fs";
+import { createReadStream, statSync as statSync6 } from "node:fs";
 init_projectCompile();
 init_fonts();
 init_assetIcons();
@@ -48961,9 +49306,9 @@ var renderPrelude = (p2) => DEV_PRELUDE_JS.split("__DEV_ORIGIN__").join(p2.origi
 var renderDevScreen = (name) => DEV_SCREEN_TS.split("__DEV_NAME__").join(JSON.stringify(name));
 
 // src/dev/wsServer.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-var acceptKey = (key) => createHash5("sha1").update(key + WS_GUID).digest("base64");
+var acceptKey = (key) => createHash6("sha1").update(key + WS_GUID).digest("base64");
 var encodeTextFrame = (text) => {
   const payload = Buffer.from(text, "utf8");
   const len = payload.length;
@@ -49106,19 +49451,19 @@ var contentType = (path2) => {
   const i2 = path2.lastIndexOf(".");
   return i2 >= 0 && MIME[path2.slice(i2 + 1).toLowerCase()] || "application/octet-stream";
 };
-var sendText = (res, status, type, body) => {
-  res.writeHead(status, { "content-type": type, "cache-control": "no-store" });
+var sendText = (res, status2, type, body) => {
+  res.writeHead(status2, { "content-type": type, "cache-control": "no-store" });
   res.end(body);
 };
-var sendJson = (res, status, body) => sendText(res, status, "application/json", JSON.stringify(body));
-var readBody = (req) => new Promise((resolve7) => {
+var sendJson = (res, status2, body) => sendText(res, status2, "application/json", JSON.stringify(body));
+var readBody = (req) => new Promise((resolve8) => {
   let body = "";
   req.on("data", (c4) => {
     if (body.length < 256 * 1024)
       body += c4.toString("utf8");
   });
-  req.on("end", () => resolve7(body));
-  req.on("error", () => resolve7(body));
+  req.on("end", () => resolve8(body));
+  req.on("error", () => resolve8(body));
 });
 var startDevServer = async (options) => {
   const { root, manifest, name, origin, token, entryOverride } = options;
@@ -49158,9 +49503,9 @@ var startDevServer = async (options) => {
     }
   };
   const recompile = () => {
-    const run = compileChain.then(compileOnce);
-    compileChain = run;
-    return run;
+    const run2 = compileChain.then(compileOnce);
+    compileChain = run2;
+    return run2;
   };
   const devJs = await compileProject2({
     entries: [{ path: "/.dev-entry.ts", type: "text", text: renderDevScreen(name) }],
@@ -49218,7 +49563,7 @@ var startDevServer = async (options) => {
         return sendText(res, 400, "text/plain", "Bad path");
       }
       const abs = resolveLocalPath(root, key);
-      if (!abs || !statSync5(abs).isFile())
+      if (!abs || !statSync6(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);
@@ -49261,11 +49606,11 @@ var startDevServer = async (options) => {
     if (conn)
       clients.add(conn);
   });
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve8, reject) => {
     server.once("error", reject);
     server.listen(options.port, options.bind ?? "0.0.0.0", () => {
       server.removeListener("error", reject);
-      resolve7();
+      resolve8();
     });
   });
   const address = server.address();
@@ -49291,35 +49636,46 @@ var DEFAULT_PORT2 = 4499;
 var DEBOUNCE_MS = 120;
 var WATCH_SKIP_DIRS = new Set([".lecodes", ".git", "node_modules"]);
 var WATCH_SKIP_FILES = new Set(["tsconfig.json", "jsconfig.json", ".gitignore", ".lecodesignore", ".DS_Store"]);
-var pickLanAddress = () => {
+var VIRTUAL_IFACE = /wsl|docker|hyper-v|vethernet|virtualbox|vmware|tap|tun|zerotier|tailscale|loopback/i;
+var lanCandidates = () => {
   const nets = networkInterfaces();
-  for (const name of Object.keys(nets)) {
-    for (const net of nets[name] ?? []) {
-      if (net.family === "IPv4" && !net.internal)
-        return net.address;
-    }
-  }
-  return null;
+  const out = [];
+  for (const iface of Object.keys(nets)) {
+    for (const net of nets[iface] ?? []) {
+      if (net.family !== "IPv4" || net.internal)
+        continue;
+      const a2 = net.address;
+      let rank = 0;
+      if (VIRTUAL_IFACE.test(iface))
+        rank += 4;
+      if (/^172\.(1[6-9]|2\d|3[01])\./.test(a2))
+        rank += 2;
+      if (a2.startsWith("169.254."))
+        rank += 8;
+      out.push({ address: a2, iface, rank });
+    }
+  }
+  return out.sort((x2, y2) => x2.rank - y2.rank).map(({ address, iface }) => ({ address, iface }));
 };
 var loadDevToken = (root) => {
-  const path2 = join19(root, LECODES_DIR, "dev.json");
+  const path2 = join20(root, LECODES_DIR, "dev.json");
   try {
-    const token2 = JSON.parse(readFileSync18(path2, "utf8")).token;
+    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");
-  mkdirSync14(join19(root, LECODES_DIR), { recursive: true });
-  writeFileSync15(path2, JSON.stringify({ token }, null, 2) + `
+  mkdirSync15(join20(root, LECODES_DIR), { recursive: true });
+  writeFileSync16(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((resolve7) => qrcode.generate(url, { small: true }, (out) => {
+    await new Promise((resolve8) => qrcode.generate(url, { small: true }, (out) => {
       log(out);
-      resolve7();
+      resolve8();
     }));
   } catch {
     note("(couldn't render a QR code — open the URL below on the device)");
@@ -49340,9 +49696,11 @@ var dev = async (args) => {
     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).");
   }
   const port = Number(flagStr(args, "port")) || DEFAULT_PORT2;
-  const host = flagStr(args, "host") ?? pickLanAddress();
+  const candidates = lanCandidates();
+  const host = flagStr(args, "host") ?? candidates[0]?.address;
   if (!host)
     throw new CliError("No LAN address found — pass one with --host <ip>.");
+  const alternatives = candidates.filter((c4) => c4.address !== host);
   const origin = `http://${host}:${port}`;
   const token = loadDevToken(root);
   const server = await startDevServer({
@@ -49422,7 +49780,10 @@ ${result.error}`);
     await printQr(server.url);
   log(`Scan the QR with the LeCodes app, or open:  ${c.bold(server.url)}`);
   note(`Older desktop builds (no websocket bridge): ${server.url}?t=poll`);
-  if (existsSync19(join19(root, LECODES_DIR, "manifest.json")))
+  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")))
     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.`);
@@ -49436,7 +49797,7 @@ init_localFiles();
 
 // src/serverDiff.ts
 init_localFiles();
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync20 } from "node:fs";
 import { basename as basename9 } from "node:path";
 var isTextAsset = (t2) => t2 === "text" || t2 === "shader" || t2 === "scene";
 var computeServerDiff = (project, scan2) => {
@@ -49455,7 +49816,7 @@ var computeServerDiff = (project, scan2) => {
     const local = localByPath.get(path2);
     if (local && !server) {
       const text = isTextKind(classifyKind(basename9(path2)));
-      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync19(local.absPath, "utf8") : undefined });
+      entries.push({ path: path2, status: "added", binary: !text, serverText: "", localText: text ? readFileSync20(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server && !local) {
@@ -49466,12 +49827,12 @@ var computeServerDiff = (project, scan2) => {
     if (server && local) {
       if (isTextAsset(server.type)) {
         const serverText = server.text ?? "";
-        const localText = readFileSync19(local.absPath, "utf8");
+        const localText = readFileSync20(local.absPath, "utf8");
         if (serverText !== localText)
           entries.push({ path: path2, status: "modified", binary: false, serverText, localText });
       } else {
         const serverSize = server.file?.size;
-        const localSize = Buffer.byteLength(readFileSync19(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync20(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path: path2, status: "modified", binary: true });
         }
@@ -49629,8 +49990,8 @@ var statusLabel = (e2) => e2.status === "added" ? c.green("  added    ") : e2.st
 init_manifest();
 init_types4();
 init_ignore();
-import { existsSync as existsSync20, mkdirSync as mkdirSync15, writeFileSync as writeFileSync16 } from "node:fs";
-import { basename as basename10, dirname as dirname13, join as join20, resolve as resolve7 } from "node:path";
+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";
 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\`.
@@ -49728,18 +50089,18 @@ Full command list: \`lecodes --help\`.
 `;
 var init2 = async (args) => {
   const dirArg = (args._[0] ?? ".").replace(/[/\\]+$/, "") || ".";
-  const root = resolve7(dirArg);
+  const root = resolve8(dirArg);
   const name = basename10(root);
-  mkdirSync15(root, { recursive: true });
+  mkdirSync16(root, { recursive: true });
   let created = 0;
   const write = (rel, content) => {
-    const abs = join20(root, rel);
-    if (existsSync20(abs)) {
+    const abs = join21(root, rel);
+    if (existsSync21(abs)) {
       note(`kept      ${rel}`);
       return;
     }
-    mkdirSync15(dirname13(abs), { recursive: true });
-    writeFileSync16(abs, content);
+    mkdirSync16(dirname13(abs), { recursive: true });
+    writeFileSync17(abs, content);
     log(`${c.green("created")}   ${rel}`);
     created++;
   };
@@ -49768,8 +50129,8 @@ init_config();
 init_ignore();
 init_localFiles();
 init_manifest();
-import { existsSync as existsSync21 } from "node:fs";
-import { basename as basename12, join as join21, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { basename as basename12, join as join22, resolve as resolve9 } from "node:path";
 init_types4();
 init_util();
 
@@ -49779,7 +50140,7 @@ init_config();
 init_manifest();
 init_localFiles();
 import { basename as basename11 } from "node:path";
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 init_util();
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
@@ -49840,9 +50201,9 @@ var push = async (args) => {
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync20(file.absPath, "utf8");
+      entry.text = readFileSync21(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename11(file.path), readFileSync20(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename11(file.path), readFileSync21(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -49949,10 +50310,10 @@ var link = async (args) => {
   const apiUrl = requireApiUrl(config);
   const token = requireToken(config);
   const dirArg = args._[0];
-  const root = dirArg ? resolve8(dirArg) : process.cwd();
-  if (!existsSync21(root))
+  const root = dirArg ? resolve9(dirArg) : process.cwd();
+  if (!existsSync22(root))
     throw new CliError(`No such directory: ${root}`);
-  if (existsSync21(join21(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
+  if (existsSync22(join22(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;
@@ -50028,8 +50389,8 @@ var login = async (args) => {
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname14, resolve as resolve9 } from "node:path";
+import { mkdirSync as mkdirSync17, readFileSync as readFileSync22, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname14, resolve as resolve10 } from "node:path";
 
 // src/compile/headlessBundle.ts
 init_api();
@@ -50139,9 +50500,9 @@ var requireRenderer = async () => {
 };
 var fileScenarioIO = (dir) => ({
   write: (relPath, data) => {
-    const abs = resolve9(dir, relPath);
-    mkdirSync16(dirname14(abs), { recursive: true });
-    writeFileSync17(abs, data);
+    const abs = resolve10(dir, relPath);
+    mkdirSync17(dirname14(abs), { recursive: true });
+    writeFileSync18(abs, data);
   }
 });
 var resolveFixtures = (value, baseDir) => {
@@ -50149,9 +50510,9 @@ var resolveFixtures = (value, baseDir) => {
     return;
   let map = value;
   if (typeof value === "string") {
-    const abs = resolve9(baseDir, value);
+    const abs = resolve10(baseDir, value);
     try {
-      map = JSON.parse(readFileSync21(abs, "utf8"));
+      map = JSON.parse(readFileSync22(abs, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read fixtures "${value}": ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -50164,7 +50525,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path2) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync21(resolve9(path2), "utf8"));
+    raw = JSON.parse(readFileSync22(resolve10(path2), "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read scenario "${path2}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -50177,7 +50538,27 @@ var readScenarioFile = (path2) => {
     throw new CliError(`Scenario "${path2}" has no "steps".`);
   return file;
 };
+var renderDesktop = async (args) => {
+  const width = Number(flagStr(args, "width")) || 390;
+  const height = Number(flagStr(args, "height")) || 844;
+  const frames = Number(flagStr(args, "frames")) || 60;
+  const timeoutMs = Number(flagStr(args, "timeout")) || 60000;
+  const pngFlag = flagStr(args, "png") ?? "screenshot.png";
+  const { js, resources } = await buildBundle(args);
+  note("Rendering (native)…");
+  await runDesktopRender(js, resources, {
+    width,
+    height,
+    frames,
+    outPng: pngFlag,
+    logs: flagBool(args, "logs"),
+    timeoutMs
+  });
+  note(`Wrote ${pngFlag} (${width}x${height}, native render)`);
+};
 var render = async (args) => {
+  if (flagBool(args, "desktop"))
+    return renderDesktop(args);
   const scriptFlag = flagStr(args, "script");
   const scenario = scriptFlag !== undefined ? readScenarioFile(scriptFlag) : null;
   const stepCount = scenario && Array.isArray(scenario.steps) ? scenario.steps.length : 0;
@@ -50194,7 +50575,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(resolve9(scriptFlag)) : ".");
+  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname14(resolve10(scriptFlag)) : ".");
   const flagFixtures = resolveFixtures(flagStr(args, "fixtures"), ".");
   const fixtures = envelopeFixtures || flagFixtures ? { ...envelopeFixtures, ...flagFixtures } : undefined;
   if (fixtures) {
@@ -50233,7 +50614,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) => resolve9(outDir, p2)).join(", ")}`));
+        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p2) => resolve10(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);
@@ -50255,7 +50636,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync17(resolve9(pngFlag), png2);
+      writeFileSync18(resolve10(pngFlag), png2);
       note(`Wrote ${pngFlag} (${png2.length} bytes, ${width}x${height})`);
     }
     return done((cb) => cb());
@@ -50270,7 +50651,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync17(resolve9(out), result.text);
+    writeFileSync18(resolve10(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -50285,8 +50666,8 @@ init_api();
 init_config();
 init_manifest();
 init_util();
-import { appendFileSync as appendFileSync2, existsSync as existsSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join22 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join23 } from "node:path";
 var ENV_VAR = "LECODES_PUSH_KEY";
 var context = () => {
   const root = findProjectRoot(process.cwd());
@@ -50430,11 +50811,11 @@ var pnKeysList = async (ctx) => {
 };
 var writeEnv = (root, key) => {
   const touched = [];
-  const envPath = join22(root, ".env");
+  const envPath = join23(root, ".env");
   const line = `${ENV_VAR}=${key}`;
-  const existing = existsSync22(envPath) ? readFileSync22(envPath, "utf8") : "";
+  const existing = existsSync23(envPath) ? readFileSync23(envPath, "utf8") : "";
   if (new RegExp(`^${ENV_VAR}=`, "m").test(existing)) {
-    writeFileSync18(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
+    writeFileSync19(envPath, existing.replace(new RegExp(`^${ENV_VAR}=.*$`, "m"), line));
   } else {
     const separator = !existing || existing.endsWith(`
 `) ? "" : `
@@ -50443,8 +50824,8 @@ var writeEnv = (root, key) => {
 `);
   }
   touched.push(".env");
-  const ignorePath = join22(root, ".gitignore");
-  const ignore = existsSync22(ignorePath) ? readFileSync22(ignorePath, "utf8") : "";
+  const ignorePath = join23(root, ".gitignore");
+  const ignore = existsSync23(ignorePath) ? readFileSync23(ignorePath, "utf8") : "";
   if (!ignore.split(`
 `).some((l2) => l2.trim() === ".env")) {
     const separator = !ignore || ignore.endsWith(`
@@ -50543,8 +50924,8 @@ var pn = async (args) => {
 init_api();
 init_config();
 init_manifest();
-import { existsSync as existsSync23, mkdirSync as mkdirSync17, rmSync as rmSync4, writeFileSync as writeFileSync19 } from "node:fs";
-import { dirname as dirname15, join as join23 } from "node:path";
+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";
 init_types4();
 init_localFiles();
 init_util();
@@ -50567,9 +50948,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 = join23(root, ...path2.replace(/^\//, "").split("/"));
-      if (existsSync23(abs))
-        rmSync4(abs);
+      const abs = join24(root, ...path2.replace(/^\//, "").split("/"));
+      if (existsSync24(abs))
+        rmSync5(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -50606,18 +50987,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 = join23(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync17(dirname15(abs), { recursive: true });
+    const abs = join24(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync18(dirname15(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync19(abs, bytes);
+      writeFileSync20(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync19(abs, text);
+      writeFileSync20(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf3(asset.type), sha };
@@ -50630,8 +51011,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/scene.ts
 init_manifest();
-import { existsSync as existsSync25, readFileSync as readFileSync24, readdirSync as readdirSync10, statSync as statSync6, writeFileSync as writeFileSync20 } from "node:fs";
-import { basename as basename13, dirname as dirname16, join as join25, resolve as resolve10 } from "node:path";
+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";
 
 // src/compile/sceneCompile.ts
 init_localFiles();
@@ -50639,18 +51020,18 @@ init_ignore();
 init_distRoot();
 init_util();
 init_projectCompile();
-import { existsSync as existsSync24, readFileSync as readFileSync23 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync24 } from "node:fs";
+import { join as join25 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join24(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join25(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync24(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync25(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join24(distRoot, "runtime", "scene-harness.json");
-    if (existsSync24(vendored))
-      return JSON.parse(readFileSync23(vendored, "utf8"));
+    const vendored = join25(distRoot, "runtime", "scene-harness.json");
+    if (existsSync25(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.");
   }
 };
@@ -50662,7 +51043,7 @@ var compileSceneEditor = async (opts) => {
   for (const file of scan2.files) {
     const path2 = "./" + rel(file.path);
     if (TEXT_EXT.test(path2)) {
-      entries.push({ path: path2, type: "text", text: readFileSync23(file.absPath, "utf8") });
+      entries.push({ path: path2, type: "text", text: readFileSync24(file.absPath, "utf8") });
     } else {
       entries.push({ path: path2, type: "resource", fileSrc: "/project/" + rel(file.path) });
     }
@@ -50704,10 +51085,10 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve10(process.cwd(), pathArg);
-      if (existsSync25(abs) && statSync6(abs).isDirectory())
+      const abs = resolve11(process.cwd(), pathArg);
+      if (existsSync26(abs) && statSync7(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync25(abs))
+      else if (abs.endsWith(".scene.ts") && existsSync26(abs))
         root = dirname16(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
@@ -50716,12 +51097,12 @@ var getContext2 = (args) => {
   return { root, manifest, name: manifest?.name ?? basename13(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path2 = join25(root, ".mcp.json");
+  const path2 = join26(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync25(path2)) {
+  if (existsSync26(path2)) {
     try {
-      config = JSON.parse(readFileSync24(path2, "utf8"));
+      config = JSON.parse(readFileSync25(path2, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -50734,17 +51115,17 @@ var writeMcpConfig2 = (root, port) => {
     return;
   }
   config.mcpServers["lecodes-scene"] = entry;
-  writeFileSync20(path2, JSON.stringify(config, null, 2) + `
+  writeFileSync21(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 readdirSync10(dir)) {
+  for (const name of readdirSync11(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join25(dir, name);
-    if (statSync6(full).isDirectory())
+    const full = join26(dir, name);
+    if (statSync7(full).isDirectory())
       n2 += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n2++;
@@ -50788,7 +51169,7 @@ var scene = async (args) => {
 init_manifest();
 init_localFiles();
 init_util();
-var status = async (_args) => {
+var status2 = async (_args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
   const scan2 = scanProject(root, manifest);
@@ -50817,8 +51198,8 @@ var status = async (_args) => {
 };
 
 // src/commands/test.ts
-import { existsSync as existsSync26, readFileSync as readFileSync25, readdirSync as readdirSync11 } from "node:fs";
-import { dirname as dirname17, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync26, readdirSync as readdirSync12 } from "node:fs";
+import { dirname as dirname17, resolve as resolve12 } from "node:path";
 init_util();
 var deriveDesignFlows = (meta, entryScreen) => {
   const edges = meta.edges ?? [];
@@ -50880,7 +51261,7 @@ var slug3 = (s2) => s2.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").
 var readFlowFile = (abs, displayName) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync25(abs, "utf8"));
+    raw = JSON.parse(readFileSync26(abs, "utf8"));
   } catch (e2) {
     throw new CliError(`Can't read "${displayName}": ${e2 instanceof Error ? e2.message : String(e2)}`);
   }
@@ -50905,37 +51286,37 @@ var readFlowFile = (abs, displayName) => {
 var test = async (args) => {
   const { js, warnings, useLocalAssets, root } = await compileHeadlessBundle(args);
   const renderer = await requireRenderer();
-  const testsDir = resolve11(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve11(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve12(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve12(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 = [resolve11(given), resolve11(testsDir, given), resolve11(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p2) => existsSync26(p2));
+      const candidates = [resolve12(given), resolve12(testsDir, given), resolve12(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p2) => existsSync27(p2));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync26(testsDir)) {
-    for (const f3 of readdirSync11(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve11(testsDir, f3), f3));
+  } else if (existsSync27(testsDir)) {
+    for (const f3 of readdirSync12(testsDir).filter((f4) => f4.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve12(testsDir, f3), f3));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve11(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync26(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve12(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync27(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) && existsSync26(designMetaPath)) {
+  if ((wantFlows || flowsOnly) && existsSync27(designMetaPath)) {
     let meta;
     try {
-      meta = JSON.parse(readFileSync25(designMetaPath, "utf8"));
+      meta = JSON.parse(readFileSync26(designMetaPath, "utf8"));
     } catch (e2) {
       throw new CliError(`Can't read ${designMetaPath}: ${e2 instanceof Error ? e2.message : String(e2)}`);
     }
@@ -50967,7 +51348,7 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve11(root, flagStr(args, "artifacts") ?? resolve11(testsDir, ".artifacts"));
+  const artifactsRoot = resolve12(root, flagStr(args, "artifacts") ?? resolve12(testsDir, ".artifacts"));
   const results = [];
   for (const kase of cases) {
     const flagSettle = flagStr(args, "settle");
@@ -50985,14 +51366,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve11(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve12(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) => resolve11(artifactsRoot, slug3(kase.name), p2))
+          artifacts: outcome.failureArtifacts.map((p2) => resolve12(artifactsRoot, slug3(kase.name), p2))
         };
       } finally {
         session.dispose();
@@ -51054,11 +51435,11 @@ init_config();
 init_manifest();
 init_types4();
 init_util();
-import { resolve as resolve12 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
 var types4 = async (args) => {
   const dirArg = args._[0];
-  const root = dirArg ? resolve12(dirArg) : (() => {
+  const root = dirArg ? resolve13(dirArg) : (() => {
     try {
       return findProjectRoot(process.cwd());
     } catch {
@@ -51117,23 +51498,23 @@ var types4 = async (args) => {
 };
 
 // src/index.ts
-import { existsSync as existsSync28, readFileSync as readFileSync27, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync29, 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 join27 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname19, join as join28 } 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 existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync26, realpathSync, rmSync as rmSync5, symlinkSync } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename14, delimiter, dirname as dirname18, join as join26, resolve as resolve13, sep as sep2 } from "node:path";
+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 { 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";
 var isWin = process.platform === "win32";
-var HOME = homedir6();
+var HOME = homedir7();
 var safeRealpath = (p2) => {
   try {
     return realpathSync(p2);
   } catch {
-    return resolve13(p2);
+    return resolve14(p2);
   }
 };
 var onPath = (dir) => {
@@ -51150,24 +51531,24 @@ var onPath = (dir) => {
 };
 var install = async (args) => {
   const bundle = dirname18(process.execPath);
-  const exeName = basename14(process.execPath);
+  const exeName2 = basename14(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync27(join26(bundle, "runtime")) || !existsSync27(join26(bundle, chiselName))) {
+  if (!existsSync28(join27(bundle, "runtime")) || !existsSync28(join27(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 = [exeName, chiselName, "runtime", "README.txt"].filter((f3) => existsSync27(join26(bundle, f3)));
+  const companions = [exeName2, chiselName, "runtime", "README.txt"].filter((f3) => existsSync28(join27(bundle, f3)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
 };
 var copyBundle = (bundle, target, companions) => {
-  mkdirSync18(target, { recursive: true });
+  mkdirSync19(target, { recursive: true });
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f3 of companions) {
-    const dest = join26(target, f3);
-    rmSync5(dest, { recursive: true, force: true });
-    cpSync3(join26(bundle, f3), dest, { recursive: true });
+    const dest = join27(target, f3);
+    rmSync6(dest, { recursive: true, force: true });
+    cpSync3(join27(bundle, f3), dest, { recursive: true });
   }
 };
 var permError = (e2, dir, system) => {
@@ -51179,41 +51560,41 @@ var permError = (e2, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  const libDir = resolve13(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join26(HOME, ".local", "lib", "lecodes-cli")));
-  const binDir = resolve13(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join26(HOME, ".local", "bin")));
-  const link2 = join26(binDir, "lecodes");
+  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");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync2(join26(libDir, "lecodes"), 493);
-    chmodSync2(join26(libDir, "chisel"), 493);
+    chmodSync2(join27(libDir, "lecodes"), 493);
+    chmodSync2(join27(libDir, "chisel"), 493);
   } catch (e2) {
     throw permError(e2, libDir, system);
   }
   try {
-    mkdirSync18(binDir, { recursive: true });
-    rmSync5(link2, { force: true });
-    symlinkSync(join26(libDir, "lecodes"), link2);
+    mkdirSync19(binDir, { recursive: true });
+    rmSync6(link2, { force: true });
+    symlinkSync(join27(libDir, "lecodes"), link2);
   } catch (e2) {
     throw permError(e2, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link2 + " → " + join26(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join27(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
   const shell = basename14(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join26(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join27(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join26(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join26(HOME, ".profile"), name: "~/.profile" };
+    return { file: join27(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join27(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 = existsSync27(file) ? readFileSync26(file, "utf8") : "";
+    const existing = existsSync28(file) ? readFileSync27(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync3(file, `${existing && !existing.endsWith(`
@@ -51251,7 +51632,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 = resolve13(flagStr(args, "dir") ?? join26(process.env.LOCALAPPDATA ?? join26(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve14(flagStr(args, "dir") ?? join27(process.env.LOCALAPPDATA ?? join27(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e2) {
@@ -51291,7 +51672,7 @@ init_util();
 var STANDALONE = (() => {
   const dir = dirname19(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync28(join27(dir, "runtime")) && existsSync28(join27(dir, chisel));
+  return existsSync29(join28(dir, "runtime")) && existsSync29(join28(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -51306,8 +51687,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join27(d, exe);
-      return existsSync28(cand) && realpathSync2(cand) === self2;
+      const cand = join28(d, exe);
+      return existsSync29(cand) && realpathSync2(cand) === self2;
     } catch {
       return false;
     }
@@ -51396,6 +51777,14 @@ ${c.bold("Commands:")}
                                   --settle <ms>      wait for promises/timers/fetch before snapshot
                                   --wait-network     let data fetches hit the real network
                                   --logs             forward the app's console output (to stderr)
+                                  --desktop          render through the NATIVE desktop host instead:
+                                                       real Filament 3D + tgfx UI + 2D, composited.
+                                                       PNG only (--png). Downloads the LeCodes
+                                                       Desktop renderer on first use into
+                                                       ~/.lecodes/renderer (Windows/Linux;
+                                                       LECODES_DESKTOP_EXE overrides)
+                                  --frames <n>       (--desktop) frames to run before the shot —
+                                                       headroom for async loads (default 60)
   test [name…]                  Run headless flow tests: tests/*.flow.json scenarios, plus flows
                                   derived from the design graph (design/meta.json activator edges
                                   — checks the built app against the designed navigation; needs
@@ -51435,6 +51824,17 @@ ${c.bold("Commands:")}
                                   --logs             forward the screens' console output (to stderr)
   design comments               Review comments pinned to the board, grouped by screen (open first)
                                   --all              include resolved threads
+                                  add "<text>" [--screen <id>] [--state <s>] [--element <name>]
+                                  reply <number> "<text>"  ·  resolve <number> [--reply "<text>"] [--reopen]
+                                  (--ai signs a write as Claude; sends with the next "lecodes push")
+  desktop [run|update]          The native desktop host ('lecodes render --desktop' uses it too):
+                                  no args shows the version status (selected / downloaded /
+                                  newest published)
+                                  run     compile the current project and open it in a real
+                                          desktop window (--width/--height set the window size;
+                                          --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,
                                   gizmo) on local files (needs the optional 'lecodes-3d-editor' package;
                                   works inside a cloned project or standalone in any folder)
@@ -51498,7 +51898,7 @@ ${c.bold("Commands:")}
                                   — 'new --env' banks it in .env), revoke <id>
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { init: init2, login, create, clone: clone3, link, status, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn };
+var commands = { init: init2, login, create, clone: clone3, link, status: status2, diff: diff2, pull, push, compile: compile2, preview: previewLegacy, render, test, types: types4, design, scene, dev, app, pn, desktop };
 if (STANDALONE)
   commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
@@ -51512,9 +51912,9 @@ var peerVersion = (name, probe) => {
     const require2 = createRequire4(import.meta.url);
     let dir = dirname19(require2.resolve(probe));
     for (let depth = 0;depth < 16; depth++) {
-      const manifest = join27(dir, "package.json");
-      if (existsSync28(manifest)) {
-        const parsed = JSON.parse(readFileSync27(manifest, "utf8"));
+      const manifest = join28(dir, "package.json");
+      if (existsSync29(manifest)) {
+        const parsed = JSON.parse(readFileSync28(manifest, "utf8"));
         if (parsed.name === name)
           return parsed.version ?? "unknown";
       }
@@ -51532,6 +51932,8 @@ var printVersion = () => {
     const version = peerVersion(name, probe);
     rows.push([name, version ?? c.dim("not installed")]);
   }
+  const desktopVersion = selectedDesktopVersion();
+  rows.push(["lecodes-desktop", installedDesktopVersions().includes(desktopVersion) ? desktopVersion : `${desktopVersion} ${c.dim("(not downloaded — fetched on first `render --desktop`)")}`]);
   const width = Math.max(...rows.map(([label2]) => label2.length));
   for (const [label2, value] of rows)
     log(`${label2.padEnd(width)}  ${value}`);
@@ -51547,14 +51949,14 @@ var main = async () => {
     printVersion();
     return;
   }
-  const run = commands[command];
-  if (!run) {
+  const run2 = commands[command];
+  if (!run2) {
     log(c.red(`Unknown command: ${command}`));
     log(HELP);
     process.exitCode = 1;
     return;
   }
-  await run(parseArgs(argv.slice(1)));
+  await run2(parseArgs(argv.slice(1)));
 };
 main().catch((e2) => {
   if (e2 instanceof CliError)