lecodes-cli 0.9.2 → 0.10.0

package/dist/index.js

@@ -2088,7 +2088,7 @@ var require_main = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "lecodes-cli",
-  version: "0.9.2",
+  version: "0.10.0",
   dependencies: {
     "@letary/chisel": "^0.5.1"
   },
@@ -3588,8 +3588,9 @@ var runtimePackageTemplate = (sdkVersion, variant, plugins) => {
 //
 // GENERATED by lecodes — regenerated by \`lecodes app sync\`; do not edit.
 // Owns the app's native dependency graph: the LeCodesSDK variant (auto-picked from what
-// the compiled bundle uses, or forced via app.json ios.variant) and one vendored target
-// per installed plugin (see plugins.lock.json).
+// the compiled bundle uses, or forced via app.json ios.variant), the exact SDK release
+// (app.json ios.sdk — move it with \`lecodes app update\`) and one vendored target per
+// installed plugin (see plugins.lock.json).
 
 import PackageDescription
 
@@ -3600,7 +3601,7 @@ let package = Package(
         .library(name: "LeCodesRuntime", targets: ["LeCodesRuntime"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/letary/lecodes-ios-sdk.git", from: "${sdkVersion}"),
+        .package(url: "https://github.com/letary/lecodes-ios-sdk.git", exact: "${sdkVersion}"),
     ],
     targets: [
         .target(
@@ -3653,6 +3654,22 @@ 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.
 
+## SDK version
+
+\`../app.json\` \`ios.sdk\` is the exact \`lecodes-ios-sdk\` release this shell links —
+\`lecodes app init\` pinned the newest one at the time, so builds stay reproducible.
+
+\`\`\`
+lecodes app update           # → newest SDK release + newest plugin tags, then sync
+lecodes app update --check   # what's available, writes nothing
+lecodes app update --sdk 1.3.0
+\`\`\`
+
+Set \`"sdk": "latest"\` instead of a version to re-resolve on every sync (needs network;
+offline it keeps whatever the shell already links). The pin is exact rather than a range
+because the CLI also downloads that release's filament resources bundle into
+\`App/Resources/\` — the two halves of one SDK must not drift apart.
+
 ## Who owns what
 
 Yours — \`lecodes app sync\` never touches these:
@@ -3700,7 +3717,8 @@ buildNumber) — edit it there, then re-run \`lecodes app sync\`. Plugins are ma
 `;
 
 // src/commands/app.ts
-var SDK_PACKAGE_VERSION = "1.2.0";
+var SDK_REPO = "letary/lecodes-ios-sdk";
+var SDK_MIN_VERSION = "1.2.0";
 var SDK_VARIANTS = ["core", "2d", "3d", "full"];
 var FIRST_PARTY_PLUGINS = {
   camera: "letary/lecodes-plugins",
@@ -3725,6 +3743,51 @@ var projectRoot = () => {
   }
 };
 var git = (cwd, ...args) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+var VERSION_RE = /^\d+\.\d+\.\d+$/;
+var cmpVersion = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0))
+      return (pa[i] ?? 0) - (pb[i] ?? 0);
+  }
+  return 0;
+};
+var fetchLatestSdkVersion = async () => {
+  const url = `https://api.github.com/repos/${SDK_REPO}/releases/latest`;
+  const res = await fetch(url, { headers: { accept: "application/vnd.github+json", "user-agent": "lecodes-cli" } });
+  if (!res.ok)
+    throw new CliError(`Could not read the latest ${SDK_REPO} release (HTTP ${res.status}) — ${url}`);
+  const tag = (await res.json()).tag_name?.replace(/^v/, "") ?? "";
+  if (!VERSION_RE.test(tag))
+    throw new CliError(`${SDK_REPO} latest release has no x.y.z tag (got "${tag}")`);
+  return tag;
+};
+var shellSdkVersion = (iosDir) => {
+  const path = join11(iosDir, "LeCodesRuntime", "Package.swift");
+  if (!existsSync8(path))
+    return null;
+  const m = /lecodes-ios-sdk\.git",\s*(?:exact|from):\s*"([^"]+)"/.exec(readFileSync10(path, "utf8"));
+  return m && VERSION_RE.test(m[1]) ? m[1] : null;
+};
+var resolveSdkVersion = async (pin, fallback) => {
+  if (pin !== "latest") {
+    if (!VERSION_RE.test(pin)) {
+      throw new CliError(`app.json ios.sdk must be "latest" or an exact x.y.z release (got "${pin}").`);
+    }
+    if (cmpVersion(pin, SDK_MIN_VERSION) < 0) {
+      throw new CliError(`app.json ios.sdk ${pin} is older than the ${SDK_MIN_VERSION} these generated shells need.`);
+    }
+    return pin;
+  }
+  try {
+    return await fetchLatestSdkVersion();
+  } catch (e) {
+    const kept = fallback ?? SDK_MIN_VERSION;
+    warn(`Could not resolve the latest SDK (${e.message}) — staying on ${kept}.`);
+    return kept;
+  }
+};
 var ensureRepo = (repo, wantTag, lock) => {
   const override = process.env.LECODES_PLUGINS_DIR;
   if (override) {
@@ -3802,7 +3865,7 @@ var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+
 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 auto|core|2d|3d|full]");
+    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 auto|core|2d|3d|full] [--sdk <version|latest>]");
   }
   const root = projectRoot();
   const iosDir = join11(root, "ios");
@@ -3814,6 +3877,9 @@ var appInit = async (args) => {
   if (variant !== "auto" && !SDK_VARIANTS.includes(variant)) {
     throw new CliError(`--variant must be auto, ${SDK_VARIANTS.join(", ")} (got "${variant}")`);
   }
+  const sdkFlag = flagStr(args, "sdk") ?? existing.ios?.sdk;
+  const sdkVersion = await resolveSdkVersion(process.env.LECODES_IOS_SDK ?? sdkFlag ?? "latest", null);
+  const sdk = sdkFlag === "latest" ? "latest" : sdkVersion;
   const name = flagStr(args, "name") ?? existing.name ?? basename4(root);
   const config = {
     ...existing,
@@ -3824,6 +3890,7 @@ var appInit = async (args) => {
       bundleId: flagStr(args, "bundle-id") ?? existing.ios?.bundleId ?? `com.example.${slugify(name)}`,
       teamId: flagStr(args, "team") ?? existing.ios?.teamId ?? "",
       variant,
+      sdk,
       buildNumber: existing.ios?.buildNumber ?? 1
     }
   };
@@ -3863,9 +3930,10 @@ ios/
   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 === "auto" ? "core" : variant, []));
+  write("LeCodesRuntime/Package.swift", runtimePackageTemplate(sdkVersion, variant === "auto" ? "core" : variant, []));
   write("LeCodesRuntime/Sources/LeCodesRuntime/LeCodesRuntime.swift", runtimeSwiftTemplate([]));
   log("");
+  log(`${c.green("sdk")}       lecodes-ios-sdk ${sdkVersion}${sdk === "latest" ? c.dim("  (ios.sdk: latest — re-resolved on every sync)") : c.dim("  (pinned in app.json ios.sdk — `lecodes app update` moves it)")}`);
   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`);
@@ -3898,18 +3966,18 @@ var resolveVariant = (requested, bundleJs) => {
   }
   return { variant, detected };
 };
-var ensureSdkResourcesBundle = async () => {
+var ensureSdkResourcesBundle = async (sdkVersion) => {
   const override = process.env.LECODES_SDK_RESOURCES;
   if (override) {
     note(`Using local resources bundle ${override} (LECODES_SDK_RESOURCES)`);
     return resolve2(override);
   }
-  const dir = join11(homedir2(), ".lecodes", "sdk-resources", SDK_PACKAGE_VERSION);
+  const dir = join11(homedir2(), ".lecodes", "sdk-resources", sdkVersion);
   const bundle = join11(dir, "LeCodesSDKResources.bundle");
   if (existsSync8(bundle))
     return bundle;
-  const url = `https://github.com/letary/lecodes-ios-sdk/releases/download/${SDK_PACKAGE_VERSION}/LeCodesSDKResources.bundle.zip`;
-  note(`Downloading LeCodesSDKResources.bundle (SDK ${SDK_PACKAGE_VERSION})…`);
+  const url = `https://github.com/${SDK_REPO}/releases/download/${sdkVersion}/LeCodesSDKResources.bundle.zip`;
+  note(`Downloading LeCodesSDKResources.bundle (SDK ${sdkVersion})…`);
   const res = await fetch(url);
   if (!res.ok)
     throw new CliError(`Resources bundle download failed (HTTP ${res.status}) — ${url}`);
@@ -3952,6 +4020,9 @@ var appSync = async (_args) => {
   if (requestedVariant !== "auto" && !SDK_VARIANTS.includes(requestedVariant)) {
     throw new CliError(`app.json ios.variant must be "auto" or one of ${SDK_VARIANTS.join(", ")} (got "${requestedVariant}").`);
   }
+  const linkedSdk = shellSdkVersion(iosDir);
+  const sdkPin = process.env.LECODES_IOS_SDK ?? config.ios.sdk ?? linkedSdk ?? "latest";
+  const sdkVersion = await resolveSdkVersion(sdkPin, linkedSdk);
   const lockPath = join11(root, "plugins.lock.json");
   const oldLock = readJson(lockPath)?.plugins ?? {};
   const pluginSpecs = Object.entries(config.plugins ?? {});
@@ -3972,6 +4043,9 @@ var appSync = async (_args) => {
     const dest = join11(sourcesDir, module);
     rmSync(dest, { recursive: true, force: true });
     cpSync(src, dest, { recursive: true });
+    if (ios.minSdk && VERSION_RE.test(ios.minSdk) && cmpVersion(sdkVersion, ios.minSdk) < 0) {
+      warn(`Plugin "${id}" needs lecodes-ios-sdk ${ios.minSdk} but the shell links ${sdkVersion} — run \`lecodes app update\` (or set app.json ios.sdk).`);
+    }
     for (const [key, value] of Object.entries(ios.infoPlist ?? {})) {
       (infoValues[key] ??= []).push(value);
     }
@@ -4003,9 +4077,11 @@ var appSync = async (_args) => {
     full: "uses the 3D + 2D engines"
   };
   log(`${c.green("variant")}   ${variant}${requestedVariant === "auto" ? ` (auto: ${WHY[detected]})` : " (forced by ios.variant)"}`);
+  const sdkWhy = sdkPin === "latest" ? "latest" : config.ios.sdk ? "pinned by ios.sdk" : "from the shell — set ios.sdk or run `lecodes app update`";
+  log(`${c.green("sdk")}       lecodes-ios-sdk ${sdkVersion}${c.dim(`  (${sdkWhy})`)}`);
   const sdkProvided = new Set;
   if (variant === "3d" || variant === "full") {
-    const sdkResources = await ensureSdkResourcesBundle();
+    const sdkResources = await ensureSdkResourcesBundle(sdkVersion);
     cpSync(sdkResources, join11(resourcesDir, "LeCodesSDKResources.bundle"), { recursive: true });
     for (const f2 of readdirSync4(sdkResources))
       if (f2 !== "Info.plist")
@@ -4043,7 +4119,7 @@ var appSync = async (_args) => {
   if (streamed.length > 0)
     log(`${c.green("remote")}    ${streamed.length} resource(s) stay on the server (resources.remote): ${streamed.map((r) => r.path).join(", ")}`);
   writeFileSync7(join11(iosDir, "README.md"), IOS_README);
-  writeFileSync7(join11(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(SDK_PACKAGE_VERSION, variant, runtimePlugins));
+  writeFileSync7(join11(iosDir, "LeCodesRuntime", "Package.swift"), runtimePackageTemplate(sdkVersion, variant, runtimePlugins));
   writeFileSync7(join11(sourcesDir, "LeCodesRuntime", "LeCodesRuntime.swift"), runtimeSwiftTemplate(runtimePlugins));
   const mergedKeys = {};
   for (const [key, values] of Object.entries(infoValues))
@@ -4058,7 +4134,7 @@ var appSync = async (_args) => {
   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);
   log("");
-  success(`Shell synced: app.js + ${runtimePlugins.length} plugin(s), variant ${variant}, v${config.version ?? "1.0.0"} (${config.ios.buildNumber ?? 1}).`);
+  success(`Shell synced: app.js + ${runtimePlugins.length} plugin(s), SDK ${sdkVersion}, 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) => {
@@ -4147,6 +4223,95 @@ var requireShell = () => {
   }
   return { root, config };
 };
+var latestPluginTag = (repo) => {
+  try {
+    return ensureRepo(repo, null, undefined).tag;
+  } catch {
+    return null;
+  }
+};
+var appUpdate = async (args) => {
+  const { root, config } = requireShell();
+  const iosDir = join11(root, "ios");
+  const checkOnly = flagBool(args, "check");
+  const wanted = flagStr(args, "sdk");
+  let changed = false;
+  const pin = config.ios.sdk ?? shellSdkVersion(iosDir) ?? "latest";
+  const current = pin === "latest" ? shellSdkVersion(iosDir) ?? SDK_MIN_VERSION : pin;
+  let nextPin;
+  if (wanted === "latest") {
+    nextPin = "latest";
+  } else if (wanted) {
+    if (!VERSION_RE.test(wanted))
+      throw new CliError(`--sdk must be "latest" or an exact x.y.z release (got "${wanted}").`);
+    if (cmpVersion(wanted, SDK_MIN_VERSION) < 0)
+      throw new CliError(`--sdk ${wanted} is older than the ${SDK_MIN_VERSION} these generated shells need.`);
+    nextPin = wanted;
+  } else {
+    nextPin = await fetchLatestSdkVersion();
+  }
+  const nextVersion = nextPin === "latest" ? await fetchLatestSdkVersion() : nextPin;
+  if (nextVersion === current && nextPin === pin) {
+    log(`${c.green("sdk")}       lecodes-ios-sdk ${current} ${c.dim("(already current)")}`);
+  } else if (nextVersion === current) {
+    log(`${c.green("sdk")}       lecodes-ios-sdk ${current} → ios.sdk ${nextPin} ${c.dim("(same version, pin mode changed)")}`);
+    changed = true;
+  } else {
+    const verb = cmpVersion(nextVersion, current) < 0 ? c.yellow("downgrade") : c.green("update");
+    log(`${c.green("sdk")}       lecodes-ios-sdk ${current} → ${c.bold(nextVersion)} ${c.dim(`(${verb})`)}`);
+    changed = true;
+  }
+  if (!checkOnly && nextPin !== pin) {
+    config.ios.sdk = nextPin;
+    writeJson(join11(root, "app.json"), config);
+  }
+  const lockPath = join11(root, "plugins.lock.json");
+  const lock = readJson(lockPath)?.plugins ?? {};
+  const specs = Object.entries(config.plugins ?? {});
+  if (specs.length > 0 && !flagBool(args, "no-plugins")) {
+    const kept = {};
+    for (const [id, spec] of specs) {
+      const entry = lock[id];
+      if (spec.startsWith("github:") && spec.includes("@")) {
+        log(`${c.green("plugin")}    ${id} ${c.dim(`pinned by app.json (${spec}) — not updated`)}`);
+        if (entry)
+          kept[id] = entry;
+        continue;
+      }
+      const repo = spec.startsWith("github:") ? spec.slice("github:".length) : FIRST_PARTY_PLUGINS[id];
+      const tag = repo ? latestPluginTag(repo) : null;
+      if (!tag) {
+        log(`${c.yellow("plugin")}    ${id} ${c.dim("could not read its latest tag — left as is")}`);
+        if (entry)
+          kept[id] = entry;
+        continue;
+      }
+      if (entry && entry.tag === tag) {
+        log(`${c.green("plugin")}    ${id} ${entry.tag} ${c.dim("(already current)")}`);
+        kept[id] = entry;
+        continue;
+      }
+      log(`${c.green("plugin")}    ${id} ${entry?.tag ?? "—"} → ${c.bold(tag)}`);
+      changed = true;
+    }
+    if (!checkOnly && existsSync8(lockPath))
+      writeJson(lockPath, { plugins: kept });
+  }
+  log("");
+  if (checkOnly) {
+    note(changed ? "Run `lecodes app update` to apply." : "Everything is up to date.");
+    return;
+  }
+  if (!changed) {
+    success("Already up to date.");
+    return;
+  }
+  if (flagBool(args, "no-sync")) {
+    success("Pins updated — run `lecodes app sync` to apply them to the shell.");
+    return;
+  }
+  await appSync({ _: [], flags: {} });
+};
 var appDoctor = async (_args) => {
   const { root, config } = requireShell();
   let failed = 0;
@@ -4177,6 +4342,18 @@ var appDoctor = async (_args) => {
     const hasResources = existsSync8(join11(root, "ios", "App", "Resources", "LeCodesSDKResources.bundle"));
     check(pkg.includes(`"LeCodesSDK-${variant}"`) && (!needsResources || hasResources), `SDK variant ${variant}${needsResources ? " (+ filament resources)" : ""}`, "run `lecodes app sync`");
   }
+  const linked = shellSdkVersion(join11(root, "ios"));
+  const pin = config.ios.sdk ?? "latest";
+  check(!!linked, `SDK ${linked ?? "version unreadable"}`, "run `lecodes app sync`");
+  if (linked && pin !== "latest") {
+    check(linked === pin, `SDK matches app.json ios.sdk (${pin})`, "run `lecodes app sync`");
+  }
+  if (linked) {
+    try {
+      const latest = await fetchLatestSdkVersion();
+      check(cmpVersion(linked, latest) >= 0, `SDK is the latest release (${latest})`, "run `lecodes app update`", false);
+    } catch {}
+  }
   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));
@@ -4303,6 +4480,8 @@ var app = async (args) => {
     return appInit(args);
   if (sub === "sync")
     return appSync(args);
+  if (sub === "update")
+    return appUpdate(args);
   if (sub === "plugin")
     return appPlugin(args);
   if (sub === "doctor")
@@ -4313,16 +4492,16 @@ var app = async (args) => {
     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`.");
+  throw new CliError("Usage: lecodes app <init ios | sync | update | open | plugin list|add|remove | doctor | build ios | upload ios> — see `lecodes help`.");
 };
 
 // src/commands/clone.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync6 } 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";
+import { dirname as dirname8, join as join12, relative as relative3, sep } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync8 } from "node:fs";
 var TSCONFIG = {
   compilerOptions: {
     target: "ES2020",
@@ -4339,17 +4518,60 @@ var TSCONFIG = {
   include: [`${LECODES_DIR}/types/**/*.d.ts`, "**/*.ts", "**/*.js"],
   exclude: ["node_modules"]
 };
+var listBundleFiles = (dir, base = dir) => {
+  if (!existsSync9(dir))
+    return [];
+  const out = [];
+  for (const name of readdirSync5(dir)) {
+    const path = join12(dir, name);
+    if (statSync3(path).isDirectory())
+      out.push(...listBundleFiles(path, base));
+    else
+      out.push(relative3(base, path).split(sep).join("/"));
+  }
+  return out;
+};
+var pruneEmptyDirs = (dir, root) => {
+  if (!existsSync9(dir) || !statSync3(dir).isDirectory())
+    return;
+  for (const name of readdirSync5(dir))
+    pruneEmptyDirs(join12(dir, name), root);
+  if (dir !== root && readdirSync5(dir).length === 0)
+    rmSync2(dir, { recursive: true });
+};
 var writeTypeBundle = (root, bundle) => {
   const typesDir = join12(root, LECODES_DIR, "types");
+  const before = new Set(listBundleFiles(typesDir));
+  const stats = { added: 0, updated: 0, removed: 0, total: Object.keys(bundle).length };
   for (const [path, text] of Object.entries(bundle)) {
     const dest = join12(typesDir, path);
+    if (!before.has(path))
+      stats.added++;
+    else if (readFileSync11(dest, "utf8") !== text)
+      stats.updated++;
+    else
+      continue;
     mkdirSync6(dirname8(dest), { recursive: true });
     writeFileSync8(dest, text);
   }
+  for (const path of before) {
+    if (path in bundle)
+      continue;
+    rmSync2(join12(typesDir, path));
+    stats.removed++;
+  }
+  pruneEmptyDirs(typesDir, typesDir);
+  return stats;
 };
-var materializeTypes = async (root, apiUrl) => {
-  writeTypeBundle(root, await getTypes(apiUrl));
+var bundleHash = (bundle) => sha256(Object.keys(bundle).sort().map((k) => `${k}\x00${bundle[k]}`).join("\x00"));
+var readProjectTypeBundle = (root) => {
+  const typesDir = join12(root, LECODES_DIR, "types");
+  const bundle = {};
+  for (const path of listBundleFiles(typesDir))
+    bundle[path] = readFileSync11(join12(typesDir, path), "utf8");
+  return bundle;
 };
+var materializeTypes = async (root, apiUrl) => writeTypeBundle(root, await getTypes(apiUrl));
 var readLocalTypeBundle = () => {
   const candidates = [
     join12(distRoot, "runtime", "sdk-types.json"),
@@ -4394,7 +4616,7 @@ var clone = async (args) => {
   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) {
+  if (existsSync10(root) && readdirSync6(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
   mkdirSync7(root, { recursive: true });
@@ -4414,7 +4636,7 @@ var clone = async (args) => {
 };
 
 // src/commands/create.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join13, resolve as resolve4 } from "node:path";
 
 // src/commands/projectTemplates.ts
@@ -4501,7 +4723,7 @@ var create = async (args) => {
     throw new CliError("Usage: lecodes create <name> [directory]");
   const dir = args._[1] ?? slug2(name);
   const root = resolve4(dir);
-  if (existsSync11(root) && readdirSync6(root).length > 0) {
+  if (existsSync11(root) && readdirSync7(root).length > 0) {
     throw new CliError(`Directory "${dir}" already exists and is not empty.`);
   }
   mkdirSync8(root, { recursive: true });
@@ -4520,7 +4742,7 @@ var create = async (args) => {
 };
 
 // src/commands/design.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync7, writeFileSync as writeFileSync11, appendFileSync } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync8, writeFileSync as writeFileSync11, appendFileSync } from "node:fs";
 import { basename as basename6, join as join15 } from "node:path";
 
 // src/compile/designCompile.ts
@@ -5507,7 +5729,7 @@ var listScreens = (designDir) => {
   const dir = join15(designDir, "screens");
   if (!existsSync13(dir))
     return [];
-  return readdirSync7(dir).filter((f2) => f2.endsWith(".ts") && !f2.startsWith(".")).map((f2) => f2.slice(0, -3)).sort();
+  return readdirSync8(dir).filter((f2) => f2.endsWith(".ts") && !f2.startsWith(".")).map((f2) => f2.slice(0, -3)).sort();
 };
 var readMetaSizes = (designDir) => {
   try {
@@ -5876,7 +6098,7 @@ 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 existsSync14, statSync as statSync3 } from "node:fs";
+import { createReadStream, existsSync as existsSync14, statSync as statSync4 } from "node:fs";
 import { join as join16 } from "node:path";
 
 // src/dev/clientTemplates.ts
@@ -6247,7 +6469,7 @@ var startDevServer = async (options) => {
         return sendText(res, 400, "text/plain", "Bad path");
       }
       const abs = join16(root, key.slice(1));
-      if (!existsSync14(abs) || !statSync3(abs).isFile())
+      if (!existsSync14(abs) || !statSync4(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);
@@ -6706,6 +6928,19 @@ lecodes test                     # run tests/*.flow.json — the starter ships w
 Scenario format + conventions: see [CLAUDE.md](./CLAUDE.md) (written for AI assistants, useful
 for humans too).
 
+## Put it on the platform
+
+This project is local-only. To give it a home on le.codes (web editor, sharing, OTA updates):
+
+\`\`\`
+lecodes login                    # once per machine
+lecodes link                     # create a project from this folder and connect it
+lecodes push -m "initial"        # upload it as the first checkpoint (--publish to go live)
+\`\`\`
+
+Already made the project in the web editor? \`lecodes link --project <uuid>\` adopts it — it
+shows what your next push would change there before connecting anything.
+
 ## Go native
 
 \`\`\`
@@ -6722,7 +6957,8 @@ lecodes app open             # open it in Xcode, build & run
   \`tests/.artifacts/\`
 - \`CLAUDE.md\` — guidance for AI assistants (the headless feedback loop + testability conventions)
 - \`assets/\` — images/fonts the app references (created on demand)
-- \`tsconfig.json\` + \`.lecodes/types/\` — generated IDE types (rewritten by the CLI; don't edit)
+- \`tsconfig.json\` + \`.lecodes/types/\` — generated IDE types (rewritten by the CLI; don't edit).
+  They come from the SDK bundled in the CLI; \`lecodes types\` refreshes them from the platform.
 - \`.lecodesignore\` — files a future \`lecodes push\` would skip
 
 Full command list: \`lecodes --help\`.
@@ -6763,6 +6999,231 @@ var init2 = async (args) => {
   log(`  ${c.bold(cd + "lecodes compile -o app.js")}  bundle it for LeCodes Desktop`);
 };
 
+// src/commands/link.ts
+import { existsSync as existsSync17 } from "node:fs";
+import { basename as basename11, join as join19, resolve as resolve6 } from "node:path";
+
+// src/commands/push.ts
+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);
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  const publish = flagBool(args, "publish");
+  const scan = scanProject(root, manifest);
+  const diff2 = diffLocal(manifest, scan);
+  if (!hasChanges(diff2)) {
+    if (publish) {
+      await publishProject(apiUrl, token, manifest.uuid);
+      success("No file changes — published the current project state.");
+    } else {
+      info(c.dim("Working tree clean — nothing to push."));
+    }
+    return;
+  }
+  const force = flagBool(args, "force");
+  if (!force && manifest.baseHeadId !== null) {
+    const commits = await getCommits(apiUrl, token, manifest.uuid);
+    if (commits.headId !== manifest.baseHeadId) {
+      throw new CliError("The project changed on the server since your last sync. Run `lecodes diff` to compare, `lecodes pull` to take the server's version, or `lecodes push --force` to overwrite.");
+    }
+    if (commits.dirty) {
+      const drift = serverPathDrift(await getProject(apiUrl, token, manifest.uuid), manifest);
+      if (drift) {
+        throw new CliError(`The project has uncommitted changes in the web editor your checkout doesn't have (${drift}). Run \`lecodes pull\` to take them, or \`lecodes push --force\` to overwrite the server.`);
+      }
+    }
+  }
+  if (force) {
+    const project = await getProject(apiUrl, token, manifest.uuid);
+    const serverDiff = computeServerDiff(project, scan);
+    if (serverDiff.length) {
+      info(c.yellow(`--force will overwrite the server. ${serverDiff.length} file${serverDiff.length === 1 ? "" : "s"} change:`));
+      const label = { added: c.green("  create  "), removed: c.red("  delete  "), modified: c.yellow("  update  ") };
+      for (const e of serverDiff)
+        log(label[e.status] + e.path + (e.binary ? c.dim(" (binary)") : ""));
+      if (process.stdin.isTTY && !flagBool(args, "y", "yes")) {
+        if (!await confirm("Overwrite the server with your local copy?", false)) {
+          info(c.dim("Aborted."));
+          return;
+        }
+      }
+    }
+  }
+  const message = (flagStr(args, "m", "message") ?? await prompt("Checkpoint message")) || "Update from lecodes CLI";
+  const sourceFor = (path) => manifest.files[path] ?? (diff2.moves.has(path) ? manifest.files[diff2.moves.get(path)] : undefined);
+  const files = [];
+  let uploaded = 0;
+  for (const file of scan.files) {
+    const source = sourceFor(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 = readFileSync17(file.absPath, "utf8");
+    } else if (!source || source.sha !== file.sha) {
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename10(file.path), readFileSync17(file.absPath));
+      entry.blobFileId = blob.id;
+      uploaded++;
+    }
+    files.push(entry);
+  }
+  const folders = scan.dirs.map((path) => ({ path }));
+  if (uploaded > 0)
+    info(c.dim(`Uploaded ${uploaded} binary file${uploaded === 1 ? "" : "s"}.`));
+  const res = await sync(apiUrl, token, manifest.uuid, { message, files, folders, publish });
+  if (!res.created) {
+    info(c.dim("Server reported no changes."));
+    if (publish)
+      reportPublish(res);
+    return;
+  }
+  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) ?? "" };
+  }
+  writeManifest(root, { ...manifest, baseHeadId: res.headId, files: newFiles });
+  const counts = [
+    diff2.added.length - diff2.moves.size && `${diff2.added.length - diff2.moves.size} added`,
+    diff2.modified.length && `${diff2.modified.length} modified`,
+    diff2.moves.size && `${diff2.moves.size} moved`,
+    diff2.deleted.length - diff2.moves.size && `${diff2.deleted.length - diff2.moves.size} deleted`
+  ].filter(Boolean).join(", ");
+  success(`Pushed checkpoint${res.seq ? ` #${res.seq}` : ""}${counts ? ` (${counts})` : ""}: ${message}`);
+  if (publish)
+    reportPublish(res);
+};
+var serverPathDrift = (project, manifest) => {
+  const pathById = buildPaths(project.assets);
+  const serverPaths = new Set(project.assets.filter((a) => a.type !== "folder").map((a) => pathById.get(a.id)));
+  const manifestPaths = new Set(Object.keys(manifest.files));
+  const added = [...serverPaths].filter((p) => !manifestPaths.has(p));
+  const removed = [...manifestPaths].filter((p) => !serverPaths.has(p));
+  const describe = (label, paths) => `${paths.length} ${label} on the server: ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? ", …" : ""}`;
+  const parts = [
+    added.length ? describe("added", added) : "",
+    removed.length ? describe("removed", removed) : ""
+  ].filter(Boolean);
+  return parts.length ? parts.join("; ") : null;
+};
+var reportPublish = (res) => {
+  if (res.published)
+    success("Published — the project is now live.");
+  else
+    warn(`Push landed, but publish failed: ${res.publishError ?? "unknown error"}`);
+};
+
+// src/commands/link.ts
+var kindOf2 = (type) => type === "file" ? "resource" : type;
+var manifestFromServer = (project) => {
+  const pathById = buildPaths(project.assets);
+  const files = {};
+  for (const asset of project.assets) {
+    if (asset.type === "folder")
+      continue;
+    files[pathById.get(asset.id)] = {
+      id: asset.id,
+      type: kindOf2(asset.type),
+      sha: asset.type === "file" ? "" : sha256(asset.text ?? "")
+    };
+  }
+  return files;
+};
+var confirmAdoption = async (root, project, files, args) => {
+  const count = Object.keys(files).length;
+  if (count === 0) {
+    info(c.dim(`Project ${c.bold(project.name)} is empty on the server — nothing to overwrite.`));
+    return true;
+  }
+  const scan = scanProject(root, { files });
+  const diff2 = computeServerDiff(project, scan);
+  if (diff2.length === 0) {
+    info(c.dim(`Project ${c.bold(project.name)} (${count} file(s)) already matches this folder.`));
+    return true;
+  }
+  warn(`${c.bold(project.name)} already has ${count} file(s). Your next push would change the server:`);
+  const label = { added: c.green("  create  "), removed: c.red("  delete  "), modified: c.yellow("  update  ") };
+  for (const e of diff2)
+    log(label[e.status] + e.path + (e.binary ? c.dim(" (binary)") : ""));
+  log("");
+  note("`lecodes pull` after linking takes the server's version instead.");
+  if (flagBool(args, "y", "yes") || flagBool(args, "force") || !process.stdin.isTTY)
+    return true;
+  return confirm("Link this folder to that project?", false);
+};
+var link = async (args) => {
+  const config = loadConfig();
+  const apiUrl = requireApiUrl(config);
+  const token = requireToken(config);
+  const dirArg = args._[0];
+  const root = dirArg ? resolve6(dirArg) : process.cwd();
+  if (!existsSync17(root))
+    throw new CliError(`No such directory: ${root}`);
+  if (existsSync17(join19(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
+    throw new CliError("This folder is already linked (.lecodes/manifest.json exists) — use `lecodes push`, or `lecodes link --force` to re-link it to another project.");
+  }
+  let enclosing = null;
+  try {
+    enclosing = findProjectRoot(root);
+  } catch {}
+  if (enclosing && enclosing !== root) {
+    throw new CliError(`This folder is inside the linked project at ${enclosing} — push from there instead.`);
+  }
+  const projectRef = flagStr(args, "project");
+  let uuid;
+  let name;
+  let files;
+  if (projectRef) {
+    uuid = parseUuid(projectRef);
+    const project = await getProject(apiUrl, token, uuid);
+    if (project.role === "viewer") {
+      throw new CliError(`You have view-only access to ${project.name} — linking would give you a checkout you can't push.`);
+    }
+    files = manifestFromServer(project);
+    if (!await confirmAdoption(root, project, files, args)) {
+      info(c.dim("Aborted — nothing was linked."));
+      return;
+    }
+    name = project.name;
+  } else {
+    name = flagStr(args, "name") ?? basename11(root);
+    info(c.dim(`Creating project ${c.bold(name)}…`));
+    uuid = (await createProject(apiUrl, token, name, flagStr(args, "team"))).uuid;
+    files = {};
+  }
+  const commits = await getCommits(apiUrl, token, uuid);
+  writeManifest(root, { uuid, apiUrl, name, baseHeadId: commits.headId, files });
+  log(`${c.green("linked")}    ${c.bold(name)} ${c.dim(uuid)}`);
+  if (!flagBool(args, "no-types")) {
+    await materializeTypes(root, apiUrl);
+    writeTsconfig(root);
+    log(`${c.green("written")}   ${LECODES_DIR}/types/ + tsconfig.json  ${c.dim("(from the server)")}`);
+  }
+  writeDefaultIgnore(root);
+  if (flagBool(args, "push")) {
+    log("");
+    if (root !== process.cwd())
+      process.chdir(root);
+    await push(args);
+    return;
+  }
+  const pending = scanProject(root, { files }).files.filter((f2) => {
+    const known = files[f2.path];
+    return !known || known.sha !== f2.sha;
+  }).length;
+  log("");
+  success(`Connected to ${c.bold(name)}.`);
+  const cd = dirArg ? `cd ${dirArg} && ` : "";
+  log(`  ${c.bold(cd + "lecodes status")}             ${pending} file(s) would go up`);
+  log(`  ${c.bold(cd + 'lecodes push -m "initial"')}  push them as the first checkpoint`);
+  log(`  ${c.dim("(add --publish to deploy it live in the same step)")}`);
+};
+
 // src/commands/login.ts
 var login = async (args) => {
   const config = loadConfig();
@@ -6775,8 +7236,8 @@ var login = async (args) => {
 };
 
 // src/commands/render.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync17, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname11, resolve as resolve6 } from "node:path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname11, resolve as resolve7 } from "node:path";
 
 // src/compile/headlessBundle.ts
 var LOCAL_ASSET_SCHEME2 = "lecodesfile://";
@@ -6877,7 +7338,7 @@ var requireRenderer = async () => {
 };
 var fileScenarioIO = (dir) => ({
   write: (relPath, data) => {
-    const abs = resolve6(dir, relPath);
+    const abs = resolve7(dir, relPath);
     mkdirSync13(dirname11(abs), { recursive: true });
     writeFileSync14(abs, data);
   }
@@ -6887,9 +7348,9 @@ var resolveFixtures = (value, baseDir) => {
     return;
   let map = value;
   if (typeof value === "string") {
-    const abs = resolve6(baseDir, value);
+    const abs = resolve7(baseDir, value);
     try {
-      map = JSON.parse(readFileSync17(abs, "utf8"));
+      map = JSON.parse(readFileSync18(abs, "utf8"));
     } catch (e) {
       throw new CliError(`Can't read fixtures "${value}": ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -6902,7 +7363,7 @@ var resolveFixtures = (value, baseDir) => {
 var readScenarioFile = (path) => {
   let raw;
   try {
-    raw = JSON.parse(readFileSync17(resolve6(path), "utf8"));
+    raw = JSON.parse(readFileSync18(resolve7(path), "utf8"));
   } catch (e) {
     throw new CliError(`Can't read scenario "${path}": ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -6932,7 +7393,7 @@ var render = async (args) => {
   const settleStr = flagStr(args, "settle") ?? (scenario?.settle !== undefined ? String(scenario.settle) : undefined);
   const timeStr = flagStr(args, "time");
   const onConsole = flagBool(args, "logs") ? (level, text2) => logErr(`${c.dim(`[${level}]`)} ${text2}`) : undefined;
-  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname11(resolve6(scriptFlag)) : ".");
+  const envelopeFixtures = resolveFixtures(scenario?.fixtures, scriptFlag !== undefined ? dirname11(resolve7(scriptFlag)) : ".");
   const flagFixtures = resolveFixtures(flagStr(args, "fixtures"), ".");
   const fixtures = envelopeFixtures || flagFixtures ? { ...envelopeFixtures, ...flagFixtures } : undefined;
   if (fixtures) {
@@ -6971,7 +7432,7 @@ var render = async (args) => {
   ${c.red(st.error ?? "failed")}`);
       }
       if (!result2.ok && result2.failureArtifacts.length > 0) {
-        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p) => resolve6(outDir, p)).join(", ")}`));
+        logErr(c.dim(`  failing frame: ${result2.failureArtifacts.map((p) => resolve7(outDir, p)).join(", ")}`));
       }
       logErr(result2.ok ? c.green(`✓ ${result2.steps.length}/${steps.length} steps passed`) : c.red(`✗ failed at step ${result2.steps.length} of ${steps.length}`));
       return done((cb) => cb(), result2.ok ? 0 : 1);
@@ -6993,7 +7454,7 @@ var render = async (args) => {
     if (isNullSink(pngFlag)) {
       note(`Discarded PNG (${pngFlag})`);
     } else {
-      writeFileSync14(resolve6(pngFlag), png);
+      writeFileSync14(resolve7(pngFlag), png);
       note(`Wrote ${pngFlag} (${png.length} bytes, ${width}x${height})`);
     }
     return done((cb) => cb());
@@ -7008,7 +7469,7 @@ var render = async (args) => {
     return done((cb) => cb());
   }
   if (out) {
-    writeFileSync14(resolve6(out), result.text);
+    writeFileSync14(resolve7(out), result.text);
     note(`Wrote ${out} (${result.text.length} bytes)`);
     return done((cb) => cb());
   }
@@ -7019,8 +7480,8 @@ var render = async (args) => {
 };
 
 // src/commands/pull.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync14, rmSync as rmSync2, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname12, join as join19 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync14, rmSync as rmSync3, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname12, join as join20 } from "node:path";
 var pull = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -7040,9 +7501,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 = join19(root, ...path.replace(/^\//, "").split("/"));
-      if (existsSync17(abs))
-        rmSync2(abs);
+      const abs = join20(root, ...path.replace(/^\//, "").split("/"));
+      if (existsSync18(abs))
+        rmSync3(abs);
     }
   }
   const files = await materializeAssets(root, project, apiUrl, token, progress);
@@ -7055,7 +7516,7 @@ var pull = async (args) => {
   writeManifest(root, { ...manifest, name: project.name, baseHeadId: commits.headId, files });
   success(`Pulled latest into ${c.bold(manifest.name)}.`);
 };
-var kindOf2 = (type) => type === "file" ? "resource" : type;
+var kindOf3 = (type) => type === "file" ? "resource" : type;
 var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
   const pathById = buildPaths(project.assets);
   const byPath = new Map;
@@ -7079,7 +7540,7 @@ 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 = join19(root, ...key.replace(/^\//, "").split("/"));
+    const abs = join20(root, ...key.replace(/^\//, "").split("/"));
     mkdirSync14(dirname12(abs), { recursive: true });
     let sha;
     if (asset.type === "file") {
@@ -7093,7 +7554,7 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
       writeFileSync15(abs, text);
       sha = sha256(text);
     }
-    files[key] = { id: asset.id, type: kindOf2(asset.type), sha };
+    files[key] = { id: asset.id, type: kindOf3(asset.type), sha };
     info(c.green(`  pulled  ${key}`));
   }
   writeManifest(root, { ...manifest, files });
@@ -7101,137 +7562,22 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
   info(c.dim("Local edits to other files are untouched. Run `lecodes diff` to review, then `lecodes push --force`."));
 };
 
-// src/commands/push.ts
-import { basename as basename10 } from "node:path";
-import { readFileSync as readFileSync18 } from "node:fs";
-var push = async (args) => {
-  const root = findProjectRoot(process.cwd());
-  const manifest = readManifest(root);
-  const config = loadConfig();
-  const apiUrl = requireApiUrl(config);
-  const token = requireToken(config);
-  const publish = flagBool(args, "publish");
-  const scan = scanProject(root, manifest);
-  const diff2 = diffLocal(manifest, scan);
-  if (!hasChanges(diff2)) {
-    if (publish) {
-      await publishProject(apiUrl, token, manifest.uuid);
-      success("No file changes — published the current project state.");
-    } else {
-      info(c.dim("Working tree clean — nothing to push."));
-    }
-    return;
-  }
-  const force = flagBool(args, "force");
-  if (!force && manifest.baseHeadId !== null) {
-    const commits = await getCommits(apiUrl, token, manifest.uuid);
-    if (commits.headId !== manifest.baseHeadId) {
-      throw new CliError("The project changed on the server since your last sync. Run `lecodes diff` to compare, `lecodes pull` to take the server's version, or `lecodes push --force` to overwrite.");
-    }
-    if (commits.dirty) {
-      const drift = serverPathDrift(await getProject(apiUrl, token, manifest.uuid), manifest);
-      if (drift) {
-        throw new CliError(`The project has uncommitted changes in the web editor your checkout doesn't have (${drift}). Run \`lecodes pull\` to take them, or \`lecodes push --force\` to overwrite the server.`);
-      }
-    }
-  }
-  if (force) {
-    const project = await getProject(apiUrl, token, manifest.uuid);
-    const serverDiff = computeServerDiff(project, scan);
-    if (serverDiff.length) {
-      info(c.yellow(`--force will overwrite the server. ${serverDiff.length} file${serverDiff.length === 1 ? "" : "s"} change:`));
-      const label = { added: c.green("  create  "), removed: c.red("  delete  "), modified: c.yellow("  update  ") };
-      for (const e of serverDiff)
-        log(label[e.status] + e.path + (e.binary ? c.dim(" (binary)") : ""));
-      if (process.stdin.isTTY && !flagBool(args, "y", "yes")) {
-        if (!await confirm("Overwrite the server with your local copy?", false)) {
-          info(c.dim("Aborted."));
-          return;
-        }
-      }
-    }
-  }
-  const message = (flagStr(args, "m", "message") ?? await prompt("Checkpoint message")) || "Update from lecodes CLI";
-  const sourceFor = (path) => manifest.files[path] ?? (diff2.moves.has(path) ? manifest.files[diff2.moves.get(path)] : undefined);
-  const files = [];
-  let uploaded = 0;
-  for (const file of scan.files) {
-    const source = sourceFor(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 = readFileSync18(file.absPath, "utf8");
-    } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename10(file.path), readFileSync18(file.absPath));
-      entry.blobFileId = blob.id;
-      uploaded++;
-    }
-    files.push(entry);
-  }
-  const folders = scan.dirs.map((path) => ({ path }));
-  if (uploaded > 0)
-    info(c.dim(`Uploaded ${uploaded} binary file${uploaded === 1 ? "" : "s"}.`));
-  const res = await sync(apiUrl, token, manifest.uuid, { message, files, folders, publish });
-  if (!res.created) {
-    info(c.dim("Server reported no changes."));
-    if (publish)
-      reportPublish(res);
-    return;
-  }
-  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) ?? "" };
-  }
-  writeManifest(root, { ...manifest, baseHeadId: res.headId, files: newFiles });
-  const counts = [
-    diff2.added.length - diff2.moves.size && `${diff2.added.length - diff2.moves.size} added`,
-    diff2.modified.length && `${diff2.modified.length} modified`,
-    diff2.moves.size && `${diff2.moves.size} moved`,
-    diff2.deleted.length - diff2.moves.size && `${diff2.deleted.length - diff2.moves.size} deleted`
-  ].filter(Boolean).join(", ");
-  success(`Pushed checkpoint${res.seq ? ` #${res.seq}` : ""}${counts ? ` (${counts})` : ""}: ${message}`);
-  if (publish)
-    reportPublish(res);
-};
-var serverPathDrift = (project, manifest) => {
-  const pathById = buildPaths(project.assets);
-  const serverPaths = new Set(project.assets.filter((a) => a.type !== "folder").map((a) => pathById.get(a.id)));
-  const manifestPaths = new Set(Object.keys(manifest.files));
-  const added = [...serverPaths].filter((p) => !manifestPaths.has(p));
-  const removed = [...manifestPaths].filter((p) => !serverPaths.has(p));
-  const describe = (label, paths) => `${paths.length} ${label} on the server: ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? ", …" : ""}`;
-  const parts = [
-    added.length ? describe("added", added) : "",
-    removed.length ? describe("removed", removed) : ""
-  ].filter(Boolean);
-  return parts.length ? parts.join("; ") : null;
-};
-var reportPublish = (res) => {
-  if (res.published)
-    success("Published — the project is now live.");
-  else
-    warn(`Push landed, but publish failed: ${res.publishError ?? "unknown error"}`);
-};
-
 // src/commands/scene.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync4, writeFileSync as writeFileSync16 } from "node:fs";
-import { basename as basename11, dirname as dirname13, join as join21, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync20, readdirSync as readdirSync9, statSync as statSync5, writeFileSync as writeFileSync16 } from "node:fs";
+import { basename as basename12, dirname as dirname13, join as join22, resolve as resolve8 } from "node:path";
 
 // src/compile/sceneCompile.ts
-import { existsSync as existsSync18, readFileSync as readFileSync19 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync19 } from "node:fs";
+import { join as join21 } from "node:path";
 var TEXT_EXT = /\.(ts|js|json|svg|txt|md)$/i;
 var rel = (key) => key.replace(/^\//, "");
 var resolveHarness = (loadSceneHarness2) => {
-  const inRepo = join20(distRoot, "..", "projects", "src", "scene-editor");
+  const inRepo = join21(distRoot, "..", "projects", "src", "scene-editor");
   try {
-    return loadSceneHarness2(existsSync18(inRepo) ? inRepo : undefined);
+    return loadSceneHarness2(existsSync19(inRepo) ? inRepo : undefined);
   } catch {
-    const vendored = join20(distRoot, "runtime", "scene-harness.json");
-    if (existsSync18(vendored))
+    const vendored = join21(distRoot, "runtime", "scene-harness.json");
+    if (existsSync19(vendored))
       return JSON.parse(readFileSync19(vendored, "utf8"));
     throw new CliError("scene-editor harness sources not found — reinstall the CLI or set LECODES_SCENE_HARNESS_DIR.");
   }
@@ -7284,22 +7630,22 @@ var getContext2 = (args) => {
     manifest = null;
     const pathArg = args._[0];
     if (pathArg) {
-      const abs = resolve7(process.cwd(), pathArg);
-      if (existsSync19(abs) && statSync4(abs).isDirectory())
+      const abs = resolve8(process.cwd(), pathArg);
+      if (existsSync20(abs) && statSync5(abs).isDirectory())
         root = abs;
-      else if (abs.endsWith(".scene.ts") && existsSync19(abs))
+      else if (abs.endsWith(".scene.ts") && existsSync20(abs))
         root = dirname13(abs);
       else
         throw new CliError(`No such folder or .scene.ts: ${pathArg}`);
     }
   }
-  return { root, manifest, name: manifest?.name ?? basename11(root) };
+  return { root, manifest, name: manifest?.name ?? basename12(root) };
 };
 var writeMcpConfig2 = (root, port) => {
-  const path = join21(root, ".mcp.json");
+  const path = join22(root, ".mcp.json");
   const entry = { type: "http", url: `http://localhost:${port}/mcp` };
   let config = {};
-  if (existsSync19(path)) {
+  if (existsSync20(path)) {
     try {
       config = JSON.parse(readFileSync20(path, "utf8"));
     } catch {
@@ -7320,11 +7666,11 @@ var writeMcpConfig2 = (root, port) => {
 };
 var countScenes = (dir) => {
   let n = 0;
-  for (const name of readdirSync8(dir)) {
+  for (const name of readdirSync9(dir)) {
     if (name === "node_modules" || name.startsWith("."))
       continue;
-    const full = join21(dir, name);
-    if (statSync4(full).isDirectory())
+    const full = join22(dir, name);
+    if (statSync5(full).isDirectory())
       n += countScenes(full);
     else if (name.endsWith(".scene.ts"))
       n++;
@@ -7394,8 +7740,8 @@ var status = async (_args) => {
 };
 
 // src/commands/test.ts
-import { existsSync as existsSync20, readFileSync as readFileSync21, readdirSync as readdirSync9 } from "node:fs";
-import { dirname as dirname14, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync21, readdirSync as readdirSync10 } from "node:fs";
+import { dirname as dirname14, resolve as resolve9 } from "node:path";
 var deriveDesignFlows = (meta, entryScreen) => {
   const edges = meta.edges ?? [];
   const isState = (id) => id.includes("@");
@@ -7481,34 +7827,34 @@ var readFlowFile = (abs, displayName) => {
 var test = async (args) => {
   const { js, warnings, useLocalAssets, root } = await compileHeadlessBundle(args);
   const renderer = await requireRenderer();
-  const testsDir = resolve8(root, flagStr(args, "dir") ?? "tests");
-  const designMetaPath = resolve8(root, flagStr(args, "design-dir") ?? "design", "meta.json");
+  const testsDir = resolve9(root, flagStr(args, "dir") ?? "tests");
+  const designMetaPath = resolve9(root, flagStr(args, "design-dir") ?? "design", "meta.json");
   const asJson = flagBool(args, "json");
   const out = asJson ? logErr : log;
   const cases = [];
   if (args._.length > 0) {
     for (const given of args._) {
-      const candidates = [resolve8(given), resolve8(testsDir, given), resolve8(testsDir, `${given}.flow.json`)];
-      const abs = candidates.find((p) => existsSync20(p));
+      const candidates = [resolve9(given), resolve9(testsDir, given), resolve9(testsDir, `${given}.flow.json`)];
+      const abs = candidates.find((p) => existsSync21(p));
       if (!abs)
         throw new CliError(`No such test: "${given}" (looked in ${testsDir}).`);
       cases.push(readFlowFile(abs, given));
     }
-  } else if (existsSync20(testsDir)) {
-    for (const f2 of readdirSync9(testsDir).filter((f3) => f3.endsWith(".flow.json")).sort()) {
-      cases.push(readFlowFile(resolve8(testsDir, f2), f2));
+  } else if (existsSync21(testsDir)) {
+    for (const f2 of readdirSync10(testsDir).filter((f3) => f3.endsWith(".flow.json")).sort()) {
+      cases.push(readFlowFile(resolve9(testsDir, f2), f2));
     }
   }
   const fixturesFlag = flagStr(args, "fixtures");
-  const defaultPack = resolve8(testsDir, "fixtures.json");
-  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync20(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
+  const defaultPack = resolve9(testsDir, "fixtures.json");
+  const flowFixtures = fixturesFlag !== undefined ? resolveFixtures(fixturesFlag, ".") : existsSync21(defaultPack) ? resolveFixtures("fixtures.json", testsDir) : undefined;
   const flowsOnly = flagBool(args, "flows");
   const wantFlows = !flagBool(args, "no-flows") && args._.length === 0;
   if (flowsOnly)
     cases.length = 0;
   let skipped = [];
   let entryScreen = null;
-  if ((wantFlows || flowsOnly) && existsSync20(designMetaPath)) {
+  if ((wantFlows || flowsOnly) && existsSync21(designMetaPath)) {
     let meta;
     try {
       meta = JSON.parse(readFileSync21(designMetaPath, "utf8"));
@@ -7543,7 +7889,7 @@ var test = async (args) => {
   }, timeoutMs);
   killer.unref?.();
   const onConsole = flagBool(args, "logs") ? (level, text) => logErr(`${c.dim(`[${level}]`)} ${text}`) : undefined;
-  const artifactsRoot = resolve8(root, flagStr(args, "artifacts") ?? resolve8(testsDir, ".artifacts"));
+  const artifactsRoot = resolve9(root, flagStr(args, "artifacts") ?? resolve9(testsDir, ".artifacts"));
   const results = [];
   for (const kase of cases) {
     const flagSettle = flagStr(args, "settle");
@@ -7561,14 +7907,14 @@ var test = async (args) => {
         onConsole
       });
       try {
-        const io = fileScenarioIO(resolve8(artifactsRoot, slug3(kase.name)));
+        const io = fileScenarioIO(resolve9(artifactsRoot, slug3(kase.name)));
         const outcome = await renderer.runScenario(session, steps, io);
         result = {
           name: kase.name,
           kind: kase.kind,
           ok: outcome.ok,
           steps: outcome.steps.map((s) => ({ desc: s.desc, ok: s.ok, error: s.error })),
-          artifacts: outcome.failureArtifacts.map((p) => resolve8(artifactsRoot, slug3(kase.name), p))
+          artifacts: outcome.failureArtifacts.map((p) => resolve9(artifactsRoot, slug3(kase.name), p))
         };
       } finally {
         session.dispose();
@@ -7624,23 +7970,86 @@ var test = async (args) => {
   process.exit(failed > 0 ? 1 : 0);
 };
 
+// src/commands/types.ts
+import { resolve as resolve10 } from "node:path";
+var label = (bundle) => `${Object.keys(bundle).length} file(s)`;
+var types = async (args) => {
+  const dirArg = args._[0];
+  const root = dirArg ? resolve10(dirArg) : (() => {
+    try {
+      return findProjectRoot(process.cwd());
+    } catch {
+      return process.cwd();
+    }
+  })();
+  const useLocal = flagBool(args, "local");
+  const checkOnly = flagBool(args, "check");
+  const local = readLocalTypeBundle();
+  let bundle = null;
+  let source = "";
+  if (useLocal) {
+    if (!local)
+      throw new CliError("This CLI ships no vendored type bundle — drop --local to fetch them from the server.");
+    bundle = local;
+    source = "the CLI's bundled SDK";
+  } else {
+    const apiUrl = normalizeApiUrl(flagStr(args, "api") ?? loadConfig().apiUrl ?? DEFAULT_API);
+    try {
+      bundle = await getTypes(apiUrl);
+      source = apiUrl;
+    } catch (e) {
+      if (!local || checkOnly)
+        throw e;
+      warn(`${e.message}`);
+      bundle = local;
+      source = "the CLI's bundled SDK (server unreachable)";
+    }
+  }
+  log(`${c.green("source")}    ${source} — ${label(bundle)}`);
+  const onDisk = readProjectTypeBundle(root);
+  const same = bundleHash(onDisk) === bundleHash(bundle);
+  if (checkOnly) {
+    if (Object.keys(onDisk).length === 0)
+      throw new CliError(`No types in ${LECODES_DIR}/types/ — run \`lecodes types\`.`);
+    if (!same)
+      throw new CliError(`Types are out of date (${label(onDisk)} on disk) — run \`lecodes types\`.`);
+    success(`Types are up to date (${label(onDisk)}).`);
+    return;
+  }
+  const stats = writeTypeBundle(root, bundle);
+  writeTsconfig(root);
+  const changes = [
+    stats.added ? `${stats.added} added` : null,
+    stats.updated ? `${stats.updated} updated` : null,
+    stats.removed ? `${stats.removed} removed` : null
+  ].filter(Boolean);
+  log(`${c.green("written")}   ${LECODES_DIR}/types/ + tsconfig.json  ${c.dim(changes.length ? `(${changes.join(", ")})` : "(already current)")}`);
+  if (!useLocal && local && bundleHash(local) !== bundleHash(bundle)) {
+    warn("The server's SDK surface differs from the one this CLI compiles with — if something autocompletes but fails to compile, update the CLI (`npm i -g lecodes-cli@latest`) or re-run with --local.");
+  }
+  log("");
+  success(stats.added + stats.updated + stats.removed > 0 ? "Types synced." : "Types already current.");
+  if (!dirArg)
+    note("Reload the TypeScript server in your editor to pick them up.");
+};
+
 // src/index.ts
-import { existsSync as existsSync22, readFileSync as readFileSync23, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync23, realpathSync as realpathSync2 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname16, join as join23 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname16, join as join24 } from "node:path";
 
 // src/commands/install.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { appendFileSync as appendFileSync2, chmodSync, cpSync as cpSync2, existsSync as existsSync21, mkdirSync as mkdirSync15, readFileSync as readFileSync22, realpathSync, rmSync as rmSync3, symlinkSync } from "node:fs";
+import { appendFileSync as appendFileSync2, chmodSync, cpSync as cpSync2, existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync22, realpathSync, rmSync as rmSync4, symlinkSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename12, delimiter, dirname as dirname15, join as join22, resolve as resolve9, sep } from "node:path";
+import { basename as basename13, delimiter, dirname as dirname15, join as join23, resolve as resolve11, sep as sep2 } from "node:path";
 var isWin = process.platform === "win32";
 var HOME = homedir3();
 var safeRealpath = (p) => {
   try {
     return realpathSync(p);
   } catch {
-    return resolve9(p);
+    return resolve11(p);
   }
 };
 var onPath = (dir) => {
@@ -7657,12 +8066,12 @@ var onPath = (dir) => {
 };
 var install = async (args) => {
   const bundle = dirname15(process.execPath);
-  const exeName = basename12(process.execPath);
+  const exeName = basename13(process.execPath);
   const chiselName = isWin ? "chisel.exe" : "chisel";
-  if (!existsSync21(join22(bundle, "runtime")) || !existsSync21(join22(bundle, chiselName))) {
+  if (!existsSync22(join23(bundle, "runtime")) || !existsSync22(join23(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((f2) => existsSync21(join22(bundle, f2)));
+  const companions = [exeName, chiselName, "runtime", "README.txt"].filter((f2) => existsSync22(join23(bundle, f2)));
   if (isWin)
     return installWindows(args, bundle, companions);
   return installUnix(args, bundle, companions);
@@ -7672,9 +8081,9 @@ var copyBundle = (bundle, target, companions) => {
   if (safeRealpath(target) === safeRealpath(bundle))
     return;
   for (const f2 of companions) {
-    const dest = join22(target, f2);
-    rmSync3(dest, { recursive: true, force: true });
-    cpSync2(join22(bundle, f2), dest, { recursive: true });
+    const dest = join23(target, f2);
+    rmSync4(dest, { recursive: true, force: true });
+    cpSync2(join23(bundle, f2), dest, { recursive: true });
   }
 };
 var permError = (e, dir, system) => {
@@ -7686,41 +8095,41 @@ var permError = (e, dir, system) => {
 };
 var installUnix = (args, bundle, companions) => {
   const system = flagBool(args, "system");
-  const libDir = resolve9(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join22(HOME, ".local", "lib", "lecodes-cli")));
-  const binDir = resolve9(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join22(HOME, ".local", "bin")));
-  const link = join22(binDir, "lecodes");
+  const libDir = resolve11(flagStr(args, "dir") ?? (system ? "/usr/local/lib/lecodes-cli" : join23(HOME, ".local", "lib", "lecodes-cli")));
+  const binDir = resolve11(flagStr(args, "bin") ?? (system ? "/usr/local/bin" : join23(HOME, ".local", "bin")));
+  const link2 = join23(binDir, "lecodes");
   try {
     copyBundle(bundle, libDir, companions);
-    chmodSync(join22(libDir, "lecodes"), 493);
-    chmodSync(join22(libDir, "chisel"), 493);
+    chmodSync(join23(libDir, "lecodes"), 493);
+    chmodSync(join23(libDir, "chisel"), 493);
   } catch (e) {
     throw permError(e, libDir, system);
   }
   try {
     mkdirSync15(binDir, { recursive: true });
-    rmSync3(link, { force: true });
-    symlinkSync(join22(libDir, "lecodes"), link);
+    rmSync4(link2, { force: true });
+    symlinkSync(join23(libDir, "lecodes"), link2);
   } catch (e) {
     throw permError(e, binDir, system);
   }
   success(`Installed to ${c.bold(libDir)}`);
-  log(`  ${c.dim(link + " → " + join22(libDir, "lecodes"))}`);
+  log(`  ${c.dim(link2 + " → " + join23(libDir, "lecodes"))}`);
   finishPathUnix(args, binDir);
 };
 var shellRc = () => {
-  const shell = basename12(process.env.SHELL ?? "");
+  const shell = basename13(process.env.SHELL ?? "");
   if (shell === "zsh")
-    return { file: join22(HOME, ".zshrc"), name: "~/.zshrc" };
+    return { file: join23(HOME, ".zshrc"), name: "~/.zshrc" };
   if (shell === "bash")
-    return { file: join22(HOME, ".bashrc"), name: "~/.bashrc" };
-  return { file: join22(HOME, ".profile"), name: "~/.profile" };
+    return { file: join23(HOME, ".bashrc"), name: "~/.bashrc" };
+  return { file: join23(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 = existsSync21(file) ? readFileSync22(file, "utf8") : "";
+    const existing = existsSync22(file) ? readFileSync22(file, "utf8") : "";
     if (existing.includes(line))
       return name;
     appendFileSync2(file, `${existing && !existing.endsWith(`
@@ -7758,7 +8167,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 = resolve9(flagStr(args, "dir") ?? join22(process.env.LOCALAPPDATA ?? join22(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
+  const target = resolve11(flagStr(args, "dir") ?? join23(process.env.LOCALAPPDATA ?? join23(HOME, "AppData", "Local"), "Programs", "lecodes-cli"));
   try {
     copyBundle(bundle, target, companions);
   } catch (e) {
@@ -7797,7 +8206,7 @@ var addToUserPathWindows = (dir) => {
 var STANDALONE = (() => {
   const dir = dirname16(process.execPath);
   const chisel = process.platform === "win32" ? "chisel.exe" : "chisel";
-  return existsSync22(join23(dir, "runtime")) && existsSync22(join23(dir, chisel));
+  return existsSync23(join24(dir, "runtime")) && existsSync23(join24(dir, chisel));
 })();
 var INSTALLED = STANDALONE && (() => {
   const exe = process.platform === "win32" ? "lecodes.exe" : "lecodes";
@@ -7812,8 +8221,8 @@ var INSTALLED = STANDALONE && (() => {
     if (!d)
       return false;
     try {
-      const cand = join23(d, exe);
-      return existsSync22(cand) && realpathSync2(cand) === self;
+      const cand = join24(d, exe);
+      return existsSync23(cand) && realpathSync2(cand) === self;
     } catch {
       return false;
     }
@@ -7844,6 +8253,19 @@ ${c.bold("Commands:")}
                                   --team <uuid>   create it inside a team
   clone <uuid|url> [dir]        Download a project's files + types into a new folder
                                   --no-types      skip the .d.ts / tsconfig generation
+  link [dir]                    Connect an existing local folder (e.g. one made by 'lecodes
+                                  init') to the platform — the reverse of clone. Creates a
+                                  project on the server, writes .lecodes/manifest.json and
+                                  refreshes the types; nothing is uploaded until you push
+                                  --name <s>          project name (default: folder name)
+                                  --team <uuid>       create it inside a team
+                                  --project <uuid|url>  adopt an EXISTING project instead —
+                                                      prints what your next push would change
+                                                      on its server tree, and confirms first
+                                  --push [-m <msg>]   push right after linking (--publish to
+                                                      deploy it live in the same step)
+                                  --force             re-link a folder that's already linked
+                                  --no-types          skip the .d.ts / tsconfig refresh
   status                        Show local changes vs the last sync
   diff [path…]                  Show a unified diff of local vs the current server state
                                   --name-only     list changed paths + status only
@@ -7907,6 +8329,13 @@ ${c.bold("Commands:")}
                                   --artifacts <dir>  failure-artifact folder override
                                   (+ the render timing flags: --width/--height, --settle,
                                    --device, --safe-area, --wait-network, --logs, --entry)
+  types [dir]                   Refresh the IDE types (.lecodes/types/ + tsconfig.json) — by
+                                  default from the server, so a project scaffolded offline picks
+                                  up the SDK the platform actually runs
+                                  --local            use the SDK bundled in this CLI instead
+                                  --check            report drift only, don't write (non-zero exit)
+                                  --api <url>        server to fetch from (default: the logged-in
+                                                       one, else https://le.codes)
   design [serve]                LeCodes Design — a live canvas of screens for AI-driven prototyping
                                   (needs the optional 'lecodes-design' package; works inside a
                                    cloned project or standalone in any folder)
@@ -7933,6 +8362,9 @@ ${c.bold("Commands:")}
                                   --variant <v>      SDK variant: auto (default — sync picks the
                                                      smallest of core/2d/3d/full covering what
                                                      the bundle uses), or one of those to pin
+                                  --sdk <v>          native SDK release (default: the newest one,
+                                                     pinned in app.json ios.sdk); 'latest' floats
+                                                     it — every sync re-resolves
   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]}
@@ -7941,6 +8373,13 @@ ${c.bold("Commands:")}
                                   plugins (pinned in plugins.lock.json), regenerate the
                                   CLI-owned shell files. app.json "update": true (or
                                   {"url": …}) enables native OTA JS updates at launch
+  app update                    Move the shell's pins forward — app.json ios.sdk to the newest
+                                  lecodes-ios-sdk release, plugins.lock.json to each plugin's
+                                  newest tag — then re-sync
+                                  --sdk <v|latest>   pin that release instead of the newest
+                                  --check            report available updates, write nothing
+                                  --no-plugins       only move the SDK pin
+                                  --no-sync          update the pins without re-syncing
   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)
@@ -7955,7 +8394,7 @@ ${c.bold("Commands:")}
                                                        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, test, design, scene, dev, app };
+var commands = { init: init2, login, create, clone, link, status, diff, pull, push, compile: compile2, preview: previewLegacy, render, test, types, design, scene, dev, app };
 if (STANDALONE)
   commands.install = install;
 var readVersion = () => package_default.version ?? "unknown";
@@ -7969,8 +8408,8 @@ var peerVersion = (name, probe) => {
     const require2 = createRequire4(import.meta.url);
     let dir = dirname16(require2.resolve(probe));
     for (let depth = 0;depth < 16; depth++) {
-      const manifest = join23(dir, "package.json");
-      if (existsSync22(manifest)) {
+      const manifest = join24(dir, "package.json");
+      if (existsSync23(manifest)) {
         const parsed = JSON.parse(readFileSync23(manifest, "utf8"));
         if (parsed.name === name)
           return parsed.version ?? "unknown";
@@ -7989,9 +8428,9 @@ var printVersion = () => {
     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}`);
+  const width = Math.max(...rows.map(([label2]) => label2.length));
+  for (const [label2, value] of rows)
+    log(`${label2.padEnd(width)}  ${value}`);
 };
 var main = async () => {
   const argv = process.argv.slice(2);