lecodes-cli 0.7.2 → 0.8.0

package/dist/index.js

@@ -109,12 +109,15 @@ var hasImportStatement = (src) => src.includes("import") || src.includes("from")
     if (isRelativeOrAbsolute(spec))
       return spec;
     const slash = spec.indexOf("/");
-    const slug2 = slash === -1 ? spec : spec.slice(0, slash);
-    if (slugs.has(slug2)) {
+    const slug = slash === -1 ? spec : spec.slice(0, slash);
+    if (slugs.has(slug)) {
       const sub = slash === -1 ? "/index" : spec.slice(slash);
-      return `/__lib/${slug2}${sub}`;
+      return `/__lib/${slug}${sub}`;
     }
-    throw new Error(`Unknown library "${slug2}" — add it in Settings → Libraries, or use a relative path like "./${slug2}".`);
+    if (slug === "ui" || slug === "creator" || slug === "utils") {
+      throw new Error(`import from "${slug}": the SDK needs no imports — UIScreen, Scene, etc. are globals; remove this import line.`);
+    }
+    throw new Error(`Unknown library "${slug}" — add it in Settings → Libraries, or use a relative path like "./${slug}".`);
   };
   let out = src.replace(IMPORT_FROM_RE, (_m, boundary, head, quote, spec) => `${boundary}${head}${quote}${rewriteSpec(spec)}${quote}`);
   out = out.replace(SIDE_EFFECT_RE, (m, boundary, head, quote, spec) => isRelativeOrAbsolute(spec) ? m : `${boundary}${head}${quote}${rewriteSpec(spec)}${quote}`);
@@ -126,18 +129,18 @@ var init_libraryImports = __esm(() => {
 });
 
 // ../sdk/src/compile/bundler.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync8, statSync } from "node:fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname5, join as join8, relative as relative2 } from "node:path";
+import { dirname as dirname4, join as join7, relative as relative2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var resolveInject = () => {
   const override = process.env.LECODES_SDK_INJECT;
-  if (override && existsSync6(override))
+  if (override && existsSync4(override))
     return override;
-  const here = dirname5(fileURLToPath2(import.meta.url));
-  const src = join8(here, "..", "inject.ts");
-  if (existsSync6(src))
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const src = join7(here, "..", "inject.ts");
+  if (existsSync4(src))
     return src;
   throw new Error("sdk: could not locate the inject source (LECODES_SDK_INJECT / src/inject.ts)");
 }, normalize = (path) => {
@@ -156,19 +159,19 @@ var resolveInject = () => {
   if (!inject.endsWith("inject.ts")) {
     throw new Error(`chisel needs the SDK source tree (src/inject.ts); got ${inject}. Set LECODES_SDK_INJECT to the source.`);
   }
-  return dirname5(inject);
+  return dirname4(inject);
 }, isSdkSource = (path) => /\.[tj]s$/.test(path) && !path.endsWith(".d.ts") && !path.includes("/compile/") && !path.includes("/tests/") && !path.includes("/__tests__/"), sdkFilesCache, collectSdkFiles = (sdkSrc) => {
   const cached = sdkFilesCache.get(sdkSrc);
   if (cached)
     return cached;
   const out = {};
   const walk = (dir) => {
-    for (const name of readdirSync3(dir)) {
-      const p = join8(dir, name);
+    for (const name of readdirSync2(dir)) {
+      const p = join7(dir, name);
       if (statSync(p).isDirectory())
         walk(p);
       else if (isSdkSource(p))
-        out["/__sdk/" + relative2(sdkSrc, p).split("\\").join("/")] = readFileSync8(p, "utf8");
+        out["/__sdk/" + relative2(sdkSrc, p).split("\\").join("/")] = readFileSync7(p, "utf8");
     }
   };
   walk(sdkSrc);
@@ -177,13 +180,13 @@ var resolveInject = () => {
 }, resolveChiselBin = () => {
   const override = process.env.LECODES_CHISEL_BIN;
   if (override) {
-    if (existsSync6(override))
+    if (existsSync4(override))
       return override;
     throw new Error(`LECODES_CHISEL_BIN points at a missing file: ${override}`);
   }
   try {
     const bin = createRequire2(import.meta.url)("@letary/chisel").binaryPath();
-    if (bin && existsSync6(bin))
+    if (bin && existsSync4(bin))
       return bin;
   } catch {}
   throw new Error("chisel binary not found. Install @letary/chisel, or set LECODES_CHISEL_BIN.");
@@ -206,9 +209,9 @@ var resolveInject = () => {
   }
   if (!projFiles[entry])
     throw new Error(`Entrypoint not found: ${entry}`);
-  for (const [slug2, libFiles] of Object.entries(libraries ?? {})) {
+  for (const [slug, libFiles] of Object.entries(libraries ?? {})) {
     for (const [k, v] of Object.entries(libFiles)) {
-      const path = normalize(`/__lib/${slug2}/${k}`);
+      const path = normalize(`/__lib/${slug}/${k}`);
       let src = v;
       if (/\.[tj]sx?$/.test(path)) {
         if (hasAssetMacro(src))
@@ -290,6 +293,9 @@ var buildHeader = (name, code, opts = {}) => {
     localAssets.add("capture");
   if (localAssets.size > 0)
     header += `// preload: ${[...localAssets].join(";")}
+`;
+  if (opts.fonts)
+    header += `// fonts: ${opts.fonts}
 `;
   if (!code.includes("_creator.createScene") && !code.includes("_creator.createEntity"))
     header += `// gl: disable
@@ -339,7 +345,7 @@ var detectEntry = (entries) => {
   const files = {};
   for (const e of opts.entries) {
     if (e.type === "resource") {
-      if (opts.localAssets) {
+      if (opts.localAssets && !e.remote) {
         const name = e.path.split(/[\\/]/).pop() ?? e.path;
         files[e.path] = `export default ("id:" + _creatorUtils.fetchLocal(${JSON.stringify(name)}))`;
       } else {
@@ -365,7 +371,7 @@ var detectEntry = (entries) => {
     return map ? `${code}
 ${inlineSourceMapComment(map)}` : code;
   }
-  const header = buildHeader(opts.name, code, { icon: opts.icon });
+  const header = buildHeader(opts.name, code, { icon: opts.icon, fonts: opts.fontsHeader });
   if (!map)
     return header + code;
   const headerLines = (header.match(/\n/g) ?? []).length;
@@ -377,17 +383,17 @@ var init_compileProject = __esm(() => {
 });
 
 // ../sdk/src/compile/sceneEditor.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "node:fs";
+import { join as join8 } from "node:path";
 var SCENE_HARNESS_DIR = "./.scene-editor", SCENE_ENTRY_PATH = "./.scene-entry.ts", loadSceneHarness = (fallbackDir) => {
   const override = process.env.LECODES_SCENE_HARNESS_DIR;
-  const dir = override && existsSync7(override) ? override : fallbackDir && existsSync7(fallbackDir) ? fallbackDir : null;
+  const dir = override && existsSync5(override) ? override : fallbackDir && existsSync5(fallbackDir) ? fallbackDir : null;
   if (!dir)
     throw new Error("scene-editor harness sources not found (set LECODES_SCENE_HARNESS_DIR)");
   const out = {};
-  for (const f of readdirSync4(dir)) {
+  for (const f of readdirSync3(dir)) {
     if (f.endsWith(".ts"))
-      out[f] = readFileSync9(join9(dir, f), "utf8");
+      out[f] = readFileSync8(join8(dir, f), "utf8");
   }
   return out;
 }, sceneEditorEntries = (scenePath, harness, projectPaths = []) => {
@@ -417,25 +423,569 @@ export {}
 };
 var init_sceneEditor = () => {};
 
+// ../sdk/src/compile/fontRegistry.ts
+var DEFAULT_FONT_REGISTRY_BASE = "https://cdn.le.codes/fonts/v1", fontRegistryBase = () => typeof process !== "undefined" && process.env?.LECODES_FONT_REGISTRY?.trim() || DEFAULT_FONT_REGISTRY_BASE, faceFileName = (id, weight, italic, ext2) => `${id}-${weight}${italic ? "-italic" : ""}.${ext2}`, LATIN, CYR, OFL = "OFL-1.1", f = (family, category, scripts, weights, italics, defaultWeights) => ({ family, category, scripts, weights, italics, defaultWeights, license: OFL }), FONT_REGISTRY;
+var init_fontRegistry = __esm(() => {
+  LATIN = ["latin"];
+  CYR = ["latin", "cyrillic"];
+  FONT_REGISTRY = {
+    inter: f("Inter", "sans-serif", CYR, [100, 200, 300, 400, 500, 600, 700, 800, 900], [], [400, 500, 700]),
+    manrope: f("Manrope", "sans-serif", CYR, [200, 300, 400, 500, 600, 700, 800], [], [400, 500, 700]),
+    "golos-text": f("Golos Text", "sans-serif", CYR, [400, 500, 600, 700, 800, 900], [], [400, 500, 700]),
+    onest: f("Onest", "sans-serif", CYR, [100, 200, 300, 400, 500, 600, 700, 800, 900], [], [400, 500, 700]),
+    rubik: f("Rubik", "sans-serif", CYR, [300, 400, 500, 600, 700, 800, 900], [300, 400, 500, 600, 700, 800, 900], [400, 500, 700]),
+    nunito: f("Nunito", "sans-serif", CYR, [200, 300, 400, 500, 600, 700, 800, 900], [400, 700], [400, 600, 700]),
+    montserrat: f("Montserrat", "sans-serif", CYR, [100, 200, 300, 400, 500, 600, 700, 800, 900], [400, 700], [400, 500, 700]),
+    "ibm-plex-sans": f("IBM Plex Sans", "sans-serif", CYR, [100, 200, 300, 400, 500, 600, 700], [400, 700], [400, 500, 700]),
+    "pt-sans": f("PT Sans", "sans-serif", CYR, [400, 700], [400, 700], [400, 700]),
+    jost: f("Jost", "sans-serif", CYR, [100, 200, 300, 400, 500, 600, 700, 800, 900], [400, 700], [400, 500, 700]),
+    "exo-2": f("Exo 2", "sans-serif", CYR, [100, 200, 300, 400, 500, 600, 700, 800, 900], [400, 700], [400, 500, 700]),
+    unbounded: f("Unbounded", "display", CYR, [200, 300, 400, 500, 600, 700, 800, 900], [], [400, 700]),
+    "russo-one": f("Russo One", "display", CYR, [400], [], [400]),
+    oswald: f("Oswald", "display", CYR, [200, 300, 400, 500, 600, 700], [], [400, 700]),
+    comfortaa: f("Comfortaa", "display", CYR, [300, 400, 500, 600, 700], [], [400, 700]),
+    "space-grotesk": f("Space Grotesk", "display", LATIN, [300, 400, 500, 600, 700], [], [400, 700]),
+    "playfair-display": f("Playfair Display", "serif", CYR, [400, 500, 600, 700, 800, 900], [400, 700], [400, 700]),
+    lora: f("Lora", "serif", CYR, [400, 500, 600, 700], [400, 700], [400, 700]),
+    "pt-serif": f("PT Serif", "serif", CYR, [400, 700], [400, 700], [400, 700]),
+    cormorant: f("Cormorant", "serif", CYR, [300, 400, 500, 600, 700], [400, 700], [400, 700]),
+    literata: f("Literata", "serif", CYR, [200, 300, 400, 500, 600, 700, 800, 900], [400, 700], [400, 700]),
+    "jetbrains-mono": f("JetBrains Mono", "monospace", CYR, [100, 200, 300, 400, 500, 600, 700, 800], [400, 700], [400, 700]),
+    "fira-code": f("Fira Code", "monospace", CYR, [300, 400, 500, 600, 700], [], [400, 700]),
+    "ibm-plex-mono": f("IBM Plex Mono", "monospace", CYR, [100, 200, 300, 400, 500, 600, 700], [400, 700], [400, 700]),
+    caveat: f("Caveat", "handwriting", CYR, [400, 500, 600, 700], [], [400, 700]),
+    pacifico: f("Pacifico", "handwriting", CYR, [400], [], [400])
+  };
+});
+
+// ../sdk/src/compile/sfnt.ts
+var TAG_TTF = 65536, TAG_OTTO = 1330926671, TAG_TTCF = 1953784678, TAG_WOFF = 2001684038, TAG_WOF2 = 2001684018, parseSfnt = (bytes) => {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.byteLength < 12)
+    throw new Error("not a font file (truncated)");
+  const version = dv.getUint32(0);
+  if (version === TAG_TTCF)
+    throw new Error("font collections (.ttc) aren't supported — export a single face");
+  if (version === TAG_WOFF || version === TAG_WOF2)
+    throw new Error("WOFF/WOFF2 project fonts aren't supported — use the .ttf/.otf");
+  if (version !== TAG_TTF && version !== TAG_OTTO)
+    throw new Error("not a TTF/OTF font file");
+  const numTables = dv.getUint16(4);
+  const tables = new Map;
+  for (let i = 0;i < numTables; i++) {
+    const rec = 12 + i * 16;
+    if (rec + 16 > bytes.byteLength)
+      throw new Error("not a font file (truncated table directory)");
+    const tag = String.fromCharCode(bytes[rec], bytes[rec + 1], bytes[rec + 2], bytes[rec + 3]);
+    tables.set(tag, { offset: dv.getUint32(rec + 8), length: dv.getUint32(rec + 12) });
+  }
+  const family = readFamily(dv, bytes, tables.get("name"));
+  if (!family)
+    throw new Error("no family name in the font's `name` table");
+  let weight = 400;
+  let italic = false;
+  const os2 = tables.get("OS/2");
+  if (os2 && os2.offset + 64 <= bytes.byteLength) {
+    weight = dv.getUint16(os2.offset + 4);
+    italic = (dv.getUint16(os2.offset + 62) & 1) === 1;
+  } else {
+    const head = tables.get("head");
+    if (head && head.offset + 46 <= bytes.byteLength) {
+      const macStyle = dv.getUint16(head.offset + 44);
+      if (macStyle & 1)
+        weight = 700;
+      italic = (macStyle & 2) === 2;
+    }
+  }
+  if (weight < 1 || weight > 1000)
+    weight = 400;
+  return { family, weight, italic };
+}, readFamily = (dv, bytes, name) => {
+  if (!name || name.offset + 6 > bytes.byteLength)
+    return "";
+  const base = name.offset;
+  const count = dv.getUint16(base + 2);
+  const stringOffset = base + dv.getUint16(base + 4);
+  let best = "";
+  let bestScore = -1;
+  for (let i = 0;i < count; i++) {
+    const rec = base + 6 + i * 12;
+    if (rec + 12 > bytes.byteLength)
+      break;
+    const platformID = dv.getUint16(rec);
+    const languageID = dv.getUint16(rec + 4);
+    const nameID = dv.getUint16(rec + 6);
+    const length = dv.getUint16(rec + 8);
+    const offset = stringOffset + dv.getUint16(rec + 10);
+    if (nameID !== 16 && nameID !== 1)
+      continue;
+    if (offset + length > bytes.byteLength)
+      continue;
+    let score = nameID === 16 ? 100 : 0;
+    if (platformID === 3)
+      score += languageID === 1033 ? 30 : 20;
+    else if (platformID === 0)
+      score += 10;
+    if (score <= bestScore)
+      continue;
+    const text = platformID === 1 ? decodeLatin1(bytes, offset, length) : decodeUtf16be(bytes, offset, length);
+    if (!text.trim())
+      continue;
+    best = text.trim();
+    bestScore = score;
+  }
+  return best;
+}, decodeUtf16be = (bytes, offset, length) => {
+  let out = "";
+  for (let i = 0;i + 1 < length; i += 2)
+    out += String.fromCharCode(bytes[offset + i] << 8 | bytes[offset + i + 1]);
+  return out;
+}, decodeLatin1 = (bytes, offset, length) => {
+  let out = "";
+  for (let i = 0;i < length; i++)
+    out += String.fromCharCode(bytes[offset + i]);
+  return out;
+};
+
+// ../sdk/src/compile/fontMacro.ts
+var FONT_ID, CODE_FILE, DECLARES_FONT, isIdentStart = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$", isIdentPart = (c2) => isIdentStart(c2) || c2 >= "0" && c2 <= "9", skipString = (src, start) => {
+  const quote = src[start];
+  const n = src.length;
+  let i = start + 1;
+  while (i < n) {
+    const c2 = src[i];
+    if (c2 === "\\") {
+      i += 2;
+      continue;
+    }
+    if (quote === "`" && c2 === "$" && src[i + 1] === "{") {
+      i = skipBraces(src, i + 1);
+      continue;
+    }
+    if (c2 === quote)
+      return i + 1;
+    i++;
+  }
+  return n;
+}, skipBraces = (src, open) => {
+  const n = src.length;
+  let depth = 0;
+  let i = open;
+  while (i < n) {
+    const c2 = src[i];
+    if (c2 === '"' || c2 === "'" || c2 === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c2 === "{")
+      depth++;
+    else if (c2 === "}") {
+      depth--;
+      if (depth === 0)
+        return i + 1;
+    }
+    i++;
+  }
+  return n;
+}, matchParen = (src, open) => {
+  const n = src.length;
+  let depth = 0;
+  let i = open;
+  while (i < n) {
+    const c2 = src[i];
+    if (c2 === '"' || c2 === "'" || c2 === "`") {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c2 === "/" && src[i + 1] === "/") {
+      i += 2;
+      while (i < n && src[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (c2 === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (c2 === "(")
+      depth++;
+    else if (c2 === ")") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  return -1;
+}, splitTopLevel = (text, delim) => {
+  const parts = [];
+  const n = text.length;
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < n) {
+    const c2 = text[i];
+    if (c2 === '"' || c2 === "'" || c2 === "`") {
+      i = skipString(text, i);
+      continue;
+    }
+    if (c2 === "(" || c2 === "[" || c2 === "{")
+      depth++;
+    else if (c2 === ")" || c2 === "]" || c2 === "}")
+      depth = Math.max(0, depth - 1);
+    else if (depth === 0 && c2 === delim) {
+      parts.push(text.slice(last, i));
+      last = i + 1;
+    }
+    i++;
+  }
+  parts.push(text.slice(last));
+  return parts;
+}, stringLiteralValue = (text) => {
+  const t = text.trim();
+  if (t.length < 2)
+    return null;
+  const q = t[0];
+  if (q !== '"' && q !== "'" && q !== "`" || t[t.length - 1] !== q)
+    return null;
+  const inner = t.slice(1, -1);
+  if (q === "`" && inner.includes("${"))
+    return null;
+  if (inner.includes(q) && !inner.includes("\\" + q))
+    return null;
+  return inner.replace(/\\(.)/g, "$1");
+}, prevNonSpace = (src, i) => {
+  let k = i - 1;
+  while (k >= 0 && /\s/.test(src[k]))
+    k--;
+  return k >= 0 ? src[k] : "";
+}, scanFontCalls = (source) => {
+  const calls = [];
+  const n = source.length;
+  let i = 0;
+  while (i < n) {
+    const c2 = source[i];
+    if (c2 === '"' || c2 === "'" || c2 === "`") {
+      i = skipString(source, i);
+      continue;
+    }
+    if (c2 === "/" && source[i + 1] === "/") {
+      i += 2;
+      while (i < n && source[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (c2 === "/" && source[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(source[i] === "*" && source[i + 1] === "/"))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (isIdentStart(c2)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(source[j]))
+        j++;
+      if (source.slice(i, j) === "font" && prevNonSpace(source, i) !== ".") {
+        const call = parseCall(source, i, j);
+        if (call) {
+          calls.push(call);
+          i = call.end;
+          continue;
+        }
+      }
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return calls;
+}, parseCall = (src, start, identEnd) => {
+  const n = src.length;
+  let i = identEnd;
+  while (i < n && /\s/.test(src[i]))
+    i++;
+  if (src[i] !== "(")
+    return null;
+  const close = matchParen(src, i);
+  if (close === -1)
+    return null;
+  const call = { start, end: close + 1, arg: "", kind: "registry" };
+  const args = splitTopLevel(src.slice(i + 1, close), ",");
+  const arg = stringLiteralValue(args[0] ?? "");
+  if (arg === null) {
+    call.error = `font(...) needs a string-literal argument — a registry id ("manrope") or a project path ("./fonts/Brand.ttf"). Got \`${(args[0] ?? "").trim() || "()"}\`.`;
+    return call;
+  }
+  call.arg = arg;
+  if (arg.startsWith("./") || arg.startsWith("../")) {
+    call.kind = "file";
+    if (!/\.(ttf|otf)$/i.test(arg)) {
+      call.error = `font("${arg}"): project fonts must be .ttf/.otf files.`;
+      return call;
+    }
+    if (args.length > 1 && args.slice(1).some((a) => a.trim())) {
+      call.error = `font("${arg}"): a project font takes no options — weight and style come from the file itself.`;
+      return call;
+    }
+    return call;
+  }
+  if (arg === "serif" || arg === "sans-serif" || arg === "monospace" || arg === "monospaced") {
+    call.error = `font("${arg}"): system font families need no font() — pass the string straight to fontFamily, e.g. .style({ fontFamily: "${arg}" }).`;
+    return call;
+  }
+  if (!FONT_ID.test(arg)) {
+    call.error = `font("${arg}"): expected a registry id (lowercase [a-z0-9-], e.g. "manrope") or a relative path ("./fonts/Brand.ttf").`;
+    return call;
+  }
+  call.kind = "registry";
+  call.id = arg;
+  const optsText = args[1]?.trim();
+  if (optsText) {
+    const err = parseOptions(optsText, call);
+    if (err) {
+      call.error = err;
+      return call;
+    }
+  }
+  return call;
+}, parseOptions = (optsText, call) => {
+  if (!optsText.startsWith("{") || !optsText.endsWith("}")) {
+    return `font("${call.arg}", opts): opts must be an object literal like { weights: [400, 700] }.`;
+  }
+  for (const prop of splitTopLevel(optsText.slice(1, -1), ",")) {
+    if (!prop.trim())
+      continue;
+    const kv = splitTopLevel(prop, ":");
+    if (kv.length < 2)
+      return `font("${call.arg}"): couldn't parse option \`${prop.trim()}\`.`;
+    const key = kv[0].trim().replace(/^["'`]|["'`]$/g, "");
+    const raw = kv.slice(1).join(":").trim();
+    if (key === "weights") {
+      const m = /^\[\s*(\d+(?:\s*,\s*\d+)*)\s*,?\s*\]$/.exec(raw);
+      if (!m)
+        return `font("${call.arg}"): weights must be a literal number array, e.g. { weights: [400, 700] }.`;
+      call.weights = m[1].split(",").map((s) => parseInt(s.trim(), 10));
+    } else if (key === "italic") {
+      if (raw !== "true" && raw !== "false")
+        return `font("${call.arg}"): italic must be a literal true/false.`;
+      call.italic = raw === "true";
+    } else {
+      return `font("${call.arg}"): unknown option "${key}" (did you mean weights/italic?).`;
+    }
+  }
+  return null;
+}, norm = (p) => p.replace(/\\/g, "/").replace(/^\//, ""), dirOf = (p) => {
+  const n = norm(p);
+  const i = n.lastIndexOf("/");
+  return i === -1 ? "" : n.slice(0, i);
+}, baseOf = (p) => {
+  const n = norm(p);
+  return n.slice(n.lastIndexOf("/") + 1);
+}, resolveRel = (dir, rel) => {
+  const out = dir ? dir.split("/") : [];
+  for (const seg of rel.split("/")) {
+    if (!seg || seg === ".")
+      continue;
+    if (seg === "..") {
+      if (out.length === 0)
+        return "";
+      out.pop();
+    } else
+      out.push(seg);
+  }
+  return out.join("/");
+}, relSpecifier = (fromDir, toPath) => {
+  const from = fromDir ? fromDir.split("/") : [];
+  const to = norm(toPath).split("/");
+  let common = 0;
+  while (common < from.length && common < to.length - 1 && from[common] === to[common])
+    common++;
+  const ups = from.length - common;
+  const rest = to.slice(common).join("/");
+  return ups === 0 ? `./${rest}` : `${"../".repeat(ups)}${rest}`;
+}, faceKey = (family, weight, italic) => `${family}|${weight}|${italic ? "i" : "n"}`, applyFontMacro = async (entries, opts) => {
+  const scanned = entries.filter((e) => e.type === "text" && CODE_FILE.test(e.path) && typeof e.text === "string" && e.text.includes("font(")).filter((e) => !DECLARES_FONT.test(e.text)).map((e) => ({ entry: e, calls: scanFontCalls(e.text) })).filter((s) => s.calls.length > 0);
+  if (scanned.length === 0)
+    return [];
+  const errors = scanned.flatMap((s) => s.calls.filter((c2) => c2.error).map((c2) => `${s.entry.path}: ${c2.error}`));
+  if (errors.length)
+    throw new Error([...new Set(errors)].join(`
+`));
+  const registryBase = (opts.registryBase ?? fontRegistryBase()).replace(/\/+$/, "");
+  const entryByPath = new Map(entries.map((e) => [norm(e.path), e]));
+  const faces = new Map;
+  const fileFaceCache = new Map;
+  const resolveCall = (entryPath, call) => {
+    if (call.kind === "file") {
+      const filePath = resolveRel(dirOf(entryPath), call.arg);
+      const target = filePath && entryByPath.get(filePath);
+      if (!target)
+        throw new Error(`${entryPath}: font("${call.arg}"): no such file in the project (resolved to "${filePath || call.arg}").`);
+      call.filePath = filePath;
+      let info2 = fileFaceCache.get(filePath);
+      if (!info2) {
+        if (!opts.readBytes)
+          throw new Error(`${entryPath}: font("${call.arg}"): project-font files aren't supported in this compile context.`);
+        const bytes = opts.readBytes(filePath);
+        if (!bytes)
+          throw new Error(`${entryPath}: font("${call.arg}"): couldn't read "${filePath}".`);
+        try {
+          info2 = parseSfnt(bytes);
+        } catch (e) {
+          throw new Error(`${entryPath}: font("${call.arg}"): ${e.message}`);
+        }
+        fileFaceCache.set(filePath, info2);
+      }
+      return { family: info2.family, callFaces: [{ family: info2.family, weight: info2.weight, italic: info2.italic }] };
+    }
+    const meta = FONT_REGISTRY[call.id];
+    if (!meta) {
+      const known = Object.keys(FONT_REGISTRY);
+      throw new Error(`${entryPath}: font("${call.id}"): unknown registry font. Available: ${known.slice(0, 10).join(", ")}${known.length > 10 ? ", …" : ""}`);
+    }
+    const weights = call.weights ?? meta.defaultWeights;
+    const badW = weights.filter((w) => !meta.weights.includes(w));
+    if (badW.length)
+      throw new Error(`${entryPath}: font("${call.id}"): no ${badW.join("/")} face — available weights: ${meta.weights.join(", ")}.`);
+    if (call.italic) {
+      const badI = weights.filter((w) => !meta.italics.includes(w));
+      if (badI.length) {
+        throw new Error(`${entryPath}: font("${call.id}"): no italic ${badI.join("/")} face${meta.italics.length ? ` — italics exist for: ${meta.italics.join(", ")}` : " — the family ships no italics"}.`);
+      }
+    }
+    const callFaces = weights.flatMap((w) => call.italic ? [{ id: call.id, family: meta.family, weight: w, italic: false }, { id: call.id, family: meta.family, weight: w, italic: true }] : [{ id: call.id, family: meta.family, weight: w, italic: false }]);
+    return { family: meta.family, callFaces };
+  };
+  const pendingRegistry = new Map;
+  const work = [];
+  for (const { entry, calls } of scanned) {
+    const fw = { entry, calls: [], faceKeys: new Set };
+    for (const call of calls) {
+      const { family, callFaces } = resolveCall(norm(entry.path), call);
+      fw.calls.push({ call, family });
+      for (const cf of callFaces) {
+        const key = faceKey(cf.family, cf.weight, cf.italic);
+        fw.faceKeys.add(key);
+        if (faces.has(key))
+          continue;
+        if (cf.id === undefined) {
+          faces.set(key, { family: cf.family, weight: cf.weight, italic: cf.italic, source: { kind: "entry", path: call.filePath } });
+        } else {
+          pendingRegistry.set(key, cf);
+          faces.set(key, { family: cf.family, weight: cf.weight, italic: cf.italic, source: { kind: "cdn", urlBase: "" } });
+        }
+      }
+    }
+    work.push(fw);
+  }
+  for (const [key, face] of pendingRegistry) {
+    const ref = faces.get(key);
+    if (opts.mode === "cdn") {
+      ref.source = { kind: "cdn", urlBase: `${registryBase}/${face.id}/${face.id}-${face.weight}${face.italic ? "-italic" : ""}.` };
+    } else {
+      if (!opts.vendorFace)
+        throw new Error(`font("${face.id}"): registry fonts need vendoring in this compile context, but no vendor hook was provided.`);
+      const path = await opts.vendorFace({ ...face, fileName: faceFileName(face.id, face.weight, face.italic, "ttf") });
+      ref.source = { kind: "entry", path: norm(path) };
+    }
+  }
+  for (const fw of work) {
+    const entryPath = norm(fw.entry.path);
+    const dir = dirOf(entryPath);
+    const modBase = `.${baseOf(entryPath)}.__fonts.ts`;
+    const modPath = dir ? `${dir}/${modBase}` : modBase;
+    const idents = new Map;
+    for (const { family } of fw.calls) {
+      if (!idents.has(family))
+        idents.set(family, `__font_${idents.size}`);
+    }
+    let text = fw.entry.text;
+    for (const { call, family } of [...fw.calls].sort((a, b) => b.call.start - a.call.start)) {
+      text = text.slice(0, call.start) + idents.get(family) + text.slice(call.end);
+    }
+    text += `
+import { ${[...idents.values()].join(", ")} } from ${JSON.stringify(`./${modBase}`)}`;
+    fw.entry.text = text;
+    const lines = [
+      "// Generated by the font() compile macro: registers this file's fonts. Imports hoist, so the",
+      "// faces are declared before the importing module's body runs. Hosts dedupe repeated faces."
+    ];
+    const faceImports = new Map;
+    const body = [];
+    for (const key of [...fw.faceKeys].sort()) {
+      const ref = faces.get(key);
+      let urlExpr;
+      if (ref.source.kind === "cdn") {
+        urlExpr = `${JSON.stringify(ref.source.urlBase)} + (_creatorUI.fontFormat ?? "ttf")`;
+      } else {
+        let ident = faceImports.get(ref.source.path);
+        if (!ident) {
+          ident = `__face_${faceImports.size}`;
+          faceImports.set(ref.source.path, ident);
+          lines.push(`import ${ident} from ${JSON.stringify(relSpecifier(dir, ref.source.path))}`);
+        }
+        urlExpr = ident;
+      }
+      const optionsExpr = ref.italic ? `{ weight: ${ref.weight}, style: "italic" }` : `{ weight: ${ref.weight} }`;
+      body.push(`_creatorUI.registerFont(${JSON.stringify(ref.family)}, ${urlExpr}, ${optionsExpr}, () => {}, () => {})`);
+    }
+    for (const [family, ident] of idents)
+      lines.push(`export const ${ident} = ${JSON.stringify(family)}`);
+    lines.push(...body);
+    entries.push({ path: modPath, type: "text", text: lines.join(`
+`) + `
+` });
+  }
+  return [...faces.values()];
+}, buildFontsHeaderValue = (faces, entryUrl) => faces.map((f2) => {
+  const tag = `${f2.family}@${f2.weight}${f2.italic ? "i" : ""}`;
+  if (f2.source.kind === "cdn")
+    return `${tag}=${f2.source.urlBase}{fmt}`;
+  const url = entryUrl?.(f2.source.path);
+  return url ? `${tag}=${url}` : null;
+}).filter((s) => !!s).join(";");
+var init_fontMacro = __esm(() => {
+  init_fontRegistry();
+  FONT_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+  CODE_FILE = /\.[tj]sx?$/;
+  DECLARES_FONT = /\b(?:function|const|let|var|class)\s+font\b|\bimport\s+(?:\{[^}]*\bfont\b[^}]*\}|font)\s+from\b/;
+});
+
 // ../sdk/src/compile/index.ts
 var exports_compile = {};
 __export(exports_compile, {
   sceneEditorEntries: () => sceneEditorEntries,
+  scanFontCalls: () => scanFontCalls,
+  parseSfnt: () => parseSfnt,
   offsetSourceMap: () => offsetSourceMap,
   loadSceneHarness: () => loadSceneHarness,
   inlineSourceMapComment: () => inlineSourceMapComment,
+  fontRegistryBase: () => fontRegistryBase,
+  faceFileName: () => faceFileName,
   detectProjectKind: () => detectProjectKind,
   compileProject: () => compileProject,
   bundleProjectWithMap: () => bundleProjectWithMap,
   bundleProject: () => bundleProject,
   buildHeader: () => buildHeader,
+  buildFontsHeaderValue: () => buildFontsHeaderValue,
+  applyFontMacro: () => applyFontMacro,
   SCENE_HARNESS_DIR: () => SCENE_HARNESS_DIR,
-  SCENE_ENTRY_PATH: () => SCENE_ENTRY_PATH
+  SCENE_ENTRY_PATH: () => SCENE_ENTRY_PATH,
+  FONT_REGISTRY: () => FONT_REGISTRY,
+  DEFAULT_FONT_REGISTRY_BASE: () => DEFAULT_FONT_REGISTRY_BASE
 });
 var init_compile = __esm(() => {
   init_bundler();
   init_compileProject();
   init_sceneEditor();
+  init_fontMacro();
+  init_fontRegistry();
 });
 
 // ../../node_modules/.bun/qrcode-terminal@0.12.0/node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
@@ -1457,7 +2007,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.7.2",
+  version: "0.8.0",
   description: "Clone, edit and push LeCodes projects from your machine.",
   type: "module",
   license: "MIT",
@@ -1507,16 +2057,22 @@ var package_default = {
   },
   devDependencies: {
     "lecodes-design": "workspace:*",
-    "lecodes-renderer": "^0.4.1",
+    "lecodes-renderer": "workspace:*",
     "qrcode-terminal": "^0.12.0",
     "lecodes-3d-editor": "workspace:*",
     sdk: "workspace:*"
   }
 };
 
-// src/commands/clone.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync } from "node:fs";
-import { resolve } from "node:path";
+// src/commands/app.ts
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync10, readdirSync as readdirSync4, rmSync, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename4, dirname as dirname7, join as join11, resolve as resolve2 } from "node:path";
+
+// src/manifest.ts
+import { dirname, join } from "node:path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 
 // src/util.ts
 import { createHash } from "node:crypto";
@@ -1621,17 +2177,145 @@ var flagStr = (args, ...keys) => {
 };
 var flagBool = (args, ...keys) => keys.some((key) => args.flags[key] === true || args.flags[key] === "true");
 
-// src/api.ts
-var errorMessage = (body, status) => {
-  if (typeof body === "string" && body)
-    return body;
-  if (body && typeof body === "object") {
-    const b = body;
-    if (typeof b.error === "string")
-      return b.error;
-    if (b.error && typeof b.error === "object") {
-      const first = Object.values(b.error)[0];
-      if (typeof first === "string")
+// src/manifest.ts
+var LECODES_DIR = ".lecodes";
+var manifestPath = (root) => join(root, LECODES_DIR, "manifest.json");
+var findProjectRoot = (start) => {
+  let dir = start;
+  while (true) {
+    if (existsSync(manifestPath(dir)))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      throw new CliError("Not inside a lecodes project (no .lecodes/manifest.json found).");
+    dir = parent;
+  }
+};
+var readManifest = (root) => {
+  try {
+    return JSON.parse(readFileSync(manifestPath(root), "utf8"));
+  } catch {
+    throw new CliError("Could not read .lecodes/manifest.json — is this a lecodes project?");
+  }
+};
+var writeManifest = (root, manifest) => {
+  mkdirSync(join(root, LECODES_DIR), { recursive: true });
+  writeFileSync(manifestPath(root), JSON.stringify(manifest, null, 2));
+};
+
+// src/ignore.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store"];
+var DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
+# Only untracked files are affected — assets already in the project stay tracked
+# even if they match a pattern. Built-in defaults (node_modules, _*, *.log) always apply.
+
+# Render / preview outputs (the default \`lecodes render --png\` target)
+screenshot.png
+shots/
+
+# Image & other binary assets ARE pushed by default — they're real project resources.
+# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
+# *.png
+
+# Local notes & dumps (uncomment to ignore)
+# *.json
+# notes.md
+`;
+var translate = (glob) => {
+  let re = "";
+  for (let i = 0;i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (glob[i + 1] === "/")
+          i++;
+      } else
+        re += "[^/]*";
+    } else if (ch === "?")
+      re += "[^/]";
+    else if (ch === "/")
+      re += "/";
+    else if ("\\^$.|+()[]{}".includes(ch))
+      re += "\\" + ch;
+    else
+      re += ch;
+  }
+  return re;
+};
+var compile = (raw) => {
+  let p = raw.trim();
+  if (!p || p.startsWith("#"))
+    return null;
+  let negate = false;
+  if (p.startsWith("!")) {
+    negate = true;
+    p = p.slice(1);
+  }
+  let dirOnly = false;
+  if (p.endsWith("/")) {
+    dirOnly = true;
+    p = p.slice(0, -1);
+  }
+  const anchored = p.startsWith("/") || p.includes("/");
+  if (p.startsWith("/"))
+    p = p.slice(1);
+  if (!p)
+    return null;
+  const body = translate(p);
+  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$");
+  return { re, negate, dirOnly };
+};
+var buildMatcher = (rules) => (key, isDir) => {
+  let ignored = false;
+  for (const r of rules) {
+    if (r.dirOnly && !isDir)
+      continue;
+    if (r.re.test(key))
+      ignored = !r.negate;
+  }
+  return ignored;
+};
+var buildGlobMatcher = (patterns) => {
+  const rules = patterns.map((p) => compile(p.trim().replace(/\/+$/, ""))).filter((r) => r !== null);
+  const match = buildMatcher(rules);
+  return (path) => match(path.startsWith("/") ? path : "/" + path, false);
+};
+var loadIgnore = (root) => {
+  const lines = [...BUILTIN_PATTERNS];
+  const file = join2(root, ".lecodesignore");
+  if (existsSync2(file)) {
+    try {
+      lines.push(...readFileSync2(file, "utf8").split(/\r?\n/));
+    } catch {}
+  }
+  const rules = lines.map(compile).filter((r) => r !== null);
+  return buildMatcher(rules);
+};
+var writeDefaultIgnore = (root) => {
+  const file = join2(root, ".lecodesignore");
+  if (!existsSync2(file))
+    writeFileSync2(file, DEFAULT_IGNORE_FILE);
+};
+
+// src/commands/compile.ts
+import { writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename3, resolve } from "node:path";
+
+// src/api.ts
+var errorMessage = (body, status) => {
+  if (typeof body === "string" && body)
+    return body;
+  if (body && typeof body === "object") {
+    const b = body;
+    if (typeof b.error === "string")
+      return b.error;
+    if (b.error && typeof b.error === "object") {
+      const first = Object.values(b.error)[0];
+      if (typeof first === "string")
         return first;
       if (first && typeof first === "object" && typeof first.message === "string") {
         return first.message;
@@ -1688,15 +2372,15 @@ var downloadBlob = async (apiUrl, src) => {
 
 // src/config.ts
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
 var DEFAULT_API = "https://le.codes";
-var CONFIG_DIR = join(homedir(), ".lecodes");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = join3(homedir(), ".lecodes");
+var CONFIG_FILE = join3(CONFIG_DIR, "config.json");
 var loadConfig = () => {
   let stored = {};
   try {
-    stored = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+    stored = JSON.parse(readFileSync3(CONFIG_FILE, "utf8"));
   } catch {}
   return {
     apiUrl: process.env.LECODES_API ?? stored.apiUrl,
@@ -1704,8 +2388,8 @@ var loadConfig = () => {
   };
 };
 var saveConfig = (config) => {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync3(CONFIG_FILE, JSON.stringify(config, null, 2));
 };
 var normalizeApiUrl = (url) => url.trim().replace(/\/+$/, "");
 var requireToken = (config) => {
@@ -1719,39 +2403,124 @@ var requireApiUrl = (config) => {
   return normalizeApiUrl(config.apiUrl);
 };
 
-// src/manifest.ts
-import { dirname, join as join2 } from "node:path";
-import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
-var LECODES_DIR = ".lecodes";
-var manifestPath = (root) => join2(root, LECODES_DIR, "manifest.json");
-var findProjectRoot = (start) => {
-  let dir = start;
-  while (true) {
-    if (existsSync(manifestPath(dir)))
-      return dir;
-    const parent = dirname(dir);
-    if (parent === dir)
-      throw new CliError("Not inside a lecodes project (no .lecodes/manifest.json found).");
-    dir = parent;
-  }
+// src/compile/collect.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+import { basename } from "node:path";
+
+// src/localFiles.ts
+import { readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import { join as join4, relative } from "node:path";
+var SKIP_DIRS = new Set([".lecodes", ".git", "node_modules"]);
+var SKIP_FILES = new Set(["tsconfig.json", "jsconfig.json", ".gitignore", ".lecodesignore", ".DS_Store"]);
+var TEXT_EXTS = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "json",
+  "svg",
+  "glsl",
+  "vert",
+  "frag",
+  "txt",
+  "md",
+  "css",
+  "html",
+  "xml",
+  "yml",
+  "yaml",
+  "csv"
+]);
+var ext = (name) => {
+  const i = name.lastIndexOf(".");
+  return i < 0 ? "" : name.slice(i + 1).toLowerCase();
 };
-var readManifest = (root) => {
-  try {
-    return JSON.parse(readFileSync2(manifestPath(root), "utf8"));
-  } catch {
-    throw new CliError("Could not read .lecodes/manifest.json — is this a lecodes project?");
-  }
+var classifyKind = (name) => {
+  const e = ext(name);
+  if (e === "mat")
+    return "shader";
+  if (e === "scene")
+    return "scene";
+  return TEXT_EXTS.has(e) ? "text" : "resource";
 };
-var writeManifest = (root, manifest) => {
-  mkdirSync2(join2(root, LECODES_DIR), { recursive: true });
-  writeFileSync2(manifestPath(root), JSON.stringify(manifest, null, 2));
+var isTextKind = (kind) => kind !== "resource";
+var scanLocal = (root, opts = {}) => {
+  const { ignore, tracked } = opts;
+  const files = [];
+  const dirs = [];
+  const ignored = [];
+  const isTracked = (key) => tracked?.has(key) ?? false;
+  const hasTrackedUnder = (key) => {
+    if (!tracked)
+      return false;
+    const prefix = key + "/";
+    for (const t of tracked)
+      if (t.startsWith(prefix))
+        return true;
+    return false;
+  };
+  const walk = (dir, parentIgnored) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join4(dir, entry.name);
+      const key = toKey(relative(root, abs));
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name))
+          continue;
+        const dirIgnored = parentIgnored || !!ignore && ignore(key, true);
+        if (dirIgnored && !isTracked(key) && !hasTrackedUnder(key)) {
+          ignored.push(key + "/");
+          continue;
+        }
+        dirs.push(key);
+        walk(abs, dirIgnored);
+      } else if (entry.isFile()) {
+        if (SKIP_FILES.has(entry.name))
+          continue;
+        const fileIgnored = parentIgnored || !!ignore && ignore(key, false);
+        if (fileIgnored && !isTracked(key)) {
+          ignored.push(key);
+          continue;
+        }
+        files.push({ path: key, absPath: abs, sha: sha256(readFileSync4(abs)) });
+      }
+    }
+  };
+  walk(root, false);
+  return { files, dirs, ignored };
+};
+var scanProject = (root, manifest) => scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest.files)) });
+var diffLocal = (manifest, scan) => {
+  const added = [];
+  const modified = [];
+  const localByPath = new Map(scan.files.map((f) => [f.path, f]));
+  for (const file of scan.files) {
+    const known = manifest.files[file.path];
+    if (!known)
+      added.push(file);
+    else if (known.sha !== file.sha)
+      modified.push(file);
+  }
+  const deleted = Object.keys(manifest.files).filter((path) => !localByPath.has(path));
+  const moves = new Map;
+  const claimed = new Set;
+  for (const file of added) {
+    const from = deleted.find((path) => !claimed.has(path) && manifest.files[path].sha === file.sha);
+    if (from) {
+      moves.set(file.path, from);
+      claimed.add(from);
+    }
+  }
+  return { added, modified, deleted, moves };
 };
+var hasChanges = (diff) => diff.added.length + diff.modified.length + diff.deleted.length > 0;
 
 // src/project.ts
-import { dirname as dirname2, join as join3 } from "node:path";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "node:fs";
 var kindOf = (type) => type === "file" ? "resource" : type;
-var absOf = (root, key) => join3(root, ...key.replace(/^\//, "").split("/"));
+var absOf = (root, key) => join5(root, ...key.replace(/^\//, "").split("/"));
 var buildPaths = (assets) => {
   const pathById = new Map;
   for (const asset of assets) {
@@ -1778,11 +2547,11 @@ var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync3(abs, bytes);
+      writeFileSync4(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync3(abs, text);
+      writeFileSync4(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf(asset.type), sha };
@@ -1791,479 +2560,1630 @@ var materializeAssets = async (root, project, apiUrl, token, onProgress) => {
   return files;
 };
 
-// src/types.ts
-import { dirname as dirname4, join as join5 } from "node:path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
-
-// src/distRoot.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname3, join as join4 } from "node:path";
-import { fileURLToPath } from "node:url";
-var distRoot = (() => {
-  const candidates = [
-    join4(dirname3(fileURLToPath(import.meta.url)), ".."),
-    dirname3(process.execPath)
-  ];
-  for (const c2 of candidates)
-    if (existsSync2(join4(c2, "runtime")))
-      return c2;
-  return candidates[0];
-})();
-
-// src/types.ts
-var TSCONFIG = {
-  compilerOptions: {
-    target: "ES2020",
-    module: "ESNext",
-    moduleResolution: "bundler",
-    lib: ["ES2020"],
-    types: [],
-    allowJs: true,
-    checkJs: false,
-    strict: false,
-    noEmit: true,
-    skipLibCheck: true
-  },
-  include: [`${LECODES_DIR}/types/**/*.d.ts`, "**/*.ts", "**/*.js"],
-  exclude: ["node_modules"]
-};
-var writeTypeBundle = (root, bundle) => {
-  const typesDir = join5(root, LECODES_DIR, "types");
-  for (const [path, text] of Object.entries(bundle)) {
-    const dest = join5(typesDir, path);
-    mkdirSync4(dirname4(dest), { recursive: true });
-    writeFileSync4(dest, text);
+// src/compile/collect.ts
+var collectEntries = (root, manifest, project, opts = {}) => {
+  const pathById = buildPaths(project.assets);
+  const serverByPath = new Map;
+  for (const asset of project.assets) {
+    if (asset.type === "folder")
+      continue;
+    serverByPath.set(pathById.get(asset.id), { fileSrc: asset.file?.src ?? undefined, shaders: asset.shaders ?? [] });
   }
-};
-var materializeTypes = async (root, apiUrl) => {
-  writeTypeBundle(root, await getTypes(apiUrl));
-};
-var readLocalTypeBundle = () => {
-  const candidates = [
-    join5(distRoot, "runtime", "sdk-types.json"),
-    join5(distRoot, "..", "sdk", "dist", "types.json")
-  ];
-  for (const path of candidates) {
-    if (existsSync3(path)) {
-      try {
-        return JSON.parse(readFileSync3(path, "utf8"));
-      } catch {}
+  const entries = [];
+  const warnings = [];
+  const scan = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest.files)) });
+  for (const file of scan.files) {
+    const type = manifest.files[file.path]?.type ?? classifyKind(basename(file.path));
+    if (type === "resource") {
+      const src = serverByPath.get(file.path)?.fileSrc;
+      if (!src && (opts.warnMissingUrl ?? true))
+        warnings.push(`No server URL for ${file.path} — push it so its URL resolves.`);
+      entries.push({ path: file.path, type, fileSrc: src, absPath: file.absPath });
+    } else if (type === "shader") {
+      const shaders = serverByPath.get(file.path)?.shaders;
+      if (!shaders?.length)
+        warnings.push(`No compiled shader for ${file.path} — push it to compile the shader.`);
+      entries.push({ path: file.path, type, shaders });
+    } else {
+      entries.push({ path: file.path, type, text: readFileSync5(file.absPath, "utf8") });
     }
   }
-  return null;
-};
-var materializeTypesLocal = (root) => {
-  const bundle = readLocalTypeBundle();
-  if (!bundle)
-    return false;
-  writeTypeBundle(root, bundle);
-  return true;
+  return { entries, warnings };
 };
-var writeTsconfig = (root) => {
-  writeFileSync4(join5(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+
+// src/compile/collectLocal.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+import { basename as basename2 } from "node:path";
+var collectLocalEntries = (root, manifest, assetBase) => {
+  const entries = [];
+  const warnings = [];
+  const scan = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
+  for (const file of scan.files) {
+    const type = manifest?.files[file.path]?.type ?? classifyKind(basename2(file.path));
+    if (type === "resource") {
+      entries.push({ path: file.path, type, fileSrc: assetBase + encodeURI(file.path), absPath: file.absPath });
+    } else if (type === "shader") {
+      warnings.push(`${file.path}: shaders compile on the server — push the project once for shaders to work in dev mode.`);
+      entries.push({ path: file.path, type, shaders: [] });
+    } else {
+      entries.push({ path: file.path, type, text: readFileSync6(file.absPath, "utf8") });
+    }
+  }
+  return { entries, warnings };
 };
 
-// src/ignore.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join6 } from "node:path";
-var BUILTIN_PATTERNS = ["node_modules/", ".git/", "_*", "*.log", ".DS_Store"];
-var DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
-# Only untracked files are affected — assets already in the project stay tracked
-# even if they match a pattern. Built-in defaults (node_modules, _*, *.log) always apply.
+// src/compile/projectCompile.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname5, join as join9 } from "node:path";
 
-# Render / preview outputs (the default \`lecodes render --png\` target)
-screenshot.png
-shots/
+// src/distRoot.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+import { fileURLToPath } from "node:url";
+var distRoot = (() => {
+  const candidates = [
+    join6(dirname3(fileURLToPath(import.meta.url)), ".."),
+    dirname3(process.execPath)
+  ];
+  for (const c2 of candidates)
+    if (existsSync3(join6(c2, "runtime")))
+      return c2;
+  return candidates[0];
+})();
 
-# Image & other binary assets ARE pushed by default — they're real project resources.
-# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
-# *.png
+// src/compile/projectCompile.ts
+init_compile();
+var vendoredInject = join9(distRoot, "runtime", "sdk", "inject.ts");
+if (existsSync6(vendoredInject))
+  process.env.LECODES_SDK_INJECT = vendoredInject;
+var resolveChiselBin2 = () => {
+  if (process.env.LECODES_CHISEL_BIN)
+    return process.env.LECODES_CHISEL_BIN;
+  try {
+    const fromPkg = createRequire3(import.meta.url)("@letary/chisel").binaryPath();
+    if (fromPkg)
+      return fromPkg;
+  } catch {}
+  const local = join9(dirname5(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel");
+  return existsSync6(local) ? local : null;
+};
+var chiselBin = resolveChiselBin2();
+if (chiselBin)
+  process.env.LECODES_CHISEL_BIN = chiselBin;
+var compileProject2 = (opts) => compileProject({
+  entries: opts.entries.map((e) => ({ path: e.path, type: e.type, text: e.text, fileSrc: e.fileSrc, remote: e.remote, shaders: e.shaders })),
+  name: opts.name,
+  publicUrl: opts.publicUrl,
+  entryOverride: opts.entryOverride,
+  header: opts.header,
+  fontsHeader: opts.fontsHeader,
+  format: opts.format,
+  localAssets: opts.localAssets,
+  minify: opts.minify,
+  sourcemap: opts.sourcemap,
+  editor: opts.editor
+});
 
-# Local notes & dumps (uncomment to ignore)
-# *.json
-# notes.md
-`;
-var translate = (glob) => {
-  let re = "";
-  for (let i = 0;i < glob.length; i++) {
-    const ch = glob[i];
-    if (ch === "*") {
-      if (glob[i + 1] === "*") {
-        re += ".*";
-        i++;
-        if (glob[i + 1] === "/")
-          i++;
-      } else
-        re += "[^/]*";
-    } else if (ch === "?")
-      re += "[^/]";
-    else if (ch === "/")
-      re += "/";
-    else if ("\\^$.|+()[]{}".includes(ch))
-      re += "\\" + ch;
-    else
-      re += ch;
-  }
-  return re;
+// src/compile/fonts.ts
+init_compile();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname6, join as join10 } from "node:path";
+var applyProjectFonts = async (entries, opts) => {
+  const registry = (opts.registry ?? fontRegistryBase()).replace(/\/+$/, "");
+  const byPath = () => new Map(entries.map((e) => [e.path.replace(/^\//, ""), e]));
+  const faces = await applyFontMacro(entries, {
+    mode: opts.mode,
+    registryBase: registry,
+    readBytes: (entryPath) => {
+      const entry = byPath().get(entryPath);
+      const abs = entry?.absPath ?? join10(opts.root, entryPath);
+      try {
+        return new Uint8Array(readFileSync9(abs));
+      } catch {
+        return null;
+      }
+    },
+    vendorFace: opts.mode === "vendor" ? async (face) => {
+      const vendorDir = opts.vendorDir ?? opts.root;
+      const rel = `assets/fonts/${face.fileName}`;
+      const abs = join10(vendorDir, rel);
+      const entryPath = `${opts.vendorPrefix ?? ""}/${rel}`;
+      if (!existsSync7(abs))
+        await downloadFace(registry, vendorDir, face, rel, abs);
+      if (!byPath().has(entryPath.replace(/^\//, ""))) {
+        entries.push(opts.makeResourceEntry?.(entryPath, abs) ?? { path: entryPath, type: "resource", absPath: abs });
+      }
+      return entryPath;
+    } : undefined
+  });
+  if (faces.length === 0)
+    return;
+  return buildFontsHeaderValue(faces, (path) => {
+    if (!opts.publicUrl || !/^https?:/i.test(opts.publicUrl))
+      return null;
+    const fileSrc = byPath().get(path.replace(/^\//, ""))?.fileSrc;
+    return fileSrc ? opts.publicUrl + fileSrc : null;
+  }) || undefined;
 };
-var compile = (raw) => {
-  let p = raw.trim();
-  if (!p || p.startsWith("#"))
-    return null;
-  let negate = false;
-  if (p.startsWith("!")) {
-    negate = true;
-    p = p.slice(1);
-  }
-  let dirOnly = false;
-  if (p.endsWith("/")) {
-    dirOnly = true;
-    p = p.slice(0, -1);
+var isHttp = (s) => /^https?:/i.test(s);
+var sha12 = (b) => createHash2("sha256").update(b).digest("hex").slice(0, 12);
+var registryHome = (registry) => registry.replace(/\/v\d+$/, "");
+var readRegistry = async (registry, rel) => {
+  if (isHttp(registry)) {
+    const res = await fetch(`${registry}/${rel}`);
+    return res.ok ? new Uint8Array(await res.arrayBuffer()) : null;
   }
-  const anchored = p.startsWith("/") || p.includes("/");
-  if (p.startsWith("/"))
-    p = p.slice(1);
-  if (!p)
+  try {
+    return new Uint8Array(readFileSync9(join10(registry, rel)));
+  } catch {
     return null;
-  const body = translate(p);
-  const re = anchored ? new RegExp("^/" + body + "(/.*)?$") : new RegExp("(^|/)" + body + "(/.*)?$");
-  return { re, negate, dirOnly };
-};
-var buildMatcher = (rules) => (key, isDir) => {
-  let ignored = false;
-  for (const r of rules) {
-    if (r.dirOnly && !isDir)
-      continue;
-    if (r.re.test(key))
-      ignored = !r.negate;
   }
-  return ignored;
 };
-var loadIgnore = (root) => {
-  const lines = [...BUILTIN_PATTERNS];
-  const file = join6(root, ".lecodesignore");
-  if (existsSync4(file)) {
-    try {
-      lines.push(...readFileSync4(file, "utf8").split(/\r?\n/));
-    } catch {}
+var readLock = (path) => {
+  try {
+    const lock = JSON.parse(readFileSync9(path, "utf8"));
+    if (lock && typeof lock === "object" && lock.faces && lock.families)
+      return lock;
+  } catch {}
+  return null;
+};
+var serializeLock = (lock) => {
+  const sortKeys = (rec) => Object.fromEntries(Object.keys(rec).sort().map((k) => [k, rec[k]]));
+  return JSON.stringify({ registry: lock.registry, faces: sortKeys(lock.faces), families: sortKeys(lock.families) }, null, 2) + `
+`;
+};
+var renderNotices = (lock) => {
+  const ids = [...new Set(Object.values(lock.faces).map((f2) => f2.id))].sort();
+  const lines = [
+    "# Font attribution & notices",
+    "",
+    "Fonts vendored from the font registry via `font(...)`. Keep this file in your repo / product.",
+    ""
+  ];
+  for (const id of ids) {
+    const l = lock.families[id];
+    if (!l)
+      continue;
+    let note2 = `- **${l.title || id}** — ${l.spdx}${l.url ? ` — ${l.url}` : ""}`;
+    if (l.attribution)
+      note2 += `
+  - **Attribution required:** ${l.attribution}`;
+    lines.push(note2);
   }
-  const rules = lines.map(compile).filter((r) => r !== null);
-  return buildMatcher(rules);
+  lines.push("");
+  return lines.join(`
+`);
 };
-var writeDefaultIgnore = (root) => {
-  const file = join6(root, ".lecodesignore");
-  if (!existsSync4(file))
-    writeFileSync5(file, DEFAULT_IGNORE_FILE);
+var writeIfChanged = (path, text) => {
+  try {
+    if (readFileSync9(path, "utf8") === text)
+      return;
+  } catch {}
+  writeFileSync5(path, text);
+};
+var downloadFace = async (registry, vendorDir, face, rel, abs) => {
+  const licRaw = await readRegistry(registry, "licenses.json");
+  if (!licRaw)
+    throw new Error(`font: can't reach the font registry (${registry}). Check your connection, or set LECODES_FONT_REGISTRY.`);
+  const licenses = JSON.parse(new TextDecoder().decode(licRaw));
+  const lic = licenses[face.id];
+  if (!lic)
+    throw new Error(`font("${face.id}"): the registry has no license entry for this family — it may not be published yet. Browse ${registryHome(registry)}.`);
+  const bytes = await readRegistry(registry, `${face.id}/${face.fileName}`);
+  if (!bytes)
+    throw new Error(`font("${face.id}"): face "${face.fileName}" not found in the registry (${registryHome(registry)}).`);
+  mkdirSync4(dirname6(abs), { recursive: true });
+  writeFileSync5(abs, bytes);
+  const lockPath = join10(vendorDir, "fonts.lock.json");
+  const lock = readLock(lockPath) ?? { registry, faces: {}, families: {} };
+  lock.registry = registry;
+  lock.faces[`${face.id}@${face.weight}${face.italic ? "i" : ""}`] = { id: face.id, family: face.family, weight: face.weight, italic: face.italic, hash: sha12(bytes), spdx: lic.spdx, path: rel };
+  lock.families[face.id] = lic;
+  writeIfChanged(lockPath, serializeLock(lock));
+  writeIfChanged(join10(vendorDir, "FONT-NOTICES.md"), renderNotices(lock));
 };
 
-// src/commands/clone.ts
-var parseUuid = (input) => {
-  if (!input)
-    throw new CliError("Usage: lecodes clone <project-uuid|url> [directory]");
-  if (!input.includes("/"))
-    return input;
-  const clean = input.split(/[?#]/)[0].replace(/\/+$/, "");
-  const match = clean.match(/\/(?:projects|view)\/([^/]+)/);
-  return match ? match[1] : clean.slice(clean.lastIndexOf("/") + 1);
+// src/commands/compile.ts
+var compile2 = async (args) => {
+  await compileImpl(args);
 };
-var slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
-var clone = async (args) => {
-  const config = loadConfig();
-  const apiUrl = requireApiUrl(config);
-  const token = requireToken(config);
-  const uuid = parseUuid(args._[0]);
-  const project = await getProject(apiUrl, token, uuid);
-  const dir = args._[1] ?? slug(project.name);
-  const root = resolve(dir);
-  if (existsSync5(root) && readdirSync(root).length > 0) {
-    throw new CliError(`Directory "${dir}" already exists and is not empty.`);
+var compileShell = (args, shell) => compileImpl(args, shell);
+var compileImpl = async (args, shell) => {
+  let root;
+  let manifest;
+  try {
+    root = findProjectRoot(process.cwd());
+    manifest = readManifest(root);
+  } catch {
+    root = process.cwd();
+    manifest = null;
   }
-  mkdirSync5(root, { recursive: true });
-  info(c.dim(`Fetching project ${c.bold(project.name)}…`));
-  const files = await materializeAssets(root, project, apiUrl, token, progress);
-  endProgress();
-  if (!flagBool(args, "no-types")) {
-    info(c.dim("Fetching type definitions…"));
-    await materializeTypes(root, apiUrl);
-    writeTsconfig(root);
+  let entries;
+  let warnings;
+  let name;
+  let publicUrl;
+  let localAssets = false;
+  if (manifest) {
+    const config = loadConfig();
+    const apiUrl = requireApiUrl(config);
+    const token = requireToken(config);
+    note("Resolving project assets…");
+    const project = await getProject(apiUrl, token, manifest.uuid);
+    ({ entries, warnings } = collectEntries(root, manifest, project, { warnMissingUrl: !shell }));
+    name = manifest.name;
+    publicUrl = flagStr(args, "public-url") ?? apiUrl;
+    localAssets = !!shell;
+    if (shell && shell.remotePatterns.length > 0) {
+      const isRemote = buildGlobMatcher(shell.remotePatterns);
+      for (const e of entries) {
+        if (e.type !== "resource" || !isRemote(e.path))
+          continue;
+        if (!e.fileSrc) {
+          warnErr(`${e.path} matches resources.remote but has no server URL yet — bundling it (push, then re-sync).`);
+          continue;
+        }
+        e.remote = true;
+      }
+    }
+  } else {
+    const publicUrlFlag = flagStr(args, "public-url");
+    localAssets = shell ? true : publicUrlFlag === undefined;
+    publicUrl = publicUrlFlag ?? "";
+    ({ entries, warnings } = collectLocalEntries(root, null, ""));
+    name = basename3(root);
+    if (shell && shell.remotePatterns.length > 0) {
+      warnErr("resources.remote needs a server-backed project (a streamed asset needs a server URL) — bundling everything.");
+    }
   }
-  writeDefaultIgnore(root);
-  const commits = await getCommits(apiUrl, token, uuid);
-  writeManifest(root, { uuid, apiUrl, name: project.name, baseHeadId: commits.headId, files });
-  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/ (${Object.keys(files).length} files)`);
-  info(c.dim(`  cd ${dir} — edit, then \`lecodes push -m "your message"\``));
+  const fontsHeader = await applyProjectFonts(entries, manifest && !shell ? { mode: "cdn", root, publicUrl } : {
+    mode: "vendor",
+    root,
+    vendorDir: root,
+    vendorPrefix: "",
+    publicUrl: shell ? "" : publicUrl,
+    makeResourceEntry: (path, absPath) => ({ path, type: "resource", fileSrc: encodeURI(path), absPath })
+  });
+  note("Compiling…");
+  const js = await compileProject2({
+    entries,
+    name,
+    publicUrl,
+    entryOverride: flagStr(args, "entry"),
+    header: !flagBool(args, "no-header"),
+    localAssets,
+    fontsHeader,
+    minify: flagBool(args, "no-minify") ? false : undefined,
+    sourcemap: flagBool(args, "no-sourcemap", "no-source-map") ? false : undefined
+  });
+  for (const w of warnings)
+    warnErr(w);
+  const out = flagStr(args, "o", "out");
+  if (out && isNullSink(out)) {
+    note(`Discarded output (${out})`);
+  } else if (out) {
+    writeFileSync6(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) => ({
+    path: e.path.replace(/^\//, ""),
+    name: e.path.split(/[\\/]/).pop() ?? e.path,
+    absPath: e.absPath,
+    remote: !!e.remote
+  }));
+};
+var previewLegacy = async (args) => {
+  warnErr("'lecodes preview' is now 'lecodes compile' — the old name still works.");
+  await compile2(args);
 };
 
-// src/commands/compile.ts
-import { writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename3, resolve as resolve2 } from "node:path";
+// src/commands/appTemplates.ts
+var pbxStr = (s) => s.replace(/[\\"]/g, (m) => "\\" + m);
+var pbxprojTemplate = ({ displayName, bundleId, teamId, version, buildNumber }) => {
+  const target = `
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = ${buildNumber};
+				DEVELOPMENT_TEAM = "${pbxStr(teamId)}";
+				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = "App/Info.plist";
+				INFOPLIST_KEY_CFBundleDisplayName = "${pbxStr(displayName)}";
+				INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents = YES;
+				INFOPLIST_KEY_UILaunchStoryboardName = LaunchScreen;
+				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPad = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
+				INFOPLIST_KEY_UISupportedInterfaceOrientations_iPhone = "UIInterfaceOrientationPortrait UIInterfaceOrientationLandscapeLeft UIInterfaceOrientationLandscapeRight";
+				IPHONEOS_DEPLOYMENT_TARGET = 15.6;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				MARKETING_VERSION = ${version};
+				PRODUCT_BUNDLE_IDENTIFIER = "${pbxStr(bundleId)}";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				SWIFT_APPROACHABLE_CONCURRENCY = YES;
+				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";`;
+  const project = (debug) => `
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++20";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = ${debug ? "dwarf" : '"dwarf-with-dsym"'};
+				DEVELOPMENT_TEAM = "${pbxStr(teamId)}";${debug ? "" : `
+				ENABLE_NS_ASSERTIONS = NO;`}
+				ENABLE_STRICT_OBJC_MSGSEND = YES;${debug ? `
+				ENABLE_TESTABILITY = YES;` : ""}
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu17;${debug ? `
+				GCC_DYNAMIC_NO_PIC = NO;` : ""}
+				GCC_NO_COMMON_BLOCKS = YES;${debug ? `
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);` : ""}
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 15.6;
+				LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
+				MTL_ENABLE_DEBUG_INFO = ${debug ? "INCLUDE_SOURCE" : "NO"};
+				MTL_FAST_MATH = YES;${debug ? `
+				ONLY_ACTIVE_ARCH = YES;` : ""}
+				SDKROOT = iphoneos;${debug ? `
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";` : `
+				SWIFT_COMPILATION_MODE = wholemodule;
+				VALIDATE_PRODUCT = YES;`}`;
+  return `// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 77;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		B73550812FEBAC710005B4CC /* LeCodesRuntime in Frameworks */ = {isa = PBXBuildFile; productRef = B73550802FEBAC710005B4CC /* LeCodesRuntime */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		B73550672FEBAC0F0005B4CC /* App.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = App.app; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
+		B73550792FEBAC100005B4CC /* Exceptions for "App" folder in "App" target */ = {
+			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+			membershipExceptions = (
+				Info.plist,
+			);
+			target = B73550662FEBAC0F0005B4CC /* App */;
+		};
+/* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
+
+/* Begin PBXFileSystemSynchronizedRootGroup section */
+		B73550692FEBAC0F0005B4CC /* App */ = {
+			isa = PBXFileSystemSynchronizedRootGroup;
+			exceptions = (
+				B73550792FEBAC100005B4CC /* Exceptions for "App" folder in "App" target */,
+			);
+			path = App;
+			sourceTree = "<group>";
+		};
+/* End PBXFileSystemSynchronizedRootGroup section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		B73550642FEBAC0F0005B4CC /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B73550812FEBAC710005B4CC /* LeCodesRuntime in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		B735505E2FEBAC0F0005B4CC = {
+			isa = PBXGroup;
+			children = (
+				B73550692FEBAC0F0005B4CC /* App */,
+				B73550682FEBAC0F0005B4CC /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		B73550682FEBAC0F0005B4CC /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				B73550672FEBAC0F0005B4CC /* App.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		B73550662FEBAC0F0005B4CC /* App */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = B735507A2FEBAC100005B4CC /* Build configuration list for PBXNativeTarget "App" */;
+			buildPhases = (
+				B73550632FEBAC0F0005B4CC /* Sources */,
+				B73550642FEBAC0F0005B4CC /* Frameworks */,
+				B73550652FEBAC0F0005B4CC /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			fileSystemSynchronizedGroups = (
+				B73550692FEBAC0F0005B4CC /* App */,
+			);
+			name = App;
+			packageProductDependencies = (
+				B73550802FEBAC710005B4CC /* LeCodesRuntime */,
+			);
+			productName = App;
+			productReference = B73550672FEBAC0F0005B4CC /* App.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		B735505F2FEBAC0F0005B4CC /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = 1;
+				LastSwiftUpdateCheck = 2650;
+				LastUpgradeCheck = 2650;
+				TargetAttributes = {
+					B73550662FEBAC0F0005B4CC = {
+						CreatedOnToolsVersion = 26.5;
+					};
+				};
+			};
+			buildConfigurationList = B73550622FEBAC0F0005B4CC /* Build configuration list for PBXProject "App" */;
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = B735505E2FEBAC0F0005B4CC;
+			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				B73550822FEBAC720005B4CC /* XCLocalSwiftPackageReference "LeCodesRuntime" */,
+			);
+			preferredProjectObjectVersion = 77;
+			productRefGroup = B73550682FEBAC0F0005B4CC /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				B73550662FEBAC0F0005B4CC /* App */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		B73550652FEBAC0F0005B4CC /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		B73550632FEBAC0F0005B4CC /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		B735507B2FEBAC100005B4CC /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {${target}
+			};
+			name = Debug;
+		};
+		B735507C2FEBAC100005B4CC /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {${target}
+			};
+			name = Release;
+		};
+		B735507D2FEBAC100005B4CC /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {${project(true)}
+			};
+			name = Debug;
+		};
+		B735507E2FEBAC100005B4CC /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {${project(false)}
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		B73550622FEBAC0F0005B4CC /* Build configuration list for PBXProject "App" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B735507D2FEBAC100005B4CC /* Debug */,
+				B735507E2FEBAC100005B4CC /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		B735507A2FEBAC100005B4CC /* Build configuration list for PBXNativeTarget "App" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B735507B2FEBAC100005B4CC /* Debug */,
+				B735507C2FEBAC100005B4CC /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+
+/* Begin XCLocalSwiftPackageReference section */
+		B73550822FEBAC720005B4CC /* XCLocalSwiftPackageReference "LeCodesRuntime" */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = LeCodesRuntime;
+		};
+/* End XCLocalSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		B73550802FEBAC710005B4CC /* LeCodesRuntime */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = LeCodesRuntime;
+		};
+/* End XCSwiftPackageProductDependency section */
+	};
+	rootObject = B735505F2FEBAC0F0005B4CC /* Project object */;
+}
+`;
+};
+var SCHEME_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "2650"
+   version = "1.7">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "B73550662FEBAC0F0005B4CC"
+               BuildableName = "App.app"
+               BlueprintName = "App"
+               ReferencedContainer = "container:App.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "B73550662FEBAC0F0005B4CC"
+            BuildableName = "App.app"
+            BlueprintName = "App"
+            ReferencedContainer = "container:App.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "B73550662FEBAC0F0005B4CC"
+            BuildableName = "App.app"
+            BlueprintName = "App"
+            ReferencedContainer = "container:App.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
+`;
+var APP_DELEGATE = `//
+//  AppDelegate.swift
+//  Generated by lecodes app init — yours to edit.
+//
 
-// src/compile/collect.ts
-import { readFileSync as readFileSync6 } from "node:fs";
-import { basename } from "node:path";
+import UIKit
 
-// src/localFiles.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
-import { join as join7, relative } from "node:path";
-var SKIP_DIRS = new Set([".lecodes", ".git", "node_modules"]);
-var SKIP_FILES = new Set(["tsconfig.json", "jsconfig.json", ".gitignore", ".lecodesignore", ".DS_Store"]);
-var TEXT_EXTS = new Set([
-  "ts",
-  "tsx",
-  "js",
-  "jsx",
-  "mjs",
-  "cjs",
-  "json",
-  "svg",
-  "glsl",
-  "vert",
-  "frag",
-  "txt",
-  "md",
-  "css",
-  "html",
-  "xml",
-  "yml",
-  "yaml",
-  "csv"
-]);
-var ext = (name) => {
-  const i = name.lastIndexOf(".");
-  return i < 0 ? "" : name.slice(i + 1).toLowerCase();
-};
-var classifyKind = (name) => {
-  const e = ext(name);
-  if (e === "mat")
-    return "shader";
-  if (e === "scene")
-    return "scene";
-  return TEXT_EXTS.has(e) ? "text" : "resource";
-};
-var isTextKind = (kind) => kind !== "resource";
-var scanLocal = (root, opts = {}) => {
-  const { ignore, tracked } = opts;
-  const files = [];
-  const dirs = [];
-  const ignored = [];
-  const isTracked = (key) => tracked?.has(key) ?? false;
-  const hasTrackedUnder = (key) => {
-    if (!tracked)
-      return false;
-    const prefix = key + "/";
-    for (const t of tracked)
-      if (t.startsWith(prefix))
-        return true;
-    return false;
-  };
-  const walk = (dir, parentIgnored) => {
-    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      const abs = join7(dir, entry.name);
-      const key = toKey(relative(root, abs));
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name))
-          continue;
-        const dirIgnored = parentIgnored || !!ignore && ignore(key, true);
-        if (dirIgnored && !isTracked(key) && !hasTrackedUnder(key)) {
-          ignored.push(key + "/");
-          continue;
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        return true
+    }
+
+    // MARK: UISceneSession Lifecycle
+
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+    }
+}
+`;
+var SCENE_DELEGATE = `//
+//  SceneDelegate.swift
+//  Generated by lecodes app init — yours to edit.
+//
+
+import UIKit
+
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+
+    var window: UIWindow?
+
+    func scene(
+        _ scene: UIScene,
+        willConnectTo session: UISceneSession,
+        options connectionOptions: UIScene.ConnectionOptions
+    ) {
+        guard let windowScene = (scene as? UIWindowScene) else { return }
+
+        let window = UIWindow(windowScene: windowScene)
+        window.rootViewController = ViewController()
+        self.window = window
+        window.makeKeyAndVisible()
+    }
+}
+`;
+var VIEW_CONTROLLER = `//
+//  ViewController.swift
+//  Generated by lecodes app init — yours to edit.
+//
+//  Runs the bundled app.js (produced by \`lecodes app sync\`) offline: everything the
+//  script needs is provided by the SDK core (_creatorUI / _creatorUtils / console)
+//  plus the plugins registered below via LeCodesRuntime.
+//
+
+import UIKit
+import LeCodesRuntime
+
+class ViewController: LeCodesViewController {
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        let lang = Locale.preferredLanguages.first.map { String($0.prefix(2)) } ?? "en"
+        engine.setLanguage(lang)
+
+        // \`// preload:\` assets (images, fonts) resolve out of the app bundle.
+        engine.setFetchLocal { path in
+            let ns = path as NSString
+            let ext = ns.pathExtension
+            let name = ns.deletingPathExtension
+            guard let url = Bundle.main.url(forResource: name, withExtension: ext.isEmpty ? nil : ext) else {
+                return nil
+            }
+            return try? Data(contentsOf: url)
         }
-        dirs.push(key);
-        walk(abs, dirIgnored);
-      } else if (entry.isFile()) {
-        if (SKIP_FILES.has(entry.name))
-          continue;
-        const fileIgnored = parentIgnored || !!ignore && ignore(key, false);
-        if (fileIgnored && !isTracked(key)) {
-          ignored.push(key);
-          continue;
+
+        registerBundledPlugins(in: engine)
+
+        guard let url = Bundle.main.url(forResource: "app", withExtension: "js"),
+              let code = try? String(contentsOf: url, encoding: .utf8) else {
+            print("LeCodes: bundled app.js is missing — run \`lecodes app sync\`")
+            return
         }
-        files.push({ path: key, absPath: abs, sha: sha256(readFileSync5(abs)) });
-      }
+        engine.run(code)
     }
-  };
-  walk(root, false);
-  return { files, dirs, ignored };
+}
+`;
+var infoPlistTemplate = (pluginKeys) => {
+  const keys = Object.keys(pluginKeys).sort();
+  const pluginBlock = keys.length === 0 ? "" : `
+	<!-- lecodes:plugins — merged from installed plugin manifests by \`lecodes app sync\` -->
+${keys.map((k) => `	<key>${k}</key>
+	<string>${pluginKeys[k]}</string>`).join(`
+`)}`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default Configuration</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>${pluginBlock}
+</dict>
+</plist>
+`;
 };
-var scanProject = (root, manifest) => scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest.files)) });
-var diffLocal = (manifest, scan) => {
-  const added = [];
-  const modified = [];
-  const localByPath = new Map(scan.files.map((f) => [f.path, f]));
-  for (const file of scan.files) {
-    const known = manifest.files[file.path];
-    if (!known)
-      added.push(file);
-    else if (known.sha !== file.sha)
-      modified.push(file);
+var LAUNCH_STORYBOARD = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" xcode11CocoaTouchSystemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>
+`;
+var ASSETS_ROOT_JSON = `{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
   }
-  const deleted = Object.keys(manifest.files).filter((path) => !localByPath.has(path));
-  const moves = new Map;
-  const claimed = new Set;
-  for (const file of added) {
-    const from = deleted.find((path) => !claimed.has(path) && manifest.files[path].sha === file.sha);
-    if (from) {
-      moves.set(file.path, from);
-      claimed.add(from);
+}
+`;
+var ACCENT_COLOR_JSON = `{
+  "colors" : [
+    {
+      "idiom" : "universal"
     }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
   }
-  return { added, modified, deleted, moves };
+}
+`;
+var APP_ICON_JSON = `{
+  "images" : [
+    {
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "tinted"
+        }
+      ],
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
+`;
+var runtimePackageTemplate = (sdkVersion, variant, plugins) => {
+  const product = `LeCodesSDK-${variant}`;
+  const pluginTargets = plugins.map((p) => `
+        // plugin: ${p.id} (vendored — see plugins.lock.json)
+        .target(
+            name: "${p.module}",
+            dependencies: [.product(name: "${product}", package: "lecodes-ios-sdk")],
+            path: "Sources/${p.module}"
+        ),`).join("");
+  const runtimeDeps = [`.product(name: "${product}", package: "lecodes-ios-sdk")`, ...plugins.map((p) => `"${p.module}"`)];
+  return `// swift-tools-version:5.9
+//
+// GENERATED by lecodes — regenerated by \`lecodes app sync\`; do not edit.
+// Owns the app's native dependency graph: the LeCodesSDK variant (app.json ios.variant)
+// and one vendored target per installed plugin (see plugins.lock.json).
+
+import PackageDescription
+
+let package = Package(
+    name: "LeCodesRuntime",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "LeCodesRuntime", targets: ["LeCodesRuntime"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/letary/lecodes-ios-sdk.git", from: "${sdkVersion}"),
+    ],
+    targets: [
+        .target(
+            name: "LeCodesRuntime",
+            dependencies: [
+                ${runtimeDeps.join(`,
+                `)},
+            ],
+            path: "Sources/LeCodesRuntime"
+        ),${pluginTargets}
+    ]
+)
+`;
 };
-var hasChanges = (diff) => diff.added.length + diff.modified.length + diff.deleted.length > 0;
+var runtimeSwiftTemplate = (plugins) => {
+  const imports = plugins.map((p) => `import ${p.module}
+`).join("");
+  const calls = plugins.length === 0 ? `
+` : plugins.map((p) => `    ${p.register}.register(in: engine)
+`).join("");
+  return `//
+//  LeCodesRuntime.swift
+//  GENERATED by lecodes — regenerated by \`lecodes app sync\`; do not edit.
+//
+//  Re-exports the SDK (so app code needs only \`import LeCodesRuntime\`) and registers
+//  every plugin installed in app.json.
+//
+
+@_exported import LeCodesSDK
+${imports}
+public func registerBundledPlugins(in engine: LeCodesEngine) {
+${calls}}
+`;
+};
+var IOS_README = `# ios/ — native Xcode shell
 
-// src/compile/collect.ts
-var collectEntries = (root, manifest, project) => {
-  const pathById = buildPaths(project.assets);
-  const serverByPath = new Map;
-  for (const asset of project.assets) {
-    if (asset.type === "folder")
-      continue;
-    serverByPath.set(pathById.get(asset.id), { fileSrc: asset.file?.src ?? undefined, shaders: asset.shaders ?? [] });
+Generated by \`lecodes app init ios\` for the LeCodes project one folder up. The app runs the
+compiled bundle in \`App/Resources/app.js\` — fully offline, nothing fetched at launch. This
+folder is ignored by the platform (\`ios/\` in \`.lecodesignore\`) and is never pushed to LeCodes.
+
+## Daily workflow
+
+Edit the app's code at the project root (\`main.ts\` …), then:
+
+\`\`\`
+lecodes app sync     # recompile app.js + assets into the shell, vendor plugins
+lecodes app open     # open App.xcodeproj in Xcode — build & run from there
+\`\`\`
+
+\`lecodes app doctor\` preflights builds; \`lecodes app build ios\` archives and exports an
+.ipa; \`lecodes app upload ios\` sends the archive to App Store Connect.
+
+## Who owns what
+
+Yours — \`lecodes app sync\` never touches these:
+
+- \`App/*.swift\` (AppDelegate, SceneDelegate, ViewController) — customize freely, add files.
+  App-local native code goes here too: add a Swift file that calls
+  \`engine.registerCallback\` / \`registerService\`, and invoke it from ViewController.
+- \`App/Assets.xcassets/\` — drop a 1024×1024 PNG into AppIcon.appiconset/ for the app icon.
+- \`App/Base.lproj/LaunchScreen.storyboard\`
+
+CLI-owned — regenerated on every sync, hand edits are overwritten:
+
+- \`App/Resources/\` — the compiled app.js + every asset it references (fonts included), so
+  the app runs fully offline. Globs in app.json \`"resources": {"remote": [...]}\` opt heavy
+  assets (videos, big models) back into streaming from the server instead.
+- \`App/Info.plist\` — template + the installed plugins' usage keys
+- \`LeCodesRuntime/\` — local Swift package: the LeCodesSDK dependency, vendored plugin
+  sources (Sources/<Module>/), and the registerBundledPlugins entry point
+- the version values inside \`App.xcodeproj/project.pbxproj\` (from app.json)
+- this README
+
+## Config
+
+Identity lives in \`../app.json\` (name, version, plugins, ios.bundleId / teamId / variant /
+buildNumber) — edit it there, then re-run \`lecodes app sync\`. Plugins are managed with
+\`lecodes app plugin add <id | github:owner/repo[@tag]>\` and pinned in \`../plugins.lock.json\`.
+`;
+
+// src/commands/app.ts
+var SDK_PACKAGE_VERSION = "1.0.4";
+var FIRST_PARTY_PLUGINS = {
+  camera: "letary/lecodes-plugins",
+  "qr-scanner": "letary/lecodes-plugins"
+};
+var readJson = (path) => {
+  if (!existsSync8(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync10(path, "utf8"));
+  } catch {
+    throw new CliError(`Invalid JSON in ${path}`);
   }
-  const entries = [];
-  const warnings = [];
-  for (const file of scanLocal(root).files) {
-    const type = manifest.files[file.path]?.type ?? classifyKind(basename(file.path));
-    if (type === "resource") {
-      const src = serverByPath.get(file.path)?.fileSrc;
-      if (!src)
-        warnings.push(`No server URL for ${file.path} — push it so its URL resolves.`);
-      entries.push({ path: file.path, type, fileSrc: src, absPath: file.absPath });
-    } else if (type === "shader") {
-      const shaders = serverByPath.get(file.path)?.shaders;
-      if (!shaders?.length)
-        warnings.push(`No compiled shader for ${file.path} — push it to compile the shader.`);
-      entries.push({ path: file.path, type, shaders });
-    } else {
-      entries.push({ path: file.path, type, text: readFileSync6(file.absPath, "utf8") });
+};
+var writeJson = (path, value) => writeFileSync7(path, JSON.stringify(value, null, 2) + `
+`);
+var projectRoot = () => {
+  try {
+    return findProjectRoot(process.cwd());
+  } catch {
+    return process.cwd();
+  }
+};
+var git = (cwd, ...args) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+var ensureRepo = (repo, wantTag, lock) => {
+  const override = process.env.LECODES_PLUGINS_DIR;
+  if (override) {
+    note(`Using local plugin checkout ${override} (LECODES_PLUGINS_DIR)`);
+    return { dir: resolve2(override), tag: "local", commit: "local" };
+  }
+  const cache = join11(homedir2(), ".lecodes", "plugins", repo.replace("/", "__"));
+  const url = `https://github.com/${repo}.git`;
+  if (!existsSync8(join11(cache, ".git"))) {
+    mkdirSync5(dirname7(cache), { recursive: true });
+    note(`Cloning ${url}…`);
+    git(dirname7(cache), "clone", "--quiet", url, cache);
+  }
+  let tag = lock?.tag ?? wantTag;
+  let commit = lock?.commit;
+  if (commit) {
+    try {
+      git(cache, "cat-file", "-e", `${commit}^{commit}`);
+    } catch {
+      git(cache, "fetch", "--quiet", "--tags", "origin");
+    }
+  } else {
+    git(cache, "fetch", "--quiet", "--tags", "origin");
+    if (!tag) {
+      tag = git(cache, "tag", "--list", "v*", "--sort=-version:refname").split(`
+`)[0] ?? "";
+      if (!tag)
+        throw new CliError(`${repo} has no v* version tags to install from`);
+    }
+    commit = git(cache, "rev-list", "-n", "1", tag);
+  }
+  git(cache, "checkout", "--quiet", "--detach", commit);
+  return { dir: cache, tag: tag ?? "unknown", commit };
+};
+var resolvePlugin = (id, spec, lock) => {
+  let repo;
+  let subdir;
+  let wantTag = null;
+  if (spec.startsWith("github:")) {
+    const [repoPart, tagPart] = spec.slice("github:".length).split("@");
+    repo = repoPart;
+    wantTag = tagPart ?? null;
+    subdir = "";
+  } else {
+    repo = FIRST_PARTY_PLUGINS[id];
+    if (!repo) {
+      throw new CliError(`Unknown plugin "${id}" — known: ${Object.keys(FIRST_PARTY_PLUGINS).join(", ")}, or use a github:owner/repo spec.`);
+    }
+    subdir = `plugins/${id}`;
+  }
+  const checkout = ensureRepo(repo, wantTag, lock?.repo === repo ? lock : undefined);
+  const dir = subdir ? join11(checkout.dir, subdir) : checkout.dir;
+  const manifest = readJson(join11(dir, "lecodes-plugin.json"));
+  if (!manifest)
+    throw new CliError(`Plugin "${id}": no lecodes-plugin.json in ${dir}`);
+  if (manifest.id !== id)
+    throw new CliError(`Plugin "${id}": manifest declares id "${manifest.id}"`);
+  if (!manifest.ios)
+    throw new CliError(`Plugin "${id}" does not support iOS (manifest "ios" is null)`);
+  if (spec.startsWith("github:")) {
+    const names = [...manifest.provides?.views ?? [], ...manifest.provides?.services ?? []];
+    for (const name of names) {
+      if (!name.includes("."))
+        warn(`Plugin "${id}" provides bare channel name "${name}" — third-party names should be vendor-prefixed (e.g. "acme.${name}").`);
     }
   }
-  return { entries, warnings };
+  return {
+    id,
+    dir,
+    manifest,
+    lock: { repo, tag: checkout.tag, commit: checkout.commit, version: manifest.version ?? "unknown" }
+  };
 };
-
-// src/compile/collectLocal.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { basename as basename2 } from "node:path";
-var collectLocalEntries = (root, manifest, assetBase) => {
-  const entries = [];
-  const warnings = [];
-  const scan = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
-  for (const file of scan.files) {
-    const type = manifest?.files[file.path]?.type ?? classifyKind(basename2(file.path));
-    if (type === "resource") {
-      entries.push({ path: file.path, type, fileSrc: assetBase + encodeURI(file.path), absPath: file.absPath });
-    } else if (type === "shader") {
-      warnings.push(`${file.path}: shaders compile on the server — push the project once for shaders to work in dev mode.`);
-      entries.push({ path: file.path, type, shaders: [] });
+var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+var appInit = async (args) => {
+  const platform = args._[1];
+  if (platform !== "ios") {
+    throw new CliError(platform ? `Unsupported platform "${platform}" — only "ios" for now.` : "Usage: lecodes app init ios [--name <display name>] [--bundle-id <id>] [--team <team id>] [--variant core|full]");
+  }
+  const root = projectRoot();
+  const iosDir = join11(root, "ios");
+  if (existsSync8(iosDir)) {
+    throw new CliError("ios/ already exists — run `lecodes app sync` to update it.");
+  }
+  const existing = readJson(join11(root, "app.json")) ?? {};
+  const variant = flagStr(args, "variant") ?? existing.ios?.variant ?? "core";
+  if (variant !== "core" && variant !== "full")
+    throw new CliError(`--variant must be "core" or "full" (got "${variant}")`);
+  const name = flagStr(args, "name") ?? existing.name ?? basename4(root);
+  const config = {
+    ...existing,
+    name,
+    version: existing.version ?? "1.0.0",
+    plugins: existing.plugins ?? {},
+    ios: {
+      bundleId: flagStr(args, "bundle-id") ?? existing.ios?.bundleId ?? `com.example.${slugify(name)}`,
+      teamId: flagStr(args, "team") ?? existing.ios?.teamId ?? "",
+      variant,
+      buildNumber: existing.ios?.buildNumber ?? 1
+    }
+  };
+  writeJson(join11(root, "app.json"), config);
+  log(`${c.green("written")}   app.json`);
+  const ignorePath = join11(root, ".lecodesignore");
+  const ignore = existsSync8(ignorePath) ? readFileSync10(ignorePath, "utf8") : DEFAULT_IGNORE_FILE;
+  if (!/^ios\/$/m.test(ignore)) {
+    writeFileSync7(ignorePath, ignore.replace(/\n*$/, `
+`) + `
+# Native app shells — generated by \`lecodes app init\`, never pushed to LeCodes.
+ios/
+`);
+    log(`${c.green("updated")}   .lecodesignore  (+ ios/)`);
+  }
+  const identity = {
+    displayName: name,
+    bundleId: config.ios.bundleId,
+    teamId: config.ios.teamId,
+    version: config.version,
+    buildNumber: config.ios.buildNumber
+  };
+  const write = (rel, content) => {
+    const abs = join11(iosDir, rel);
+    mkdirSync5(dirname7(abs), { recursive: true });
+    writeFileSync7(abs, content);
+    log(`${c.green("created")}   ios/${rel}`);
+  };
+  write("README.md", IOS_README);
+  write("App.xcodeproj/project.pbxproj", pbxprojTemplate(identity));
+  write("App.xcodeproj/xcshareddata/xcschemes/App.xcscheme", SCHEME_XML);
+  write("App/AppDelegate.swift", APP_DELEGATE);
+  write("App/SceneDelegate.swift", SCENE_DELEGATE);
+  write("App/ViewController.swift", VIEW_CONTROLLER);
+  write("App/Info.plist", infoPlistTemplate({}));
+  write("App/Base.lproj/LaunchScreen.storyboard", LAUNCH_STORYBOARD);
+  write("App/Assets.xcassets/Contents.json", ASSETS_ROOT_JSON);
+  write("App/Assets.xcassets/AccentColor.colorset/Contents.json", ACCENT_COLOR_JSON);
+  write("App/Assets.xcassets/AppIcon.appiconset/Contents.json", APP_ICON_JSON);
+  write("LeCodesRuntime/Package.swift", runtimePackageTemplate(SDK_PACKAGE_VERSION, variant, []));
+  write("LeCodesRuntime/Sources/LeCodesRuntime/LeCodesRuntime.swift", runtimeSwiftTemplate([]));
+  log("");
+  success(`iOS shell for ${c.bold(name)} ready.`);
+  log(`  ${c.bold("lecodes app sync")}          embed the compiled bundle (+ plugins) into the shell`);
+  log(`  ${c.bold("open ios/App.xcodeproj")}    then run on your device from Xcode`);
+  log(`  App icon: drop a 1024×1024 PNG into ios/App/Assets.xcassets/AppIcon.appiconset/`);
+};
+var appSync = async (_args) => {
+  const root = projectRoot();
+  const config = readJson(join11(root, "app.json"));
+  const iosDir = join11(root, "ios");
+  if (!config?.ios || !existsSync8(iosDir)) {
+    throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
+  }
+  const variant = config.ios.variant === "full" ? "full" : "core";
+  const lockPath = join11(root, "plugins.lock.json");
+  const oldLock = readJson(lockPath)?.plugins ?? {};
+  const pluginSpecs = Object.entries(config.plugins ?? {});
+  const runtimePlugins = [];
+  const infoValues = {};
+  const newLock = {};
+  const sourcesDir = join11(iosDir, "LeCodesRuntime", "Sources");
+  for (const [id, spec] of pluginSpecs) {
+    const plugin = resolvePlugin(id, spec, oldLock[id]);
+    const ios = plugin.manifest.ios;
+    const module = ios.module;
+    const register = ios.register;
+    if (!module || !register)
+      throw new CliError(`Plugin "${id}": manifest ios.module / ios.register missing`);
+    const src = join11(plugin.dir, ios.sources ?? "ios");
+    if (!existsSync8(src))
+      throw new CliError(`Plugin "${id}": sources dir ${src} missing`);
+    const dest = join11(sourcesDir, module);
+    rmSync(dest, { recursive: true, force: true });
+    cpSync(src, dest, { recursive: true });
+    for (const [key, value] of Object.entries(ios.infoPlist ?? {})) {
+      (infoValues[key] ??= []).push(value);
+    }
+    runtimePlugins.push({ id, module, register });
+    newLock[id] = plugin.lock;
+    log(`${c.green("plugin")}    ${id}@${plugin.lock.version} (${plugin.lock.tag} → Sources/${module})`);
+  }
+  const keep = new Set(["LeCodesRuntime", ...runtimePlugins.map((p) => p.module)]);
+  for (const entry of existsSync8(sourcesDir) ? readdirSync4(sourcesDir) : []) {
+    if (!keep.has(entry) && statSync2(join11(sourcesDir, entry)).isDirectory()) {
+      rmSync(join11(sourcesDir, entry), { recursive: true });
+      log(`${c.yellow("removed")}   ios/LeCodesRuntime/Sources/${entry}  (plugin uninstalled)`);
+    }
+  }
+  writeFileSync7(join11(iosDir, "README.md"), IOS_README);
+  writeFileSync7(join11(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(SDK_PACKAGE_VERSION, variant, runtimePlugins));
+  writeFileSync7(join11(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins));
+  const mergedKeys = {};
+  for (const [key, values] of Object.entries(infoValues))
+    mergedKeys[key] = [...new Set(values)].join(" ");
+  writeFileSync7(join11(iosDir, "App", "Info.plist"), infoPlistTemplate(mergedKeys));
+  if (pluginSpecs.length > 0 || existsSync8(lockPath))
+    writeJson(lockPath, { plugins: newLock });
+  const pbxPath = join11(iosDir, "App.xcodeproj", "project.pbxproj");
+  const pbx = readFileSync10(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};`);
+  writeFileSync7(pbxPath, pbx);
+  const remotePatterns = config.resources?.remote ?? [];
+  if (!Array.isArray(remotePatterns) || remotePatterns.some((p) => typeof p !== "string")) {
+    throw new CliError('app.json "resources.remote" must be an array of glob strings (e.g. ["videos/**"]).');
+  }
+  const resourcesDir = join11(iosDir, "App", "Resources");
+  rmSync(resourcesDir, { recursive: true, force: true });
+  mkdirSync5(resourcesDir, { recursive: true });
+  const resources = await compileShell({ _: [], flags: { o: join11(resourcesDir, "app.js") } }, { remotePatterns });
+  const bundleJs = readFileSync10(join11(resourcesDir, "app.js"), "utf8");
+  const preload = /^\/\/ preload: (.*)$/m.exec(bundleJs)?.[1].split(";").map((s) => s.trim()).filter(Boolean) ?? [];
+  const IMPLICIT_PRELOADS = new Set(["uberarchive", "capture"]);
+  const byName = new Map;
+  for (const r of resources) {
+    if (r.remote || !r.absPath)
+      continue;
+    const list = byName.get(r.name) ?? [];
+    list.push(r);
+    byName.set(r.name, list);
+  }
+  let embedded = 0;
+  for (const name of preload) {
+    if (IMPLICIT_PRELOADS.has(name))
+      continue;
+    const candidates = byName.get(name) ?? [];
+    if (candidates.length === 0) {
+      warn(`bundle needs local asset "${name}" but no project file provides it — it won't load on device`);
+      continue;
+    }
+    if (candidates.length > 1)
+      warn(`asset name collision: ${name} (${candidates.map((r) => r.path).join(", ")}) — embedding ${candidates[0].path}`);
+    cpSync(candidates[0].absPath, join11(resourcesDir, name));
+    embedded++;
+  }
+  if (embedded > 0)
+    log(`${c.green("assets")}    ${embedded} file(s) embedded → ios/App/Resources/`);
+  const streamed = resources.filter((r) => r.remote);
+  if (streamed.length > 0)
+    log(`${c.green("remote")}    ${streamed.length} resource(s) stay on the server (resources.remote): ${streamed.map((r) => r.path).join(", ")}`);
+  log("");
+  success(`Shell synced: app.js + ${runtimePlugins.length} plugin(s), variant ${variant}, v${config.version ?? "1.0.0"} (${config.ios.buildNumber ?? 1}).`);
+  note("Build & run from Xcode (open ios/App.xcodeproj) — user files in ios/App/*.swift were not touched.");
+};
+var appPlugin = async (args) => {
+  const sub = args._[1];
+  const root = projectRoot();
+  const configPath = join11(root, "app.json");
+  const config = readJson(configPath);
+  if (!config)
+    throw new CliError("No app.json here — run `lecodes app init ios` first.");
+  config.plugins ??= {};
+  if (sub === "list" || sub === undefined) {
+    const entries = Object.entries(config.plugins);
+    if (entries.length === 0) {
+      log("No plugins installed.");
+      return;
+    }
+    const lock = readJson(join11(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}`);
+    }
+    return;
+  }
+  const id = args._[2];
+  if (!id)
+    throw new CliError(`Usage: lecodes app plugin ${sub} <id | github:owner/repo[@tag]>`);
+  if (sub === "add") {
+    if (id.startsWith("github:")) {
+      const bare = id.slice("github:".length).split("@")[0].split("/").pop();
+      config.plugins[bare] = id;
+      log(`${c.green("added")}     ${bare} → ${id}  ${c.dim("(third-party native code — review it before shipping)")}`);
+    } else if (FIRST_PARTY_PLUGINS[id]) {
+      config.plugins[id] = "*";
+      log(`${c.green("added")}     ${id}`);
     } else {
-      entries.push({ path: file.path, type, text: readFileSync7(file.absPath, "utf8") });
+      throw new CliError(`Unknown plugin "${id}" — known: ${Object.keys(FIRST_PARTY_PLUGINS).join(", ")}, or use github:owner/repo[@tag].`);
     }
+    writeJson(configPath, config);
+    note("Run `lecodes app sync` to vendor it into the shell.");
+    return;
   }
-  return { entries, warnings };
+  if (sub === "remove") {
+    if (!(id in config.plugins))
+      throw new CliError(`Plugin "${id}" is not installed.`);
+    delete config.plugins[id];
+    writeJson(configPath, config);
+    log(`${c.yellow("removed")}   ${id}`);
+    note("Run `lecodes app sync` to drop its sources from the shell.");
+    return;
+  }
+  throw new CliError(`Unknown subcommand "plugin ${sub}" — use list, add or remove.`);
 };
-
-// src/compile/projectCompile.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname6, join as join10 } from "node:path";
-init_compile();
-var vendoredInject = join10(distRoot, "runtime", "sdk", "inject.ts");
-if (existsSync8(vendoredInject))
-  process.env.LECODES_SDK_INJECT = vendoredInject;
-var resolveChiselBin2 = () => {
-  if (process.env.LECODES_CHISEL_BIN)
-    return process.env.LECODES_CHISEL_BIN;
+var runTool = (cwd, cmd, args) => {
   try {
-    const fromPkg = createRequire3(import.meta.url)("@letary/chisel").binaryPath();
-    if (fromPkg)
-      return fromPkg;
+    return execFileSync(cmd, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 128 * 1024 * 1024 });
+  } catch (e) {
+    const err = e;
+    const tail = ((err.stdout ?? "") + `
+` + (err.stderr ?? "")).split(`
+`).filter((l) => l.trim()).slice(-25).join(`
+`);
+    throw new CliError(`${cmd} ${args[0] ?? ""} failed:
+${tail}`);
+  }
+};
+var exportOptionsPlist = (method, teamId, destination) => `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>method</key>
+	<string>${method}</string>
+	<key>signingStyle</key>
+	<string>automatic</string>${teamId ? `
+	<key>teamID</key>
+	<string>${teamId}</string>` : ""}${destination ? `
+	<key>destination</key>
+	<string>${destination}</string>` : ""}
+</dict>
+</plist>
+`;
+var requireShell = () => {
+  const root = projectRoot();
+  const config = readJson(join11(root, "app.json"));
+  if (!config?.ios || !existsSync8(join11(root, "ios"))) {
+    throw new CliError("No iOS shell here — run `lecodes app init ios` first.");
+  }
+  return { root, config };
+};
+var appDoctor = async (_args) => {
+  const { root, config } = requireShell();
+  let failed = 0;
+  const check = (ok, label, hint = "", fatal = true) => {
+    log(`${ok ? c.green("✓") : fatal ? c.red("✗") : c.yellow("!")} ${label}${ok || !hint ? "" : c.dim("  — " + hint)}`);
+    if (!ok && fatal)
+      failed++;
+  };
+  let xcodeVersion = "";
+  try {
+    xcodeVersion = runTool(root, "xcodebuild", ["-version"]).split(`
+`)[0];
   } catch {}
-  const local = join10(dirname6(process.execPath), process.platform === "win32" ? "chisel.exe" : "chisel");
-  return existsSync8(local) ? local : null;
+  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 = join11(root, "ios", "App", "Assets.xcassets", "AppIcon.appiconset");
+  const hasIcon = existsSync8(iconDir) && readdirSync4(iconDir).some((f2) => f2.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 = join11(root, "ios", "App", "Resources", "app.js");
+  check(existsSync8(bundle), "Bundled app.js", "run `lecodes app sync`");
+  const lock = readJson(join11(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 asc = readJson(join11(homedir2(), ".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);
+  log("");
+  if (failed > 0)
+    throw new CliError(`${failed} check(s) failed.`);
+  success("Ready to build.");
+};
+var ARCHIVE_PATH = "ios/build/App.xcarchive";
+var appBuild = async (args) => {
+  const { root, config } = requireShell();
+  const configuration = flagStr(args, "configuration") ?? "Release";
+  const method = flagStr(args, "method") ?? "app-store-connect";
+  if (!flagBool(args, "no-sync"))
+    await appSync({ _: [], flags: {} });
+  note(`Archiving (${configuration})… this takes a few minutes`);
+  runTool(root, "xcodebuild", [
+    "-project",
+    "ios/App.xcodeproj",
+    "-scheme",
+    "App",
+    "-destination",
+    "generic/platform=iOS",
+    "-configuration",
+    configuration,
+    "archive",
+    "-archivePath",
+    ARCHIVE_PATH,
+    "-allowProvisioningUpdates"
+  ]);
+  success(`Archive: ios/build/App.xcarchive`);
+  if (flagBool(args, "no-export"))
+    return;
+  const optionsPath = join11(root, "ios", "build", "ExportOptions.plist");
+  writeFileSync7(optionsPath, exportOptionsPlist(method, config.ios.teamId ?? ""));
+  note(`Exporting (.ipa, method ${method})…`);
+  runTool(root, "xcodebuild", [
+    "-exportArchive",
+    "-archivePath",
+    ARCHIVE_PATH,
+    "-exportOptionsPlist",
+    optionsPath,
+    "-exportPath",
+    "ios/build/export",
+    "-allowProvisioningUpdates"
+  ]);
+  success("Export: ios/build/export/  — upload with `lecodes app upload ios`");
+};
+var appUpload = async (args) => {
+  const { root, config } = requireShell();
+  if (!existsSync8(join11(root, ARCHIVE_PATH))) {
+    throw new CliError("No archive at ios/build/App.xcarchive — run `lecodes app build ios` first.");
+  }
+  const ascPath = join11(homedir2(), ".lecodes", "asc.json");
+  const stored = readJson(ascPath) ?? {};
+  const keyPath = flagStr(args, "key-path") ?? stored.keyPath;
+  const keyId = flagStr(args, "key-id") ?? stored.keyId;
+  const issuerId = flagStr(args, "issuer-id") ?? stored.issuerId;
+  if (!keyPath || !keyId || !issuerId) {
+    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 (!existsSync8(keyPath))
+    throw new CliError(`API key file not found: ${keyPath}`);
+  if (flagStr(args, "key-path")) {
+    mkdirSync5(dirname7(ascPath), { recursive: true });
+    writeJson(ascPath, { keyPath, keyId, issuerId });
+    note("Stored the key reference in ~/.lecodes/asc.json");
+  }
+  const optionsPath = join11(root, "ios", "build", "UploadOptions.plist");
+  writeFileSync7(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",
+    "-archivePath",
+    ARCHIVE_PATH,
+    "-exportOptionsPlist",
+    optionsPath,
+    "-exportPath",
+    "ios/build/upload",
+    "-authenticationKeyPath",
+    resolve2(keyPath),
+    "-authenticationKeyID",
+    keyId,
+    "-authenticationKeyIssuerID",
+    issuerId,
+    "-allowProvisioningUpdates"
+  ]);
+  const configPath = join11(root, "app.json");
+  const fresh = readJson(configPath);
+  fresh.ios.buildNumber = (fresh.ios.buildNumber ?? 1) + 1;
+  writeJson(configPath, fresh);
+  success(`Uploaded build ${(fresh.ios.buildNumber ?? 2) - 1} — check App Store Connect / TestFlight once processing finishes.`);
+  note(`ios.buildNumber bumped to ${fresh.ios.buildNumber} for the next build.`);
+};
+var appOpen = async (args) => {
+  const root = projectRoot();
+  const platform = args._[1] ?? "ios";
+  if (platform === "ios") {
+    const proj = join11(root, "ios", "App.xcodeproj");
+    if (!existsSync8(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.");
+    execFileSync("open", [proj], { stdio: "ignore" });
+    success("Opened ios/App.xcodeproj in Xcode.");
+    return;
+  }
+  if (platform === "android") {
+    throw new CliError("Android shells don't exist yet — `lecodes app open` covers ios for now.");
+  }
+  throw new CliError(`Unknown platform "${platform}" — use ios.`);
+};
+var app = async (args) => {
+  const sub = args._[0];
+  if (sub === "init")
+    return appInit(args);
+  if (sub === "sync")
+    return appSync(args);
+  if (sub === "plugin")
+    return appPlugin(args);
+  if (sub === "doctor")
+    return appDoctor(args);
+  if (sub === "build")
+    return appBuild(args);
+  if (sub === "upload")
+    return appUpload(args);
+  if (sub === "open")
+    return appOpen(args);
+  throw new CliError("Usage: lecodes app <init ios | sync | open | plugin list|add|remove | doctor | build ios | upload ios> — see `lecodes help`.");
 };
-var chiselBin = resolveChiselBin2();
-if (chiselBin)
-  process.env.LECODES_CHISEL_BIN = chiselBin;
-var compileProject2 = (opts) => compileProject({
-  entries: opts.entries.map((e) => ({ path: e.path, type: e.type, text: e.text, fileSrc: e.fileSrc, shaders: e.shaders })),
-  name: opts.name,
-  publicUrl: opts.publicUrl,
-  entryOverride: opts.entryOverride,
-  header: opts.header,
-  format: opts.format,
-  localAssets: opts.localAssets,
-  minify: opts.minify,
-  sourcemap: opts.sourcemap,
-  editor: opts.editor
-});
 
-// src/commands/compile.ts
-var compile2 = async (args) => {
-  let root;
-  let manifest;
-  try {
-    root = findProjectRoot(process.cwd());
-    manifest = readManifest(root);
-  } catch {
-    root = process.cwd();
-    manifest = null;
-  }
-  let entries;
-  let warnings;
-  let name;
-  let publicUrl;
-  let localAssets = false;
-  if (manifest) {
-    const config = loadConfig();
-    const apiUrl = requireApiUrl(config);
-    const token = requireToken(config);
-    note("Resolving project assets…");
-    const project = await getProject(apiUrl, token, manifest.uuid);
-    ({ entries, warnings } = collectEntries(root, manifest, project));
-    name = manifest.name;
-    publicUrl = flagStr(args, "public-url") ?? apiUrl;
-  } else {
-    const publicUrlFlag = flagStr(args, "public-url");
-    localAssets = publicUrlFlag === undefined;
-    publicUrl = publicUrlFlag ?? "";
-    ({ entries, warnings } = collectLocalEntries(root, null, publicUrl));
-    name = basename3(root);
+// src/commands/clone.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+
+// src/types.ts
+import { dirname as dirname8, join as join12 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+var TSCONFIG = {
+  compilerOptions: {
+    target: "ES2020",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    lib: ["ES2020"],
+    types: [],
+    allowJs: true,
+    checkJs: false,
+    strict: false,
+    noEmit: true,
+    skipLibCheck: true
+  },
+  include: [`${LECODES_DIR}/types/**/*.d.ts`, "**/*.ts", "**/*.js"],
+  exclude: ["node_modules"]
+};
+var writeTypeBundle = (root, bundle) => {
+  const typesDir = join12(root, LECODES_DIR, "types");
+  for (const [path, text] of Object.entries(bundle)) {
+    const dest = join12(typesDir, path);
+    mkdirSync6(dirname8(dest), { recursive: true });
+    writeFileSync8(dest, text);
   }
-  note("Compiling…");
-  const js = await compileProject2({
-    entries,
-    name,
-    publicUrl,
-    entryOverride: flagStr(args, "entry"),
-    header: !flagBool(args, "no-header"),
-    localAssets,
-    minify: flagBool(args, "no-minify") ? false : undefined,
-    sourcemap: flagBool(args, "no-sourcemap", "no-source-map") ? false : undefined
-  });
-  for (const w of warnings)
-    warnErr(w);
-  const out = flagStr(args, "o", "out");
-  if (out && isNullSink(out)) {
-    note(`Discarded output (${out})`);
-  } else if (out) {
-    writeFileSync6(resolve2(out), js);
-    note(`Wrote ${out} (${js.length} bytes)`);
-  } else {
-    process.stdout.write(js);
-    if (!js.endsWith(`
-`))
-      process.stdout.write(`
-`);
+};
+var materializeTypes = async (root, apiUrl) => {
+  writeTypeBundle(root, await getTypes(apiUrl));
+};
+var readLocalTypeBundle = () => {
+  const candidates = [
+    join12(distRoot, "runtime", "sdk-types.json"),
+    join12(distRoot, "..", "sdk", "dist", "types.json")
+  ];
+  for (const path of candidates) {
+    if (existsSync9(path)) {
+      try {
+        return JSON.parse(readFileSync11(path, "utf8"));
+      } catch {}
+    }
   }
+  return null;
 };
-var previewLegacy = async (args) => {
-  warnErr("'lecodes preview' is now 'lecodes compile' — the old name still works.");
-  await compile2(args);
+var materializeTypesLocal = (root) => {
+  const bundle = readLocalTypeBundle();
+  if (!bundle)
+    return false;
+  writeTypeBundle(root, bundle);
+  return true;
+};
+var writeTsconfig = (root) => {
+  writeFileSync8(join12(root, "tsconfig.json"), JSON.stringify(TSCONFIG, null, 2));
+};
+
+// src/commands/clone.ts
+var parseUuid = (input) => {
+  if (!input)
+    throw new CliError("Usage: lecodes clone <project-uuid|url> [directory]");
+  if (!input.includes("/"))
+    return input;
+  const clean = input.split(/[?#]/)[0].replace(/\/+$/, "");
+  const match = clean.match(/\/(?:projects|view)\/([^/]+)/);
+  return match ? match[1] : clean.slice(clean.lastIndexOf("/") + 1);
+};
+var slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+var clone = async (args) => {
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  const uuid = parseUuid(args._[0]);
+  const project = await getProject(apiUrl, token, uuid);
+  const dir = args._[1] ?? slug(project.name);
+  const root = resolve3(dir);
+  if (existsSync10(root) && readdirSync5(root).length > 0) {
+    throw new CliError(`Directory "${dir}" already exists and is not empty.`);
+  }
+  mkdirSync7(root, { recursive: true });
+  info(c.dim(`Fetching project ${c.bold(project.name)}…`));
+  const files = await materializeAssets(root, project, apiUrl, token, progress);
+  endProgress();
+  if (!flagBool(args, "no-types")) {
+    info(c.dim("Fetching type definitions…"));
+    await materializeTypes(root, apiUrl);
+    writeTsconfig(root);
+  }
+  writeDefaultIgnore(root);
+  const commits = await getCommits(apiUrl, token, uuid);
+  writeManifest(root, { uuid, apiUrl, name: project.name, baseHeadId: commits.headId, files });
+  success(`Cloned ${c.bold(project.name)} into ${c.bold(dir)}/ (${Object.keys(files).length} files)`);
+  info(c.dim(`  cd ${dir} — edit, then \`lecodes push -m "your message"\``));
 };
 
 // src/commands/create.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join11, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join13, resolve as resolve4 } from "node:path";
 var slug2 = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "project";
 var STARTER = `// Welcome to le.codes — no imports needed, the whole SDK is available as globals.
 const scene = new Scene2D({ background: '#10131a' })
@@ -2281,18 +4201,18 @@ var create = async (args) => {
   if (!name)
     throw new CliError("Usage: lecodes create <name> [directory]");
   const dir = args._[1] ?? slug2(name);
-  const root = resolve3(dir);
-  if (existsSync9(root) && readdirSync5(root).length > 0) {
+  const root = resolve4(dir);
+  if (existsSync11(root) && readdirSync6(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
-  mkdirSync6(root, { recursive: true });
+  mkdirSync8(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);
-  writeFileSync7(join11(root, "main.ts"), STARTER);
+  writeFileSync9(join13(root, "main.ts"), STARTER);
   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)}/`);
@@ -2300,22 +4220,22 @@ var create = async (args) => {
 };
 
 // src/commands/design.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync9, appendFileSync } from "node:fs";
-import { basename as basename5, join as join13 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync7, writeFileSync as writeFileSync11, appendFileSync } from "node:fs";
+import { basename as basename6, join as join15 } from "node:path";
 
 // src/compile/designCompile.ts
-import { readFileSync as readFileSync11 } from "node:fs";
-import { basename as basename4 } from "node:path";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { basename as basename5 } from "node:path";
 
 // src/compile/assetIcons.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, join as join12 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname9, join as join14 } from "node:path";
 var DEFAULT_REGISTRY = process.env.LECODES_ICON_REGISTRY?.trim() || "https://icon-registry.jt3.ru/v1";
 var ICON_ID = /^([a-z0-9]+(?:-[a-z0-9]+)*):([a-z0-9]+(?:-[a-z0-9]+)*)$/;
-var isIdentStart = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$";
-var isIdentPart = (c2) => isIdentStart(c2) || c2 >= "0" && c2 <= "9";
-var skipString = (src, start) => {
+var isIdentStart2 = (c2) => c2 >= "A" && c2 <= "Z" || c2 >= "a" && c2 <= "z" || c2 === "_" || c2 === "$";
+var isIdentPart2 = (c2) => isIdentStart2(c2) || c2 >= "0" && c2 <= "9";
+var skipString2 = (src, start) => {
   const quote = src[start];
   const n = src.length;
   let i = start + 1;
@@ -2326,7 +4246,7 @@ var skipString = (src, start) => {
       continue;
     }
     if (quote === "`" && c2 === "$" && src[i + 1] === "{") {
-      i = skipBraces(src, i + 1);
+      i = skipBraces2(src, i + 1);
       continue;
     }
     if (c2 === quote)
@@ -2335,14 +4255,14 @@ var skipString = (src, start) => {
   }
   return n;
 };
-var skipBraces = (src, open) => {
+var skipBraces2 = (src, open) => {
   const n = src.length;
   let depth = 0;
   let i = open;
   while (i < n) {
     const c2 = src[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(src, i);
+      i = skipString2(src, i);
       continue;
     }
     if (c2 === "{")
@@ -2356,14 +4276,14 @@ var skipBraces = (src, open) => {
   }
   return n;
 };
-var matchParen = (src, open) => {
+var matchParen2 = (src, open) => {
   const n = src.length;
   let depth = 0;
   let i = open;
   while (i < n) {
     const c2 = src[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(src, i);
+      i = skipString2(src, i);
       continue;
     }
     if (c2 === "/" && src[i + 1] === "/") {
@@ -2391,7 +4311,7 @@ var matchParen = (src, open) => {
   }
   return -1;
 };
-var splitTopLevel = (text, delim) => {
+var splitTopLevel2 = (text, delim) => {
   const parts = [];
   const n = text.length;
   let depth = 0;
@@ -2400,7 +4320,7 @@ var splitTopLevel = (text, delim) => {
   while (i < n) {
     const c2 = text[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(text, i);
+      i = skipString2(text, i);
       continue;
     }
     if (c2 === "(" || c2 === "[" || c2 === "{")
@@ -2416,7 +4336,7 @@ var splitTopLevel = (text, delim) => {
   parts.push(text.slice(last));
   return parts;
 };
-var stringLiteralValue = (text) => {
+var stringLiteralValue2 = (text) => {
   const t = text.trim();
   if (t.length < 2)
     return null;
@@ -2437,7 +4357,7 @@ var scanAssetIconCalls = (source) => {
   while (i < n) {
     const c2 = source[i];
     if (c2 === '"' || c2 === "'" || c2 === "`") {
-      i = skipString(source, i);
+      i = skipString2(source, i);
       continue;
     }
     if (c2 === "/" && source[i + 1] === "/") {
@@ -2454,12 +4374,12 @@ var scanAssetIconCalls = (source) => {
       i += 2;
       continue;
     }
-    if (isIdentStart(c2)) {
+    if (isIdentStart2(c2)) {
       let j = i + 1;
-      while (j < n && isIdentPart(source[j]))
+      while (j < n && isIdentPart2(source[j]))
         j++;
-      if (source.slice(i, j) === "assetIcon" && prevNonSpace(source, i) !== ".") {
-        const call = parseCall(source, i, j);
+      if (source.slice(i, j) === "assetIcon" && prevNonSpace2(source, i) !== ".") {
+        const call = parseCall2(source, i, j);
         if (call) {
           calls.push(call);
           i = call.end;
@@ -2473,25 +4393,25 @@ var scanAssetIconCalls = (source) => {
   }
   return calls;
 };
-var prevNonSpace = (src, i) => {
+var prevNonSpace2 = (src, i) => {
   let k = i - 1;
   while (k >= 0 && /\s/.test(src[k]))
     k--;
   return k >= 0 ? src[k] : "";
 };
-var parseCall = (src, start, identEnd) => {
+var parseCall2 = (src, start, identEnd) => {
   const n = src.length;
   let i = identEnd;
   while (i < n && /\s/.test(src[i]))
     i++;
   if (src[i] !== "(")
     return null;
-  const close = matchParen(src, i);
+  const close = matchParen2(src, i);
   if (close === -1)
     return null;
   const call = { start, end: close + 1, id: "", pack: "", name: "" };
-  const args = splitTopLevel(src.slice(i + 1, close), ",");
-  const id = stringLiteralValue(args[0] ?? "");
+  const args = splitTopLevel2(src.slice(i + 1, close), ",");
+  const id = stringLiteralValue2(args[0] ?? "");
   if (id === null) {
     call.error = `assetIcon(...) needs a string-literal id like "lucide:bell" (got \`${(args[0] ?? "").trim() || "()"}\`).`;
     return call;
@@ -2522,8 +4442,8 @@ var extractColor = (optsText) => {
   if (!optsText.startsWith("{") || !optsText.endsWith("}")) {
     return { error: `assetIcon(id, opts): opts must be an object literal like { color: "#5b8cff" }.` };
   }
-  for (const prop of splitTopLevel(optsText.slice(1, -1), ",")) {
-    const kv = splitTopLevel(prop, ":");
+  for (const prop of splitTopLevel2(optsText.slice(1, -1), ",")) {
+    const kv = splitTopLevel2(prop, ":");
     if (kv.length < 2)
       continue;
     const key = kv[0].trim().replace(/^["'`]|["'`]$/g, "");
@@ -2532,7 +4452,7 @@ var extractColor = (optsText) => {
     const raw = kv.slice(1).join(":").trim();
     if (!raw)
       continue;
-    const literal = stringLiteralValue(raw);
+    const literal = stringLiteralValue2(raw);
     return literal !== null ? { bake: literal } : { tint: raw };
   }
   return {};
@@ -2553,34 +4473,34 @@ var iconExpr = (svg, call) => {
   return call.tint ? `Object.assign(${src}, { tintColor: (${call.tint}) })` : src;
 };
 var escapeTemplate = (s) => s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-var isHttp = (s) => /^https?:/i.test(s);
-var sha12 = (s) => createHash2("sha256").update(s).digest("hex").slice(0, 12);
-var registryHome = (registry) => registry.replace(/\/v\d+$/, "");
+var isHttp2 = (s) => /^https?:/i.test(s);
+var sha122 = (s) => createHash3("sha256").update(s).digest("hex").slice(0, 12);
+var registryHome2 = (registry) => registry.replace(/\/v\d+$/, "");
 var readText = async (registry, rel) => {
-  if (isHttp(registry)) {
+  if (isHttp2(registry)) {
     const res = await fetch(`${registry}/${rel}`);
     return res.ok ? await res.text() : null;
   }
   try {
-    return readFileSync10(join12(registry, rel), "utf8");
+    return readFileSync12(join14(registry, rel), "utf8");
   } catch {
     return null;
   }
 };
-var readLock = (path) => {
+var readLock2 = (path) => {
   try {
-    const lock = JSON.parse(readFileSync10(path, "utf8"));
+    const lock = JSON.parse(readFileSync12(path, "utf8"));
     if (lock && typeof lock === "object" && lock.icons && lock.packs)
       return lock;
   } catch {}
   return null;
 };
-var serializeLock = (lock) => {
+var serializeLock2 = (lock) => {
   const sortKeys = (rec) => Object.fromEntries(Object.keys(rec).sort().map((k) => [k, rec[k]]));
   return JSON.stringify({ registry: lock.registry, icons: sortKeys(lock.icons), packs: sortKeys(lock.packs) }, null, 2) + `
 `;
 };
-var renderNotices = (lock) => {
+var renderNotices2 = (lock) => {
   const packs = [...new Set(Object.values(lock.icons).map((i) => i.pack))].sort();
   const lines = [
     "# Icon attribution & notices",
@@ -2605,29 +4525,29 @@ var renderNotices = (lock) => {
   return lines.join(`
 `);
 };
-var writeIfChanged = (path, text) => {
-  const current = existsSync10(path) ? safeRead(path) : null;
+var writeIfChanged2 = (path, text) => {
+  const current = existsSync12(path) ? safeRead(path) : null;
   if (current === text)
     return false;
-  writeFileSync8(path, text);
+  writeFileSync10(path, text);
   return true;
 };
 var safeRead = (path) => {
   try {
-    return readFileSync10(path, "utf8");
+    return readFileSync12(path, "utf8");
   } catch {
     return null;
   }
 };
 var vendorIcons = async (designDir, ids, opts = {}) => {
   const registry = (opts.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
-  const lockPath = join12(designDir, "icons.lock.json");
-  const lock = readLock(lockPath) ?? { registry, icons: {}, packs: {} };
+  const lockPath = join14(designDir, "icons.lock.json");
+  const lock = readLock2(lockPath) ?? { registry, icons: {}, packs: {} };
   const svgById = new Map;
   const missing = [];
   for (const id of ids) {
     const li = lock.icons[id];
-    const cached = li && safeRead(join12(designDir, li.path));
+    const cached = li && safeRead(join14(designDir, li.path));
     if (cached)
       svgById.set(id, cached);
     else
@@ -2643,23 +4563,23 @@ var vendorIcons = async (designDir, ids, opts = {}) => {
       const [, pack, name] = m;
       const lic = licenses[pack];
       if (!lic)
-        throw new Error(`assetIcon: unknown icon pack "${pack}" (in "${id}"). Browse packs at ${registryHome(registry)}.`);
+        throw new Error(`assetIcon: unknown icon pack "${pack}" (in "${id}"). Browse packs at ${registryHome2(registry)}.`);
       const svg = await readText(registry, `${pack}/${name}.svg`);
       if (svg === null)
-        throw new Error(`assetIcon: icon "${id}" not found in the registry. Check the name at ${registryHome(registry)}.`);
+        throw new Error(`assetIcon: icon "${id}" not found in the registry. Check the name at ${registryHome2(registry)}.`);
       const rel = `assets/icons/${pack}/${name}.svg`;
-      const abs = join12(designDir, rel);
-      mkdirSync7(dirname7(abs), { recursive: true });
-      writeFileSync8(abs, svg);
-      lock.icons[id] = { pack, name, hash: sha12(svg), spdx: lic.spdx, path: rel };
+      const abs = join14(designDir, rel);
+      mkdirSync9(dirname9(abs), { recursive: true });
+      writeFileSync10(abs, svg);
+      lock.icons[id] = { pack, name, hash: sha122(svg), spdx: lic.spdx, path: rel };
       lock.packs[pack] = { spdx: lic.spdx, title: lic.title, url: lic.url, attribution: lic.attribution, modifiedNotice: lic.modifiedNotice };
       svgById.set(id, svg);
     }
     lock.registry = registry;
-    writeIfChanged(lockPath, serializeLock(lock));
+    writeIfChanged2(lockPath, serializeLock2(lock));
   }
   if (Object.keys(lock.icons).length)
-    writeIfChanged(join12(designDir, "ICON-NOTICES.md"), renderNotices(lock));
+    writeIfChanged2(join14(designDir, "ICON-NOTICES.md"), renderNotices2(lock));
   return svgById;
 };
 var applyAssetIcons = async (entries, designDir, opts = {}) => {
@@ -2683,7 +4603,7 @@ var compileDesignScreen = async (opts) => {
   const entries = [];
   const scan = scanLocal(root, { ignore: loadIgnore(root), tracked: new Set(Object.keys(manifest?.files ?? {})) });
   for (const file of scan.files) {
-    const type = manifest?.files[file.path]?.type ?? classifyKind(basename4(file.path));
+    const type = manifest?.files[file.path]?.type ?? classifyKind(basename5(file.path));
     if (type === "resource") {
       entries.push({
         path: file.path,
@@ -2694,7 +4614,7 @@ var compileDesignScreen = async (opts) => {
     } else if (type === "shader") {
       entries.push({ path: file.path, type, shaders: [] });
     } else {
-      entries.push({ path: file.path, type, text: readFileSync11(file.absPath, "utf8") });
+      entries.push({ path: file.path, type, text: readFileSync13(file.absPath, "utf8") });
     }
   }
   const invoke = state !== undefined ? `screen(${JSON.stringify(state)})` : "screen()";
@@ -2708,6 +4628,18 @@ var compileDesignScreen = async (opts) => {
 `
   });
   await applyAssetIcons(entries, designDir);
+  await applyProjectFonts(entries, {
+    mode: "vendor",
+    root,
+    vendorDir: designDir,
+    vendorPrefix: designKey,
+    makeResourceEntry: (path, absPath) => ({
+      path,
+      type: "resource",
+      fileSrc: opts.assets === "disk" ? encodeURIComponent(absPath) : encodeURI(path),
+      absPath
+    })
+  });
   return compileProject2({
     entries,
     name: opts.name,
@@ -2754,10 +4686,10 @@ var openBrowser = (url) => {
 };
 var browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser) => {
   const state = randomBytes(16).toString("hex");
-  let resolve4;
+  let resolve5;
   let reject;
   const tokenPromise = new Promise((res, rej) => {
-    resolve4 = res;
+    resolve5 = res;
     reject = rej;
   });
   const server = createServer((req, res) => {
@@ -2775,7 +4707,7 @@ var browserLogin = async (webBase, timeoutMs = 5 * 60 * 1000, open = openBrowser
     }
     res.writeHead(200, { "content-type": "text/html" });
     res.end(SUCCESS_HTML);
-    resolve4(token);
+    resolve5(token);
   });
   await new Promise((res, rej) => {
     server.once("error", rej);
@@ -2839,6 +4771,9 @@ Behaviour that isn't visible in a single screen — validation, permissions, not
 cases — and the decisions you've made and why, so they aren't re-litigated later.
 `;
 var TOKENS_TS = `// Design tokens shared by every screen. Colors are hex strings (the engine parses hex only).
+// App font: one theme() call here sets the default text font everywhere. font("id") installs a
+// registry family (vendored at compile time) and returns its name — no loading code needed.
+// theme({ fontFamily: font("manrope") })
 export const colors = {
   bg: "#101114",
   card: "#1c1e24",
@@ -2852,6 +4787,57 @@ export const spacing = { xs: 4, sm: 8, md: 16, lg: 24 }
 
 export const radius = { sm: 8, md: 12, lg: 20 }
 `;
+var TABS_TS = `// The app's tab bar, declared ONCE — the design canvas discovers it from this file.
+//
+//   export const mainTabs = defineTabs({
+//     home: { label: "Home", icon: assetIcon("lucide:house") },
+//     news: { label: "News", icon: assetIcon("lucide:newspaper") },
+//   })
+//
+// The KEYS are screen ids — each tab's root screen (screens/<key>.ts), in tab order, literals only.
+// Every screen that shows the bar mounts it with a literal tab id — tab roots AND pushed details
+// that keep the bar:
+//
+//   export default () => mainTabs.screen("news", [ ...content ])
+//
+// A screen that doesn't mount it is a full-screen push (bar hidden). Never draw meta.json edges
+// between tab screens — the bar already navigates; the board renders it as a rail + lanes.
+// Restyle the bar below freely: only the defineTabs({ keys }) declaration and the
+// .screen("<tab>", …) / .bar("<tab>") call shapes are parsed.
+
+type TabDef = { label: string, icon?: { svg: string, tintColor: string | null } }
+
+// Theme-variable driven — theme({ primaryColor, mutedColor, tabbarBg, screenBg }) anywhere
+// restyles every screen's bar at once; the fallbacks keep an untouched scaffold looking right.
+const ACTIVE = "var(--primaryColor, #5b8cff)"
+const INACTIVE = "var(--mutedColor, #8a919e)"
+const BAR_BG = "var(--tabbarBg, #15171c)"
+const SCREEN_BG = "var(--screenBg, #101114)"
+
+export const defineTabs = <T extends Record<string, TabDef>>(tabs: T) => {
+  const ids = Object.keys(tabs) as (keyof T & string)[]
+
+  /** The bar alone — mount it yourself when the screen owns its whole layout. */
+  const bar = (active: keyof T & string) =>
+    UIRow(ids.map((id) => {
+      const color = id === active ? ACTIVE : INACTIVE
+      return UIButton([
+        ...(tabs[id].icon ? [UIImage(tabs[id].icon!).style({ width: 22, height: 22, tintColor: color })] : []),
+        UIText(tabs[id].label).style({ fontSize: 10, color }),
+      ]).style({ name: \`tab-\${id}\`, flexDirection: "column", gap: 3, flexGrow: 1, flexBasis: 0, pt: 8, pb: 6 })
+    })).style({ bgColor: BAR_BG, pb: "safe-bottom" })
+
+  /** A screen that sits ON the bar (the common case): [ content, bar ] — the same column the real
+   *  app composes as [ UIPager, bar ]. */
+  const screen = (active: keyof T & string, children: UINodeChild[]) =>
+    UIScreen([
+      UIColumn(children).style({ flexGrow: 1, p: 16, pt: "safe-top" }),
+      bar(active),
+    ]).style({ bgColor: SCREEN_BG })
+
+  return { ids, bar, screen }
+}
+`;
 var HOME_SCREEN_TS = `import { colors, spacing, radius } from "../shared/tokens"
 
 // Mock data: the domain shown on realistic values. Inline, per screen.
@@ -2930,6 +4916,12 @@ positions or descriptions.
 
 - An edge's optional \`activator\` names the element (its \`name\` style option) that triggers the
   transition. Give a \`name\` to interactive elements an edge refers to — nothing else needs names.
+- **Edges are forward intent only.** Never draw back/dismiss/logout edges — the navigation stack
+  implies return paths. And never draw edges between tab screens — the tab bar already navigates
+  (see "The tab bar" below); the board flags bar-implied edges for deletion.
+- **An edge from a screen to itself** (\`"from": "home", "to": "home@empty"\`) is a *state link*: the
+  board draws it as a chip on the activator element (clicking it switches the tile's state), never
+  as an arrow. Use it to record "tapping X puts this screen into state Y".
 - **Group each screen** you create by its user-facing area — \`"group": "Onboarding"\` — 2–6 screens
   per group (Onboarding, Checkout, Settings…). Groups render as labeled regions and \`arrange\` lays
   each out as its own sub-flow, so grouping keeps big boards legible. Semantic clustering is your
@@ -2977,6 +4969,25 @@ keep in the chat.
   typing a component's return value or a container's children — with no imports. Trust the types;
   don't fall back to \`any\`.
 
+## The tab bar
+
+Most apps have one — declare it ONCE, in source, and never draw edges for it:
+
+- \`shared/tabs.ts\` ships a \`defineTabs\` helper. Declare the bar there:
+  \`export const mainTabs = defineTabs({ home: { label: "Home", icon: assetIcon("lucide:house") }, … })\`
+  — the **keys are screen ids** (each tab's root screen, in tab order), literals only.
+- Every screen that shows the bar mounts it with a **literal** tab id:
+  \`export default () => mainTabs.screen("news", [ …content ])\` — tab roots AND pushed detail
+  screens that keep the bar (the news lane's article screen mounts \`"news"\` too). A screen that
+  doesn't mount it is a full-screen push (bar hidden), e.g. a photo viewer.
+- The canvas discovers all of this from the source (like screen states) and draws the bar as a
+  **rail + lane bands** — tab switching needs NO edges, and \`design_state\` serves the discovered
+  \`hubs\`. In the live prototype, tapping a tab button jumps the board to that tab's root screen.
+- Style through theme variables: the bar reads \`var(--primaryColor)\`, \`var(--mutedColor)\`,
+  \`var(--tabbarBg)\`, \`var(--screenBg)\` (with fallbacks) — one \`theme({ primaryColor: … })\` call
+  restyles it app-wide. You may restyle \`shared/tabs.ts\` itself; keep the \`defineTabs({ … })\`
+  declaration and \`.screen("<tab>", …)\` call shapes intact (the canvas parses them).
+
 ## Screen states (variants)
 
 A screen often has more than one look — a list vs. its empty state, a form vs. its error state.
@@ -2984,10 +4995,9 @@ Instead of a second file per variant, make the default export a **function of a
 type is a string-literal union** — the union IS the state list (no separate schema):
 
 \`\`\`ts
-export default (state: "default" | "empty" = "default") => UIScreen([
+export default (state: "default" | "empty" = "default") => mainTabs.screen("home", [
   Header(child),
   state === "empty" ? EmptyState("Nothing here yet") : UIScrollable(items.map(Card)),
-  TabBar(tabs, "home"),
 ])
 \`\`\`
 
@@ -3005,6 +5015,35 @@ export default (state: "default" | "empty" = "default") => UIScreen([
   \`"home@empty"\`) — still one node per screen. \`lecodes design check\` errors on an edge pointing at
   a state the screen doesn't declare.
 
+## Overlays (sheets & dialogs)
+
+A bottom sheet or confirm dialog is a **\`UIWidget\`**, not an absolutely-positioned child of the
+screen. Its \`overlayColor\` is the scrim — a real modal layer: it blocks everything beneath it
+(taps AND the canvas's hover/hints), and a tap on it fires \`onOverlayTap\`. \`show()\` it from the
+state branch instead of embedding it:
+
+\`\`\`ts
+const FilterSheet = () => {
+  const sheet = UIWidget(
+    { left: 0, right: 0, bottom: 0, p: 16, gap: 8, overlayColor: "#0008" },
+    [ SheetCard([ … ]), PrimaryButton("Apply", { name: "apply" }) ],
+  )
+  return sheet.onOverlayTap(() => sheet.hide())
+}
+
+export default (state: "default" | "filters" = "default") => {
+  if (state === "filters") FilterSheet().show()
+  return UIScreen([ … ])
+}
+\`\`\`
+
+- Size the widget box to the **content only** (bottom-anchor a sheet, or center a dialog card
+  inside a full-inset box) — the scrim is the \`overlayColor\`, painted full-screen behind it.
+- A tap lands **outside the widget box** → \`onOverlayTap\` (dismiss a sheet there). A confirm
+  dialog that demands an explicit choice uses a full-inset box and no \`onOverlayTap\`.
+- Headless snapshots render widgets as \`overlays\` in the JSON and composite them in the PNG,
+  and the edge \`activator\` names on widget elements (\`"apply"\`, \`"confirm"\`) work as usual.
+
 ## Icons
 
 Use real icons instead of emoji. \`assetIcon("pack:name")\` is a **compile-time macro**: it vendors
@@ -3027,6 +5066,28 @@ UIImage(assetIcon("lucide:check")).style({ width: 20, height: 20, tintColor: col
   (attribution) — **commit these**; they make rebuilds offline. An unknown \`pack:name\` is a clear
   compile error.
 
+## Fonts
+
+Real typography sells a design. \`font("id")\` installs a font from the registry AND returns its
+family name — no loading code, no awaiting, ever:
+
+\`\`\`ts
+theme({ fontFamily: font("manrope") })                                 // app font, in shared/tokens.ts
+UIText("Hero").style({ fontFamily: font("unbounded"), fontSize: 34 })  // display accents per node
+font("ibm-plex-sans", { weights: [400, 600] })                         // pick exact weights
+\`\`\`
+
+- Registry ids (all OFL, cyrillic-capable unless noted):
+  sans \`inter manrope golos-text onest rubik nunito montserrat ibm-plex-sans pt-sans jost exo-2\`;
+  display \`unbounded russo-one oswald comfortaa space-grotesk\` (latin only);
+  serif \`playfair-display lora pt-serif cormorant literata\`;
+  mono \`jetbrains-mono fira-code ibm-plex-mono\`; handwriting \`caveat pacifico\`.
+- Default weights are ~400/500/700 — install the weights you use (\`fontWeight: 600\` wants a 600
+  face). The id must be a **string literal**; an unknown one is a clear compile error.
+- Your own file works too: \`font("./fonts/Brand.ttf")\` — family/weight are read from the file.
+- Vendored faces land in \`assets/fonts/\`, tracked by \`fonts.lock.json\` + \`FONT-NOTICES.md\` —
+  **commit these**; they make rebuilds offline and they're what the platform board renders from.
+
 ## See what you built
 
 The developer watches the canvas live (screens hot-reload on save). To see a screen yourself:
@@ -3077,6 +5138,15 @@ var DESIGN_MACROS_DTS = `// Generated by \`lecodes design init\`. Globals the de
  * string literal (resolved, and the SVG vendored, at compile time).
  */
 declare function assetIcon(id: string, opts?: { color?: string }): { readonly svg: string, tintColor: string | null }
+
+/**
+ * Install a font and get its family name back — using a font IS declaring it. A registry id
+ * (\`font("manrope")\`) vendors faces from the font registry at compile time ({ weights, italic }
+ * narrows the set); a project path (\`font("./fonts/Brand.ttf")\`) reads family/weight/italic from
+ * the file itself. The argument must be a string literal. No awaiting — pass the result straight
+ * to \`theme({ fontFamily: font("manrope") })\` or a \`fontFamily\` style.
+ */
+declare function font(id: string, opts?: { weights?: number[], italic?: boolean }): string
 `;
 var README_HINT = `# design/
 
@@ -3101,33 +5171,33 @@ var getContext = (args) => {
   return {
     root,
     manifest,
-    name: manifest?.name ?? basename5(root),
+    name: manifest?.name ?? basename6(root),
     dirName,
-    designDir: join13(root, dirName),
+    designDir: join15(root, dirName),
     designKey: "/" + dirName.replace(/\\/g, "/")
   };
 };
 var listScreens = (designDir) => {
-  const dir = join13(designDir, "screens");
-  if (!existsSync11(dir))
+  const dir = join15(designDir, "screens");
+  if (!existsSync13(dir))
     return [];
-  return readdirSync6(dir).filter((f) => f.endsWith(".ts") && !f.startsWith(".")).map((f) => f.slice(0, -3)).sort();
+  return readdirSync7(dir).filter((f2) => f2.endsWith(".ts") && !f2.startsWith(".")).map((f2) => f2.slice(0, -3)).sort();
 };
 var readMetaSizes = (designDir) => {
   try {
-    const meta = JSON.parse(readFileSync12(join13(designDir, "meta.json"), "utf8"));
+    const meta = JSON.parse(readFileSync14(join15(designDir, "meta.json"), "utf8"));
     return meta?.screens ?? {};
   } catch {
     return {};
   }
 };
 var writeMcpConfig = (ctx, port) => {
-  const path = join13(ctx.root, ".mcp.json");
+  const path = join15(ctx.root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync11(path)) {
+  if (existsSync13(path)) {
     try {
-      config = JSON.parse(readFileSync12(path, "utf8"));
+      config = JSON.parse(readFileSync14(path, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-design server by hand.");
       return;
@@ -3140,7 +5210,7 @@ var writeMcpConfig = (ctx, port) => {
     return;
   }
   config.mcpServers["lecodes-design"] = entry;
-  writeFileSync9(path, JSON.stringify(config, null, 2) + `
+  writeFileSync11(path, JSON.stringify(config, null, 2) + `
 `);
   log(`${c.green(existing ? "updated" : "created")}   .mcp.json (lecodes-design MCP → ${entry.url})`);
 };
@@ -3150,25 +5220,26 @@ var init = async (ctx, args) => {
     ["spec.md", SPEC_MD],
     ["README.md", README_HINT],
     ["CLAUDE.md", CLAUDE_MD],
-    [join13("shared", "tokens.ts"), TOKENS_TS],
-    [join13("screens", "home.ts"), HOME_SCREEN_TS]
+    [join15("shared", "tokens.ts"), TOKENS_TS],
+    [join15("shared", "tabs.ts"), TABS_TS],
+    [join15("screens", "home.ts"), HOME_SCREEN_TS]
   ];
-  mkdirSync8(join13(ctx.designDir, "screens"), { recursive: true });
-  mkdirSync8(join13(ctx.designDir, "shared"), { recursive: true });
+  mkdirSync10(join15(ctx.designDir, "screens"), { recursive: true });
+  mkdirSync10(join15(ctx.designDir, "shared"), { recursive: true });
   let created = 0;
   for (const [rel, content] of files) {
-    const abs = join13(ctx.designDir, rel);
-    if (existsSync11(abs)) {
+    const abs = join15(ctx.designDir, rel);
+    if (existsSync13(abs)) {
       note(`kept      ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
       continue;
     }
-    writeFileSync9(abs, content);
+    writeFileSync11(abs, content);
     log(`${c.green("created")}   ${ctx.dirName}/${rel.replace(/\\/g, "/")}`);
     created++;
   }
-  const ignorePath = join13(ctx.root, ".lecodesignore");
+  const ignorePath = join15(ctx.root, ".lecodesignore");
   const ignoreLine = `${ctx.dirName}/.snapshots/`;
-  const current = existsSync11(ignorePath) ? readFileSync12(ignorePath, "utf8") : "";
+  const current = existsSync13(ignorePath) ? readFileSync14(ignorePath, "utf8") : "";
   if (!current.split(/\r?\n/).includes(ignoreLine)) {
     appendFileSync(ignorePath, (current && !current.endsWith(`
 `) ? `
@@ -3179,8 +5250,8 @@ var init = async (ctx, args) => {
   writeMcpConfig(ctx, Number(flagStr(args, "port")) || DEFAULT_PORT);
   const wroteTypes = materializeTypesLocal(ctx.designDir);
   writeTsconfig(ctx.designDir);
-  mkdirSync8(join13(ctx.designDir, ".lecodes", "types"), { recursive: true });
-  writeFileSync9(join13(ctx.designDir, ".lecodes", "types", "design-macros.d.ts"), DESIGN_MACROS_DTS);
+  mkdirSync10(join15(ctx.designDir, ".lecodes", "types"), { recursive: true });
+  writeFileSync11(join15(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.");
@@ -3229,16 +5300,16 @@ var snapshot = async (ctx, args) => {
   killer.unref?.();
   const png = flagBool(args, "png") || flagStr(args, "png") !== undefined;
   const sizes = readMetaSizes(ctx.designDir);
-  const outDir = flagStr(args, "out-dir") ?? join13(ctx.designDir, ".snapshots");
+  const outDir = flagStr(args, "out-dir") ?? join15(ctx.designDir, ".snapshots");
   const single = targets.length === 1 && requested.length === 1 && !png && !allStates && !flagStr(args, "out-dir");
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
   if (!single)
-    mkdirSync8(outDir, { recursive: true });
+    mkdirSync10(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(readFileSync12(join13(ctx.designDir, "screens", `${id}.ts`), "utf8"));
+      const { states, canonical } = discover(readFileSync14(join15(ctx.designDir, "screens", `${id}.ts`), "utf8"));
       if (stateFlag !== undefined) {
         if (!states.includes(stateFlag)) {
           if (requested.length === 1)
@@ -3279,18 +5350,18 @@ var snapshot = async (ctx, args) => {
         for (const w of pngResult.warnings)
           warnErr(`${tag}: ${w}`);
       for (const base of bases) {
-        writeFileSync9(join13(outDir, `${base}.json`), result.text);
-        log(`${c.green("✓")} ${tag} → ${join13(outDir, `${base}.json`)}`);
+        writeFileSync11(join15(outDir, `${base}.json`), result.text);
+        log(`${c.green("✓")} ${tag} → ${join15(outDir, `${base}.json`)}`);
         if (pngResult) {
-          writeFileSync9(join13(outDir, `${base}.png`), pngResult.png);
-          log(`${c.green("✓")} ${tag} → ${join13(outDir, `${base}.png`)}`);
+          writeFileSync11(join15(outDir, `${base}.png`), pngResult.png);
+          log(`${c.green("✓")} ${tag} → ${join15(outDir, `${base}.png`)}`);
         }
       }
     }
   }
 };
 var serve = async (ctx, args) => {
-  if (!existsSync11(ctx.designDir)) {
+  if (!existsSync13(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let designServer;
@@ -3363,7 +5434,7 @@ var serve = async (ctx, args) => {
     openBrowser(server.url);
 };
 var arrange = async (ctx, args) => {
-  if (!existsSync11(ctx.designDir)) {
+  if (!existsSync13(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let designServer;
@@ -3399,7 +5470,7 @@ var share = async (ctx, args) => {
   note("Turn it off with:  lecodes design share --off");
 };
 var check = async (ctx, args) => {
-  if (!existsSync11(ctx.designDir)) {
+  if (!existsSync13(ctx.designDir)) {
     throw new CliError(`No ${ctx.dirName}/ folder here. Run "lecodes design init" to scaffold it.`);
   }
   let designServer;
@@ -3436,6 +5507,14 @@ var check = async (ctx, args) => {
       log(`  ${c.yellow("!")} ${s.id}: ${s.statesWarning}`);
     log("");
   }
+  if (state.hubs.length) {
+    log(c.bold("Tab bars"));
+    for (const h of state.hubs) {
+      const mounted = Object.keys(h.lanes).length;
+      log(`  ${h.name} (${h.file}): ${h.tabs.join(" · ")} — ${mounted} screen${mounted === 1 ? "" : "s"} on the bar`);
+    }
+    log("");
+  }
   const hard = state.warnings.length;
   if (hard === 0) {
     const n = state.screens.length;
@@ -3464,15 +5543,15 @@ var design = async (args) => {
 };
 
 // src/commands/dev.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync13, watch, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync15, watch, writeFileSync as writeFileSync12 } from "node:fs";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { basename as basename6, join as join15 } from "node:path";
+import { basename as basename7, join as join17 } from "node:path";
 
 // src/dev/devServer.ts
 import { createServer as createServer2 } from "node:http";
-import { createReadStream, existsSync as existsSync12, statSync as statSync2 } from "node:fs";
-import { join as join14 } from "node:path";
+import { createReadStream, existsSync as existsSync14, statSync as statSync3 } from "node:fs";
+import { join as join16 } from "node:path";
 
 // src/dev/clientTemplates.ts
 var DEV_SCREEN_TS = `const title = "LeCodes Dev"
@@ -3587,9 +5666,9 @@ var renderPrelude = (p) => DEV_PRELUDE_JS.split("__DEV_ORIGIN__").join(p.origin)
 var renderDevScreen = (name) => DEV_SCREEN_TS.split("__DEV_NAME__").join(JSON.stringify(name));
 
 // src/dev/wsServer.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-var acceptKey = (key) => createHash3("sha1").update(key + WS_GUID).digest("base64");
+var acceptKey = (key) => createHash4("sha1").update(key + WS_GUID).digest("base64");
 var encodeTextFrame = (text) => {
   const payload = Buffer.from(text, "utf8");
   const len = payload.length;
@@ -3736,14 +5815,14 @@ var sendText = (res, status, type, body) => {
   res.end(body);
 };
 var sendJson = (res, status, body) => sendText(res, status, "application/json", JSON.stringify(body));
-var readBody = (req) => new Promise((resolve4) => {
+var readBody = (req) => new Promise((resolve5) => {
   let body = "";
   req.on("data", (c2) => {
     if (body.length < 256 * 1024)
       body += c2.toString("utf8");
   });
-  req.on("end", () => resolve4(body));
-  req.on("error", () => resolve4(body));
+  req.on("end", () => resolve5(body));
+  req.on("error", () => resolve5(body));
 });
 var startDevServer = async (options) => {
   const { root, manifest, name, origin, token, entryOverride } = options;
@@ -3756,7 +5835,15 @@ var startDevServer = async (options) => {
   const compileOnce = async () => {
     try {
       const { entries, warnings } = collectLocalEntries(root, manifest, `${base}/assets`);
-      const js = await compileProject2({ entries, name, publicUrl: origin, entryOverride, header: true });
+      const fontsHeader = await applyProjectFonts(entries, {
+        mode: "vendor",
+        root,
+        vendorDir: root,
+        vendorPrefix: "",
+        publicUrl: origin,
+        makeResourceEntry: (path, absPath) => ({ path, type: "resource", fileSrc: `${base}/assets` + encodeURI(path), absPath })
+      });
+      const js = await compileProject2({ entries, name, publicUrl: origin, entryOverride, header: true, fontsHeader });
       const changed = bundleJs === null || stripVolatile(js) !== stripVolatile(bundleJs);
       if (changed) {
         bundleJs = js;
@@ -3828,8 +5915,8 @@ var startDevServer = async (options) => {
       } catch {
         return sendText(res, 400, "text/plain", "Bad path");
       }
-      const abs = join14(root, key.slice(1));
-      if (!existsSync12(abs) || !statSync2(abs).isFile())
+      const abs = join16(root, key.slice(1));
+      if (!existsSync14(abs) || !statSync3(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);
@@ -3872,11 +5959,11 @@ var startDevServer = async (options) => {
     if (conn)
       clients.add(conn);
   });
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     server.once("error", reject);
     server.listen(options.port, options.bind ?? "0.0.0.0", () => {
       server.removeListener("error", reject);
-      resolve4();
+      resolve5();
     });
   });
   const address = server.address();
@@ -3912,24 +5999,24 @@ var pickLanAddress = () => {
   return null;
 };
 var loadDevToken = (root) => {
-  const path = join15(root, LECODES_DIR, "dev.json");
+  const path = join17(root, LECODES_DIR, "dev.json");
   try {
-    const token2 = JSON.parse(readFileSync13(path, "utf8")).token;
+    const token2 = JSON.parse(readFileSync15(path, "utf8")).token;
     if (token2 && /^[a-z0-9]{8,}$/.test(token2))
       return token2;
   } catch {}
   const token = randomBytes2(6).toString("hex");
-  mkdirSync9(join15(root, LECODES_DIR), { recursive: true });
-  writeFileSync10(path, JSON.stringify({ token }, null, 2) + `
+  mkdirSync11(join17(root, LECODES_DIR), { recursive: true });
+  writeFileSync12(path, 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((resolve4) => qrcode.generate(url, { small: true }, (out) => {
+    await new Promise((resolve5) => qrcode.generate(url, { small: true }, (out) => {
       log(out);
-      resolve4();
+      resolve5();
     }));
   } catch {
     note("(couldn't render a QR code — open the URL below on the device)");
@@ -3945,7 +6032,7 @@ var dev = async (args) => {
     root = process.cwd();
     manifest = null;
   }
-  const name = manifest?.name ?? basename6(root);
+  const name = manifest?.name ?? basename7(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).");
   }
@@ -4032,15 +6119,15 @@ ${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 (existsSync13(join15(root, LECODES_DIR, "manifest.json")))
+  if (existsSync15(join17(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.`);
 };
 
 // src/serverDiff.ts
-import { readFileSync as readFileSync14 } from "node:fs";
-import { basename as basename7 } from "node:path";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { basename as basename8 } from "node:path";
 var isTextAsset = (t) => t === "text" || t === "shader" || t === "scene";
 var computeServerDiff = (project, scan) => {
   const pathById = buildPaths(project.assets);
@@ -4050,15 +6137,15 @@ var computeServerDiff = (project, scan) => {
       continue;
     serverByPath.set(pathById.get(asset.id), asset);
   }
-  const localByPath = new Map(scan.files.map((f) => [f.path, f]));
+  const localByPath = new Map(scan.files.map((f2) => [f2.path, f2]));
   const entries = [];
   const paths = new Set([...serverByPath.keys(), ...localByPath.keys()]);
   for (const path of [...paths].sort()) {
     const server = serverByPath.get(path);
     const local = localByPath.get(path);
     if (local && !server) {
-      const text = isTextKind(classifyKind(basename7(path)));
-      entries.push({ path, status: "added", binary: !text, serverText: "", localText: text ? readFileSync14(local.absPath, "utf8") : undefined });
+      const text = isTextKind(classifyKind(basename8(path)));
+      entries.push({ path, status: "added", binary: !text, serverText: "", localText: text ? readFileSync16(local.absPath, "utf8") : undefined });
       continue;
     }
     if (server && !local) {
@@ -4069,12 +6156,12 @@ var computeServerDiff = (project, scan) => {
     if (server && local) {
       if (isTextAsset(server.type)) {
         const serverText = server.text ?? "";
-        const localText = readFileSync14(local.absPath, "utf8");
+        const localText = readFileSync16(local.absPath, "utf8");
         if (serverText !== localText)
           entries.push({ path, status: "modified", binary: false, serverText, localText });
       } else {
         const serverSize = server.file?.size;
-        const localSize = Buffer.byteLength(readFileSync14(local.absPath));
+        const localSize = Buffer.byteLength(readFileSync16(local.absPath));
         if (serverSize !== undefined && serverSize !== localSize) {
           entries.push({ path, status: "modified", binary: true });
         }
@@ -4227,8 +6314,8 @@ var diff = async (args) => {
 var statusLabel = (e) => e.status === "added" ? c.green("  added    ") : e.status === "removed" ? c.red("  removed  ") : c.yellow("  modified ");
 
 // src/commands/init.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename8, dirname as dirname8, join as join16, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync12, writeFileSync as writeFileSync13 } from "node:fs";
+import { basename as basename9, dirname as dirname10, join as join18, resolve as resolve5 } from "node:path";
 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\`.
 
@@ -4264,24 +6351,55 @@ const screen = UIScreen(
 
 screen.open()
 `;
+var readmeTemplate = (name) => `# ${name}
+
+A LeCodes app. The whole SDK is available as globals (\`UIScreen\`, \`UIText\`, \`Scene2D\`, …) —
+no imports needed. \`main.ts\` is the entry point.
+
+## Run it
+
+\`\`\`
+lecodes dev                  # live on your phone: scan the QR with the LeCodes app, hot reload
+lecodes compile -o app.js    # bundle to a single self-contained JS file
+\`\`\`
+
+## Go native
+
+\`\`\`
+lecodes app init ios         # generate a native Xcode shell in ios/
+lecodes app sync             # embed the compiled bundle + plugins into it
+lecodes app open             # open it in Xcode, build & run
+\`\`\`
+
+## Layout
+
+- \`main.ts\` — the app. Add more top-level .ts files freely; the largest export-free one
+  is picked as the entry point.
+- \`assets/\` — images/fonts the app references (created on demand)
+- \`tsconfig.json\` + \`.lecodes/types/\` — generated IDE types (rewritten by the CLI; don't edit)
+- \`.lecodesignore\` — files a future \`lecodes push\` would skip
+
+Full command list: \`lecodes --help\`.
+`;
 var init2 = async (args) => {
   const dirArg = (args._[0] ?? ".").replace(/[/\\]+$/, "") || ".";
-  const root = resolve4(dirArg);
-  const name = basename8(root);
-  mkdirSync10(root, { recursive: true });
+  const root = resolve5(dirArg);
+  const name = basename9(root);
+  mkdirSync12(root, { recursive: true });
   let created = 0;
   const write = (rel, content) => {
-    const abs = join16(root, rel);
-    if (existsSync14(abs)) {
+    const abs = join18(root, rel);
+    if (existsSync16(abs)) {
       note(`kept      ${rel}`);
       return;
     }
-    mkdirSync10(dirname8(abs), { recursive: true });
-    writeFileSync11(abs, content);
+    mkdirSync12(dirname10(abs), { recursive: true });
+    writeFileSync13(abs, content);
     log(`${c.green("created")}   ${rel}`);
     created++;
   };
   write("main.ts", STARTER2);
+  write("README.md", readmeTemplate(name));
   write(".lecodesignore", DEFAULT_IGNORE_FILE);
   const wroteTypes = materializeTypesLocal(root);
   writeTsconfig(root);
@@ -4308,20 +6426,20 @@ var login = async (args) => {
 };
 
 // src/commands/render.ts
-import { writeFileSync as writeFileSync12 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { writeFileSync as writeFileSync14 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 var LOCAL_ASSET_SCHEME2 = "lecodesfile://";
 var DEVICE_SAFE_AREA = {
-  none: [0, 0, 0, 0],
-  iphone: [47, 0, 34, 0],
-  android: [24, 0, 24, 0]
+  none: { insets: [0, 0, 0, 0], bars: [] },
+  iphone: { insets: [59, 0, 34, 0], bars: [] },
+  android: { insets: [24, 0, 48, 0], bars: ["top", "bottom"] }
 };
 var resolveSafeArea = (args) => {
   const explicit = flagStr(args, "safe-area");
   if (explicit) {
     const n = explicit.split(",").map((s) => Number(s.trim()));
     if (n.length === 4 && n.every((v) => Number.isFinite(v)))
-      return n;
+      return { safeArea: n, safeAreaBars: [] };
     throw new CliError(`--safe-area expects "top,right,bottom,left" (4 numbers), got "${explicit}".`);
   }
   const device = flagStr(args, "device");
@@ -4329,7 +6447,7 @@ var resolveSafeArea = (args) => {
     const preset = DEVICE_SAFE_AREA[device];
     if (!preset)
       throw new CliError(`Unknown --device "${device}". Options: ${Object.keys(DEVICE_SAFE_AREA).join(", ")}.`);
-    return preset;
+    return { safeArea: preset.insets, safeAreaBars: preset.bars };
   }
   return;
 };
@@ -4352,6 +6470,13 @@ var render = async (args) => {
   const useLocalAssets = !publicUrlFlag && !flagBool(args, "remote-assets");
   const compileEntries = useLocalAssets ? entries.map((e) => e.type === "resource" && e.absPath ? { ...e, fileSrc: encodeURIComponent(e.absPath) } : e) : entries;
   const warnings = useLocalAssets ? collectWarnings.filter((w) => !w.includes("No server URL")) : collectWarnings;
+  await applyProjectFonts(compileEntries, useLocalAssets ? {
+    mode: "vendor",
+    root,
+    vendorDir: root,
+    vendorPrefix: "",
+    makeResourceEntry: (path, absPath) => ({ path, type: "resource", fileSrc: encodeURIComponent(absPath), absPath })
+  } : { mode: "cdn", root });
   note("Compiling…");
   const js = await compileProject2({
     entries: compileEntries,
@@ -4384,7 +6509,7 @@ var render = async (args) => {
     localAssets: useLocalAssets,
     timeMs: timeStr !== undefined ? Number(timeStr) : undefined,
     afterAnimations: !flagBool(args, "no-after-animations"),
-    safeArea: resolveSafeArea(args),
+    ...resolveSafeArea(args),
     onConsole
   };
   const done = (flush) => flush(() => {
@@ -4405,7 +6530,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync12(resolve5(pngFlag), png);
+      writeFileSync14(resolve6(pngFlag), png);
       note(`Wrote ${pngFlag} (${png.length} bytes, ${width}x${height})`);
     }
     return done((cb) => cb());
@@ -4420,7 +6545,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync12(resolve5(out), result.text);
+    writeFileSync14(resolve6(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -4431,8 +6556,8 @@ var render = async (args) => {
 };
 
 // src/commands/pull.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync11, rmSync, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname9, join as join17 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, rmSync as rmSync2, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname11, join as join19 } from "node:path";
 var pull = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -4452,9 +6577,9 @@ var pull = async (args) => {
   const remotePaths = new Set([...buildPaths(project.assets).entries()].filter(([id]) => project.assets.find((a) => a.id === id)?.type !== "folder").map(([, path]) => path));
   for (const path of Object.keys(manifest.files)) {
     if (!remotePaths.has(path)) {
-      const abs = join17(root, ...path.replace(/^\//, "").split("/"));
-      if (existsSync15(abs))
-        rmSync(abs);
+      const abs = join19(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync17(abs))
+        rmSync2(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -4491,18 +6616,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 = join17(root, ...key.replace(/^\//, "").split("/"));
-    mkdirSync11(dirname9(abs), { recursive: true });
+    const abs = join19(root, ...key.replace(/^\//, "").split("/"));
+    mkdirSync13(dirname11(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
       if (!asset.file?.src)
         continue;
       const bytes = await downloadBlob(apiUrl, asset.file.src);
-      writeFileSync13(abs, bytes);
+      writeFileSync15(abs, bytes);
       sha = sha256(bytes);
     } else {
       const text = asset.text ?? "";
-      writeFileSync13(abs, text);
+      writeFileSync15(abs, text);
       sha = sha256(text);
     }
     files[key] = { id: asset.id, type: kindOf2(asset.type), sha };
@@ -4514,8 +6639,8 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 };
 
 // src/commands/push.ts
-import { basename as basename9 } from "node:path";
-import { readFileSync as readFileSync15 } from "node:fs";
+import { basename as basename10 } from "node:path";
+import { readFileSync as readFileSync17 } from "node:fs";
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -4569,14 +6694,14 @@ var push = async (args) => {
   let uploaded = 0;
   for (const file of scan.files) {
     const source = sourceFor(file.path);
-    const kind = source?.type ?? classifyKind(basename9(file.path));
+    const kind = source?.type ?? classifyKind(basename10(file.path));
     const entry = { path: file.path, type: kind };
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync15(file.absPath, "utf8");
+      entry.text = readFileSync17(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename9(file.path), readFileSync15(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename10(file.path), readFileSync17(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -4592,7 +6717,7 @@ var push = async (args) => {
       reportPublish(res);
     return;
   }
-  const shaByPath = new Map(scan.files.map((f) => [f.path, f.sha]));
+  const shaByPath = new Map(scan.files.map((f2) => [f2.path, f2.sha]));
   const newFiles = {};
   for (const node of res.nodes) {
     newFiles[node.path] = { id: node.id, type: node.type, sha: shaByPath.get(node.path) ?? "" };
@@ -4629,22 +6754,22 @@ var reportPublish = (res) => {
 };
 
 // src/commands/scene.ts
-import { existsSync as existsSync17, readFileSync as readFileSync17, readdirSync as readdirSync7, statSync as statSync3, writeFileSync as writeFileSync14 } from "node:fs";
-import { basename as basename10, dirname as dirname10, join as join19, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync19, readdirSync as readdirSync8, statSync as statSync4, writeFileSync as writeFileSync16 } from "node:fs";
+import { basename as basename11, dirname as dirname12, join as join21, resolve as resolve7 } from "node:path";
 
 // src/compile/sceneCompile.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync18 } from "node:fs";
+import { join as join20 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join18(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join20(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync16(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync18(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join18(distRoot, "runtime", "scene-harness.json");
-    if (existsSync16(vendored))
-      return JSON.parse(readFileSync16(vendored, "utf8"));
+    const vendored = join20(distRoot, "runtime", "scene-harness.json");
+    if (existsSync18(vendored))
+      return JSON.parse(readFileSync18(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
 };
@@ -4656,7 +6781,7 @@ var compileSceneEditor = async (opts) => {
   for (const file of scan.files) {
     const path = "./" + rel(file.path);
     if (TEXT_EXT.test(path)) {
-      entries.push({ path, type: "text", text: readFileSync16(file.absPath, "utf8") });
+      entries.push({ path, type: "text", text: readFileSync18(file.absPath, "utf8") });
     } else {
       entries.push({ path, type: "resource", fileSrc: "/project/" + rel(file.path) });
     }
@@ -4696,24 +6821,24 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve6(process.cwd(), pathArg);
-      if (existsSync17(abs) && statSync3(abs).isDirectory())
+      const abs = resolve7(process.cwd(), pathArg);
+      if (existsSync19(abs) && statSync4(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync17(abs))
-        root = dirname10(abs);
+      else if (abs.endsWith(".scene.ts") && existsSync19(abs))
+        root = dirname12(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
     }
   }
-  return { root, manifest, name: manifest?.name ?? basename10(root) };
+  return { root, manifest, name: manifest?.name ?? basename11(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path = join19(root, ".mcp.json");
+  const path = join21(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync17(path)) {
+  if (existsSync19(path)) {
     try {
-      config = JSON.parse(readFileSync17(path, "utf8"));
+      config = JSON.parse(readFileSync19(path, "utf8"));
     } catch {
       warnErr(".mcp.json exists but isn't valid JSON — left it untouched. Add the lecodes-scene server by hand.");
       return;
@@ -4726,17 +6851,17 @@ var writeMcpConfig2 = (root, port) => {
     return;
   }
   config.mcpServers["lecodes-scene"] = entry;
-  writeFileSync14(path, JSON.stringify(config, null, 2) + `
+  writeFileSync16(path, JSON.stringify(config, null, 2) + `
 `);
   note(`${existing ? "updated" : "created"}   .mcp.json (lecodes-scene MCP → ${entry.url})`);
 };
 var countScenes = (dir) => {
   let n = 0;
-  for (const name of readdirSync7(dir)) {
+  for (const name of readdirSync8(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join19(dir, name);
-    if (statSync3(full).isDirectory())
+    const full = join21(dir, name);
+    if (statSync4(full).isDirectory())
       n += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n++;
@@ -4788,12 +6913,12 @@ var status = async (_args) => {
     info(c.dim("Working tree clean — nothing to push.") + ignoredNote);
     return;
   }
-  for (const f of diff2.added) {
-    if (!diff2.moves.has(f.path))
-      log(c.green(`  added     ${f.path}`));
+  for (const f2 of diff2.added) {
+    if (!diff2.moves.has(f2.path))
+      log(c.green(`  added     ${f2.path}`));
   }
-  for (const f of diff2.modified)
-    log(c.yellow(`  modified  ${f.path}`));
+  for (const f2 of diff2.modified)
+    log(c.yellow(`  modified  ${f2.path}`));
   for (const [to, from] of diff2.moves)
     log(c.cyan(`  moved     ${from} → ${to}`));
   const movedFrom = new Set(diff2.moves.values());
@@ -4806,21 +6931,22 @@ var status = async (_args) => {
 };
 
 // src/index.ts
-import { existsSync as existsSync19, realpathSync as realpathSync2 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname12, join as join21 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync21, realpathSync as realpathSync2 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import { delimiter as delimiter2, dirname as dirname14, join as join23 } from "node:path";
 
 // src/commands/install.ts
-import { execFileSync } from "node:child_process";
-import { appendFileSync as appendFileSync2, chmodSync, cpSync, existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync18, realpathSync, rmSync as rmSync2, symlinkSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { basename as basename11, delimiter, dirname as dirname11, join as join20, resolve as resolve7, sep } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { appendFileSync as appendFileSync2, chmodSync, cpSync as cpSync2, existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync20, realpathSync, rmSync as rmSync3, symlinkSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename12, delimiter, dirname as dirname13, join as join22, resolve as resolve8, sep } from "node:path";
 var isWin = process.platform === "win32";
-var HOME = homedir2();
+var HOME = homedir3();
 var safeRealpath = (p) => {
   try {
     return realpathSync(p);
   } catch {
-    return resolve7(p);
+    return resolve8(p);
   }
 };
 var onPath = (dir) => {
@@ -4836,25 +6962,25 @@ var onPath = (dir) => {
   });
 };
 var install = async (args) => {
-  const bundle = dirname11(process.execPath);
-  const exeName = basename11(process.execPath);
+  const bundle = dirname13(process.execPath);
+  const exeName = basename12(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync18(join20(bundle, "runtime")) || !existsSync18(join20(bundle, chiselName))) {
+  if (!existsSync20(join22(bundle, "runtime")) || !existsSync20(join22(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((f) => existsSync18(join20(bundle, f)));
+  const companions = [exeName, chiselName, "runtime", "README.txt"].filter((f2) => existsSync20(join22(bundle, f2)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
 };
 var copyBundle = (bundle, target, companions) => {
-  mkdirSync12(target, { recursive: true });
+  mkdirSync14(target, { recursive: true });
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
-  for (const f of companions) {
-    const dest = join20(target, f);
-    rmSync2(dest, { recursive: true, force: true });
-    cpSync(join20(bundle, f), dest, { recursive: true });
+  for (const f2 of companions) {
+    const dest = join22(target, f2);
+    rmSync3(dest, { recursive: true, force: true });
+    cpSync2(join22(bundle, f2), dest, { recursive: true });
   }
 };
 var permError = (e, dir, system) => {
@@ -4866,41 +6992,41 @@ var permError = (e, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  const libDir = resolve7(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join20(HOME, ".local", "lib", "lecodes-cli")));
-  const binDir = resolve7(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join20(HOME, ".local", "bin")));
-  const link = join20(binDir, "lecodes");
+  const libDir = resolve8(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join22(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve8(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join22(HOME, ".local", "bin")));
+  const link = join22(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync(join20(libDir, "lecodes"), 493);
-    chmodSync(join20(libDir, "chisel"), 493);
+    chmodSync(join22(libDir, "lecodes"), 493);
+    chmodSync(join22(libDir, "chisel"), 493);
   } catch (e) {
     throw permError(e, libDir, system);
   }
   try {
-    mkdirSync12(binDir, { recursive: true });
-    rmSync2(link, { force: true });
-    symlinkSync(join20(libDir, "lecodes"), link);
+    mkdirSync14(binDir, { recursive: true });
+    rmSync3(link, { force: true });
+    symlinkSync(join22(libDir, "lecodes"), link);
   } catch (e) {
     throw permError(e, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link + " → " + join20(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link + " → " + join22(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
-  const shell = basename11(process.env.SHELL ?? "");
+  const shell = basename12(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join20(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join22(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join20(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join20(HOME, ".profile"), name: "~/.profile" };
+    return { file: join22(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join22(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 = existsSync18(file) ? readFileSync18(file, "utf8") : "";
+    const existing = existsSync20(file) ? readFileSync20(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync2(file, `${existing && !existing.endsWith(`
@@ -4938,7 +7064,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 = resolve7(flagStr(args, "dir") ?? join20(process.env.LOCALAPPDATA ?? join20(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve8(flagStr(args, "dir") ?? join22(process.env.LOCALAPPDATA ?? join22(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e) {
@@ -4966,7 +7092,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 {
-    execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
+    execFileSync2("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", env: { ...process.env, LECODES_INSTALL_DIR: dir } });
     return true;
   } catch {
     return false;
@@ -4975,9 +7101,9 @@ var addToUserPathWindows = (dir) => {
 
 // src/index.ts
 var STANDALONE = (() => {
-  const dir = dirname12(process.execPath);
+  const dir = dirname14(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync19(join21(dir, "runtime")) && existsSync19(join21(dir, chisel));
+  return existsSync21(join23(dir, "runtime")) && existsSync21(join23(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -4992,8 +7118,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join21(d, exe);
-      return existsSync19(cand) && realpathSync2(cand) === self;
+      const cand = join23(d, exe);
+      return existsSync21(cand) && realpathSync2(cand) === self;
     } catch {
       return false;
     }
@@ -5080,12 +7206,70 @@ ${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                  Generate a native Xcode shell in <project>/ios/ (offline-first:
+                                  runs the bundled app.js; ios/ is never pushed to LeCodes)
+                                  --name <s>         display name (default: app.json / folder name)
+                                  --bundle-id <id>   iOS bundle identifier
+                                  --team <id>        Apple development team id
+                                  --variant <v>      SDK variant: core (default) or full (3D/AR)
+  app sync                      Make the shell match the project: compile the bundle + embed
+                                  its assets into ios/App/Resources/ (offline by default, also
+                                  for server projects; app.json "resources": {"remote": [globs]}
+                                  keeps heavy assets streaming from the server), vendor app.json
+                                  plugins (pinned in plugins.lock.json), regenerate the
+                                  CLI-owned shell files
+  app plugin <list|add|remove>  Manage native plugins in app.json (then run 'lecodes app sync')
+                                  add takes a known id (camera, qr-scanner) or github:owner/repo[@tag]
+  app open [ios]                Open the native shell in its IDE (Xcode; Android Studio later)
+  app doctor                    Preflight checks for building/uploading the shell
+  app build ios                 Sync, archive and export the .ipa (automatic signing)
+                                  --configuration <c>  build configuration (default Release)
+                                  --method <m>         export method (default app-store-connect)
+                                  --no-export          stop after the archive
+                                  --no-sync            skip the lecodes app sync step
+  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
 
 Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKEN).`;
-var commands = { init: init2, login, create, clone, status, diff, pull, push, compile: compile2, preview: previewLegacy, render, design, scene, dev };
+var commands = { init: init2, login, create, clone, status, diff, pull, push, compile: compile2, preview: previewLegacy, render, design, scene, dev, app };
 if (STANDALONE)
   commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
+var OPTIONAL_PEERS = [
+  ["lecodes-renderer", "lecodes-renderer/headless"],
+  ["lecodes-design", "lecodes-design/server"],
+  ["lecodes-3d-editor", "lecodes-3d-editor/server"]
+];
+var peerVersion = (name, probe) => {
+  try {
+    const require2 = createRequire4(import.meta.url);
+    let dir = dirname14(require2.resolve(probe));
+    for (let depth = 0;depth < 16; depth++) {
+      const manifest = join23(dir, "package.json");
+      if (existsSync21(manifest)) {
+        const parsed = JSON.parse(readFileSync21(manifest, "utf8"));
+        if (parsed.name === name)
+          return parsed.version ?? "unknown";
+      }
+      const parent = dirname14(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {}
+  return null;
+};
+var printVersion = () => {
+  const rows = [["lecodes-cli", readVersion()]];
+  for (const [name, probe] of OPTIONAL_PEERS) {
+    const version = peerVersion(name, probe);
+    rows.push([name, version ?? c.dim("not installed")]);
+  }
+  const width = Math.max(...rows.map(([label]) => label.length));
+  for (const [label, value] of rows)
+    log(`${label.padEnd(width)}  ${value}`);
+};
 var main = async () => {
   const argv = process.argv.slice(2);
   const command = argv[0];
@@ -5094,7 +7278,7 @@ var main = async () => {
     return;
   }
   if (command === "--version" || command === "-v" || command === "version") {
-    log(readVersion());
+    printVersion();
     return;
   }
   const run = commands[command];