@sublime-ui/devkit 0.1.0

package/dist/cli.js

@@ -0,0 +1,1438 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/lib/probe.ts
+import { join } from "path";
+
+// src/util/exec.ts
+import { execa } from "execa";
+async function run(file, args, opts = {}) {
+  const result = await execa(file, args, {
+    ...opts.cwd === void 0 ? {} : { cwd: opts.cwd },
+    env: { ...process.env, ...opts.env },
+    reject: false,
+    all: false
+  });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.exitCode ?? 1
+  };
+}
+async function runInherit(file, args, opts = {}) {
+  const result = await execa(file, args, {
+    ...opts.cwd === void 0 ? {} : { cwd: opts.cwd },
+    env: { ...process.env, ...opts.env },
+    stdio: "inherit",
+    reject: false
+  });
+  return result.exitCode ?? 1;
+}
+
+// src/lib/detect.ts
+function parseJavaVersion(stderr) {
+  const match = stderr.match(/version "([^"]+)"/);
+  return match ? match[1] ?? null : null;
+}
+function parseAdbVersion(stdout) {
+  const match = stdout.match(/version (\d+\.\d+\.\d+)/);
+  return match ? match[1] ?? null : null;
+}
+function parseSdkmanagerInstalled(stdout) {
+  const result = {};
+  for (const rawLine of stdout.split("\n")) {
+    if (!rawLine.includes("|")) continue;
+    const cells = rawLine.split("|").map((c) => c.trim());
+    const path = cells[0];
+    const version = cells[1];
+    if (path === void 0 || version === void 0) continue;
+    if (path === "" || path === "Path" || path.startsWith("---")) continue;
+    if (version === "Version") continue;
+    result[path] = version;
+  }
+  return result;
+}
+
+// src/lib/requirements.ts
+var REQUIREMENTS = {
+  node: { min: 18 },
+  jdk: { major: 17 },
+  ndk: "27.1.12297006",
+  cmake: "3.22.1",
+  buildTools: "35.0.0",
+  platform: "android-35"
+};
+var JDK_DOWNLOAD = {
+  windowsX64: "https://github.com/adoptium/temurin17-binaries/releases/download/jdk-17.0.13%2B11/OpenJDK17U-jdk_x64_windows_hotspot_17.0.13_11.zip"
+};
+function leadingMajor(actual) {
+  if (actual === null) return null;
+  const match = actual.match(/\d+/);
+  if (match === null) return null;
+  return Number.parseInt(match[0], 10);
+}
+function satisfiesMajor(actual, requiredMajor) {
+  const major = leadingMajor(actual);
+  return major !== null && major >= requiredMajor;
+}
+function satisfiesExact(actual, required) {
+  return actual !== null && actual === required;
+}
+
+// src/lib/probe.ts
+function resolveAndroidHome(env) {
+  return env["ANDROID_HOME"] ?? env["ANDROID_SDK_ROOT"] ?? null;
+}
+function sdkmanagerPath(androidHome) {
+  const bin = process.platform === "win32" ? "sdkmanager.bat" : "sdkmanager";
+  return join(androidHome, "cmdline-tools", "latest", "bin", bin);
+}
+async function gatherProbes() {
+  const nodeRes = await run(process.execPath, ["-v"]);
+  const javaRes = await run("java", ["-version"]);
+  const androidHome = resolveAndroidHome(process.env);
+  let sdkmanager = false;
+  let installed = {};
+  if (androidHome !== null) {
+    const smPath = sdkmanagerPath(androidHome);
+    const listRes = await run(smPath, ["--list_installed"]);
+    sdkmanager = listRes.exitCode === 0;
+    installed = parseSdkmanagerInstalled(listRes.stdout);
+  }
+  const adbRes = await run("adb", ["--version"]);
+  return {
+    node: nodeRes.stdout.trim() || null,
+    jdk17: parseJavaVersion(javaRes.stderr),
+    androidHome,
+    sdkmanager,
+    platformTools: parseAdbVersion(adbRes.stdout) !== null,
+    ndk: installed[`ndk;${REQUIREMENTS.ndk}`] ?? null,
+    cmake: installed[`cmake;${REQUIREMENTS.cmake}`] ?? null
+  };
+}
+
+// src/lib/doctor-report.ts
+function buildDoctorReport(probes) {
+  const rows = [
+    {
+      label: "Node >=18",
+      ok: satisfiesMajor(probes.node, REQUIREMENTS.node.min),
+      detail: probes.node ?? "not found"
+    },
+    {
+      label: "JDK 17",
+      ok: satisfiesMajor(probes.jdk17, REQUIREMENTS.jdk.major),
+      detail: probes.jdk17 ?? "not found (run: sublime setup)"
+    },
+    {
+      label: "ANDROID_HOME",
+      ok: probes.androidHome !== null,
+      detail: probes.androidHome ?? "not set"
+    },
+    {
+      label: "sdkmanager",
+      ok: probes.sdkmanager,
+      detail: probes.sdkmanager ? "cmdline-tools present" : "missing"
+    },
+    {
+      label: "platform-tools",
+      ok: probes.platformTools,
+      detail: probes.platformTools ? "adb present" : "missing"
+    },
+    {
+      label: `NDK ${REQUIREMENTS.ndk}`,
+      ok: satisfiesExact(probes.ndk, REQUIREMENTS.ndk),
+      detail: probes.ndk ?? "missing (auto-installed on build)"
+    },
+    {
+      label: `CMake ${REQUIREMENTS.cmake}`,
+      ok: satisfiesExact(probes.cmake, REQUIREMENTS.cmake),
+      detail: probes.cmake ?? "missing (auto-installed on build)"
+    }
+  ];
+  return { rows, ok: rows.every((r) => r.ok) };
+}
+
+// src/util/log.ts
+import pc from "picocolors";
+var log = {
+  info: (m) => console.log(m),
+  step: (m) => console.log(pc.cyan(`\u2192 ${m}`)),
+  success: (m) => console.log(pc.green(`\u2713 ${m}`)),
+  warn: (m) => console.log(pc.yellow(`! ${m}`)),
+  error: (m) => console.error(pc.red(`\u2717 ${m}`)),
+  table: (rows) => {
+    const width = rows.reduce((m, r) => Math.max(m, r.label.length), 0);
+    for (const r of rows) {
+      const mark = r.ok ? pc.green("\u2713") : pc.red("\u2717");
+      console.log(`${mark} ${r.label.padEnd(width)}  ${pc.dim(r.detail)}`);
+    }
+  }
+};
+
+// src/commands/doctor.ts
+async function doctorCommand() {
+  log.step("Checking environment for offline Android builds\u2026");
+  const probes = await gatherProbes();
+  const report = buildDoctorReport(probes);
+  log.table(report.rows);
+  if (report.ok) {
+    log.success("Environment ready. Run: sublime build");
+    return 0;
+  }
+  log.warn("Some requirements are missing. Run: sublime setup");
+  return 1;
+}
+
+// src/lib/jdk.ts
+import { existsSync, mkdirSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function sublimeHomeDir() {
+  return join2(homedir(), ".sublime");
+}
+async function ensurePortableJdk17() {
+  if (process.platform !== "win32") {
+    const home = process.env["JAVA_HOME"];
+    if (home && existsSync(home)) return home;
+    throw new Error(
+      "JDK 17 required. Install it (e.g. `brew install temurin@17`) and set JAVA_HOME."
+    );
+  }
+  const root = join2(sublimeHomeDir(), "jdk-17");
+  const marker = join2(root, "bin", "java.exe");
+  if (existsSync(marker)) return root;
+  mkdirSync(sublimeHomeDir(), { recursive: true });
+  const zipPath = join2(sublimeHomeDir(), "jdk-17.zip");
+  const tmp = join2(sublimeHomeDir(), "jdk-17-tmp");
+  rmSync(tmp, { recursive: true, force: true });
+  rmSync(root, { recursive: true, force: true });
+  log.step("Downloading portable JDK 17 (Temurin)\u2026");
+  const dl = await runInherit("powershell", [
+    "-NoProfile",
+    "-Command",
+    `Invoke-WebRequest -Uri '${JDK_DOWNLOAD.windowsX64}' -OutFile '${zipPath}'`
+  ]);
+  if (dl !== 0) {
+    throw new Error("Failed to download JDK 17 (check your network connection).");
+  }
+  log.step("Extracting JDK 17\u2026");
+  const ex = await runInherit("powershell", [
+    "-NoProfile",
+    "-Command",
+    `Expand-Archive -Path '${zipPath}' -DestinationPath '${tmp}' -Force`
+  ]);
+  if (ex !== 0) {
+    throw new Error("Failed to extract the JDK 17 archive.");
+  }
+  const inner = (await run("powershell", [
+    "-NoProfile",
+    "-Command",
+    `(Get-ChildItem -Directory '${tmp}' | Select-Object -First 1).FullName`
+  ])).stdout.trim();
+  if (inner === "") {
+    throw new Error("JDK 17 archive contained no extracted folder.");
+  }
+  const mv = await runInherit("powershell", [
+    "-NoProfile",
+    "-Command",
+    `Move-Item -Path '${inner}' -Destination '${root}' -Force`
+  ]);
+  if (mv !== 0) {
+    throw new Error("Failed to move the extracted JDK 17 into place.");
+  }
+  rmSync(tmp, { recursive: true, force: true });
+  rmSync(zipPath, { force: true });
+  if (!existsSync(marker)) {
+    throw new Error("Portable JDK 17 install incomplete (java.exe missing).");
+  }
+  return root;
+}
+
+// src/commands/setup.ts
+async function setupCommand() {
+  if (process.platform !== "win32") {
+    log.info("Guided setup (macOS/Linux):");
+    log.info("  1. Install Temurin JDK 17 and set JAVA_HOME.");
+    log.info("  2. Install Android cmdline-tools; set ANDROID_HOME.");
+    log.info('  3. sdkmanager "platform-tools" "platforms;android-35" "build-tools;35.0.0"');
+    log.info("  4. Re-run: sublime doctor");
+    return 0;
+  }
+  log.step("Setting up Windows build environment\u2026");
+  const jdk = await ensurePortableJdk17();
+  log.success(`Portable JDK 17 ready at ${jdk}`);
+  if (resolveAndroidHome(process.env) === null) {
+    log.warn("ANDROID_HOME is not set. Install Android SDK cmdline-tools and set ANDROID_HOME, then re-run: sublime doctor");
+    return 1;
+  }
+  log.success("Setup complete. Run: sublime doctor");
+  return 0;
+}
+
+// src/commands/build.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync, statSync } from "fs";
+import { join as join4 } from "path";
+
+// src/lib/gradle.ts
+import { resolve } from "path";
+
+// src/lib/sdkmanager.ts
+import { existsSync as existsSync2, readdirSync, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
+function isValidNdk(ndkDir) {
+  if (!existsSync2(join3(ndkDir, "source.properties"))) return false;
+  const hasNdkBuild = existsSync2(join3(ndkDir, "ndk-build")) || existsSync2(join3(ndkDir, "ndk-build.cmd"));
+  if (!hasNdkBuild) return false;
+  const llvmBin = join3(ndkDir, "toolchains", "llvm", "prebuilt");
+  if (!existsSync2(llvmBin)) return false;
+  for (const host of readdirSync(llvmBin)) {
+    const bin = join3(llvmBin, host, "bin");
+    if (existsSync2(join3(bin, "clang.exe")) || existsSync2(join3(bin, "clang"))) {
+      return true;
+    }
+  }
+  return false;
+}
+function ndkDirFor(androidHome, id) {
+  const m = id.match(/^ndk;(.+)$/);
+  return m ? join3(androidHome, "ndk", m[1] ?? "") : null;
+}
+async function ensureComponents(androidHome, ids, jdk17Home) {
+  if (ids.length === 0) return;
+  const smPath = sdkmanagerPath(androidHome);
+  const env = { JAVA_HOME: jdk17Home, ANDROID_HOME: androidHome };
+  for (const id of ids) {
+    const ndkDir = ndkDirFor(androidHome, id);
+    if (ndkDir !== null && existsSync2(ndkDir) && !isValidNdk(ndkDir)) {
+      log.warn(`Removing corrupt NDK at ${ndkDir}`);
+      rmSync2(ndkDir, { recursive: true, force: true });
+    }
+    log.step(`Installing ${id} \u2026`);
+    const res = await run(smPath, [`--sdk_root=${androidHome}`, id, "--channel=0"], {
+      env
+    });
+    if (res.exitCode !== 0) {
+      await run(smPath, [`--sdk_root=${androidHome}`, "--licenses"], { env });
+      const retry = await run(
+        smPath,
+        [`--sdk_root=${androidHome}`, id, "--channel=0"],
+        { env }
+      );
+      if (retry.exitCode !== 0) {
+        throw new Error(`Failed to install ${id}:
+${retry.stderr || retry.stdout}`);
+      }
+    }
+    if (ndkDir !== null && !isValidNdk(ndkDir)) {
+      throw new Error(`NDK install incomplete at ${ndkDir}`);
+    }
+  }
+}
+
+// src/lib/gradle.ts
+function parseMissingSdkComponents(output) {
+  const idPattern = /\b([a-z][a-z-]*(?:;[A-Za-z0-9._-]+)+)/g;
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const match of output.matchAll(idPattern)) {
+    const id = match[1];
+    if (id === void 0 || seen.has(id)) continue;
+    seen.add(id);
+    result.push(id);
+  }
+  return result;
+}
+function gradlewPath(projectAndroidDir) {
+  const script = process.platform === "win32" ? "gradlew.bat" : "gradlew";
+  return resolve(projectAndroidDir, script);
+}
+async function defaultRunner(androidDir, task, jdk17Home, androidHome) {
+  const gw = gradlewPath(androidDir);
+  const env = { JAVA_HOME: jdk17Home, ANDROID_HOME: androidHome };
+  const res = await run(gw, [task, "--no-daemon", "--stacktrace"], {
+    cwd: resolve(androidDir),
+    env
+  });
+  process.stdout.write(res.stdout);
+  process.stderr.write(res.stderr);
+  return { exitCode: res.exitCode, output: `${res.stdout}
+${res.stderr}` };
+}
+async function runGradleWithHealing(opts) {
+  const maxAttempts = opts.maxAttempts ?? 4;
+  const runner = opts.runner ?? ((task) => defaultRunner(opts.androidDir, task, opts.jdk17Home, opts.androidHome));
+  const installer = opts.installer ?? ((ids) => ensureComponents(opts.androidHome, ids, opts.jdk17Home));
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    log.step(`Gradle ${opts.task} (attempt ${attempt}/${maxAttempts})\u2026`);
+    const result = await runner(opts.task);
+    if (result.exitCode === 0) {
+      log.success(`Gradle ${opts.task} succeeded.`);
+      return;
+    }
+    const missing = parseMissingSdkComponents(result.output);
+    if (missing.length === 0) {
+      throw new Error(
+        `Gradle failed with no installable SDK component to recover.
+${result.output.slice(-2e3)}`
+      );
+    }
+    log.warn(`Missing SDK components: ${missing.join(", ")} \u2014 installing\u2026`);
+    await installer(missing);
+  }
+  throw new Error(`Gradle ${opts.task} failed after ${maxAttempts} attempts.`);
+}
+
+// src/commands/build.ts
+function gradleTaskFor(opts) {
+  if (opts.aab) return "bundleRelease";
+  return opts.release ? "assembleRelease" : "assembleDebug";
+}
+function readAndroidPackageId(appJsonPath) {
+  if (!existsSync3(appJsonPath)) return null;
+  const json = JSON.parse(readFileSync(appJsonPath, "utf8"));
+  return json.expo?.android?.package ?? null;
+}
+function findApk(projectDir, variant) {
+  const file = variant === "release" ? "app-release.apk" : "app-debug.apk";
+  const p = join4(
+    projectDir,
+    "android",
+    "app",
+    "build",
+    "outputs",
+    "apk",
+    variant,
+    file
+  );
+  return existsSync3(p) ? p : null;
+}
+function findAab(projectDir) {
+  const p = join4(
+    projectDir,
+    "android",
+    "app",
+    "build",
+    "outputs",
+    "bundle",
+    "release",
+    "app-release.aab"
+  );
+  return existsSync3(p) ? p : null;
+}
+function ensureLocalProperties(projectDir, androidHome) {
+  const target = join4(projectDir, "android", "local.properties");
+  if (existsSync3(target)) return;
+  const escaped = androidHome.replace(/\\/g, "\\\\");
+  writeFileSync(target, `sdk.dir=${escaped}
+`);
+}
+async function buildCommand(opts) {
+  const androidHome = resolveAndroidHome(process.env);
+  if (androidHome === null) {
+    log.error("ANDROID_HOME/ANDROID_SDK_ROOT not set. Run: sublime doctor");
+    return 1;
+  }
+  const androidDir = join4(opts.project, "android");
+  if (!existsSync3(androidDir)) {
+    log.step("Generating native Android project (expo prebuild)\u2026");
+    const code = await runInherit("npx", [
+      "expo",
+      "prebuild",
+      "--platform",
+      "android",
+      "--no-install"
+    ], { cwd: opts.project });
+    if (code !== 0 || !existsSync3(androidDir)) {
+      log.error("expo prebuild failed.");
+      return 1;
+    }
+  }
+  ensureLocalProperties(opts.project, androidHome);
+  const jdk17Home = await ensurePortableJdk17();
+  const task = gradleTaskFor({ release: opts.release, aab: opts.aab });
+  await runGradleWithHealing({ androidDir, task, jdk17Home, androidHome });
+  if (!opts.aab) {
+    const variant = opts.release ? "release" : "debug";
+    const apk = findApk(opts.project, variant);
+    if (apk === null) {
+      log.error(`Build reported success but no ${variant} APK was found.`);
+      return 1;
+    }
+    const mb = (statSync(apk).size / (1024 * 1024)).toFixed(1);
+    log.success(`APK ready: ${apk} (${mb} MB)`);
+  } else {
+    const aab = findAab(opts.project);
+    if (aab === null) {
+      log.error("Build reported success but no AAB was found.");
+      return 1;
+    }
+    const mb = (statSync(aab).size / (1024 * 1024)).toFixed(1);
+    log.success(`AAB ready: ${aab} (${mb} MB)`);
+  }
+  return 0;
+}
+
+// src/commands/run.ts
+import { join as join5 } from "path";
+
+// src/lib/android.ts
+function parseAdbDevices(stdout) {
+  const serials = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("List of devices")) continue;
+    const [serial, state] = trimmed.split(/\s+/);
+    if (serial !== void 0 && state === "device") serials.push(serial);
+  }
+  return serials;
+}
+async function listDevices() {
+  const res = await run("adb", ["devices"]);
+  return parseAdbDevices(res.stdout);
+}
+async function installApk(serial, apkPath) {
+  const res = await run("adb", ["-s", serial, "install", "-r", apkPath]);
+  if (res.exitCode !== 0) {
+    throw new Error(`adb install failed:
+${res.stderr || res.stdout}`);
+  }
+}
+async function launchActivity(serial, pkg) {
+  const res = await run("adb", [
+    "-s",
+    serial,
+    "shell",
+    "monkey",
+    "-p",
+    pkg,
+    "-c",
+    "android.intent.category.LAUNCHER",
+    "1"
+  ]);
+  if (res.exitCode !== 0) {
+    throw new Error(`Failed to launch ${pkg}:
+${res.stderr || res.stdout}`);
+  }
+}
+
+// src/commands/run.ts
+async function runCommand(opts) {
+  const apk = findApk(opts.project, "release") ?? findApk(opts.project, "debug");
+  if (apk === null) {
+    log.error("No APK found. Run: sublime build");
+    return 1;
+  }
+  const devices = await listDevices();
+  if (devices.length === 0) {
+    log.error("No connected device/emulator. Start one and retry.");
+    return 1;
+  }
+  const serial = opts.device ?? devices[0];
+  if (serial === void 0) return 1;
+  log.step(`Installing ${apk} on ${serial}\u2026`);
+  await installApk(serial, apk);
+  const pkg = readAndroidPackageId(join5(opts.project, "app.json"));
+  if (pkg === null) {
+    log.error("Could not read android.package from app.json");
+    return 1;
+  }
+  log.step(`Launching ${pkg}\u2026`);
+  await launchActivity(serial, pkg);
+  log.success("Launched.");
+  return 0;
+}
+
+// src/cli.ts
+import { input } from "@inquirer/prompts";
+
+// src/commands/make-model.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { join as join7 } from "path";
+
+// src/lib/generators/config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
+var DEFAULT_CONFIG = {
+  modelsDir: "src/models",
+  componentsDir: "src/components",
+  themeDir: "src/theme",
+  navigationDir: "src/navigation",
+  importAlias: "@sublime-ui"
+};
+function loadConfig(cwd) {
+  const path = join6(cwd, "sublime.config.json");
+  if (!existsSync4(path)) return { ...DEFAULT_CONFIG };
+  const raw = JSON.parse(readFileSync2(path, "utf8"));
+  const result = { ...DEFAULT_CONFIG };
+  for (const key of Object.keys(DEFAULT_CONFIG)) {
+    const value = raw[key];
+    if (typeof value === "string") result[key] = value;
+  }
+  if (raw.desktop && typeof raw.desktop === "object") {
+    const desktop = {};
+    if (typeof raw.desktop.dir === "string") desktop.dir = raw.desktop.dir;
+    if (typeof raw.desktop.nativeDir === "string") desktop.nativeDir = raw.desktop.nativeDir;
+    result.desktop = desktop;
+  }
+  return result;
+}
+
+// src/lib/generators/names.ts
+function pascalCase(input2) {
+  return input2.split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function pluralize(word) {
+  const w = word.toLowerCase();
+  if (/[^aeiou]y$/.test(w)) return w.slice(0, -1) + "ies";
+  if (/(s|x|ch|sh)$/.test(w)) return w + "es";
+  return w + "s";
+}
+function deriveNames(name) {
+  const className = pascalCase(name);
+  const plural = pluralize(className);
+  return {
+    className,
+    resource: `/${plural}`,
+    sliceName: plural,
+    fileName: className
+  };
+}
+
+// src/lib/generators/fields.ts
+var SCALARS = /* @__PURE__ */ new Set(["string", "number", "boolean"]);
+function parseFields(input2) {
+  const fields = [];
+  const warnings = [];
+  for (const part of input2.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed === "") continue;
+    const [rawName, rawType] = trimmed.split(":").map((s) => s.trim());
+    if (rawName === void 0 || rawName === "") continue;
+    const type = rawType ?? "string";
+    if (SCALARS.has(type) || type.endsWith("[]")) {
+      fields.push({ name: rawName, tsType: type });
+    } else {
+      warnings.push(`Field "${rawName}" has unknown type "${type}" \u2014 defaulting to string.`);
+      fields.push({ name: rawName, tsType: "string" });
+    }
+  }
+  return { fields, warnings };
+}
+
+// src/lib/generators/render-model.ts
+function renderModel(opts) {
+  const hasId = opts.fields.some((f) => f.name === "id");
+  const fields = hasId ? opts.fields : [{ name: "id", tsType: "number" }, ...opts.fields];
+  const declares = fields.map((f) => `  declare ${f.name}: ${f.tsType};`).join("\n");
+  return `import { Model, registerModel } from '${opts.importAlias}/framework';
+
+export class ${opts.className} extends Model {
+  protected static resource = '${opts.resource}';
+${declares}
+}
+
+registerModel(${opts.className});
+`;
+}
+
+// src/lib/generators/barrel.ts
+function updateBarrel(existing, line) {
+  const lines = existing.split("\n").map((l) => l.trim());
+  if (lines.includes(line.trim())) return existing;
+  const base = existing.length > 0 && !existing.endsWith("\n") ? existing + "\n" : existing;
+  return `${base}${line}
+`;
+}
+
+// src/lib/generators/write.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+var FileExistsError = class _FileExistsError extends Error {
+  path;
+  constructor(path) {
+    super(`File already exists: ${path} (use --force to overwrite)`);
+    this.name = "FileExistsError";
+    this.path = path;
+    Object.setPrototypeOf(this, _FileExistsError.prototype);
+  }
+};
+function safeWrite(path, content, force) {
+  if (existsSync5(path) && !force) throw new FileExistsError(path);
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, content);
+}
+
+// src/commands/make-model.ts
+async function makeModel(opts) {
+  const cfg = loadConfig(opts.cwd);
+  const names = deriveNames(opts.name);
+  const raw = opts.fields ?? (opts.promptFields ? await opts.promptFields() : "");
+  const { fields, warnings } = parseFields(raw);
+  for (const w of warnings) log.warn(w);
+  const content = renderModel({
+    className: names.className,
+    resource: opts.resource ?? names.resource,
+    importAlias: cfg.importAlias,
+    fields
+  });
+  const modelPath = join7(opts.cwd, cfg.modelsDir, `${names.fileName}.ts`);
+  const barrelPath = join7(opts.cwd, cfg.modelsDir, "index.ts");
+  try {
+    safeWrite(modelPath, content, opts.force);
+    const existing = existsSync6(barrelPath) ? readFileSync3(barrelPath, "utf8") : "";
+    safeWrite(barrelPath, updateBarrel(existing, `export * from './${names.fileName}.js';`), true);
+    log.success(`Created ${modelPath}`);
+    return 0;
+  } catch (err) {
+    if (err instanceof FileExistsError) {
+      log.error(err.message);
+      return 1;
+    }
+    throw err;
+  }
+}
+
+// src/commands/make-component.ts
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { join as join8 } from "path";
+
+// src/lib/generators/render-component.ts
+function renderComponentTypes(name) {
+  return `import type { ReactNode } from 'react';
+
+export type Variant = 'solid' | 'soft' | 'outline' | 'ghost';
+export type Tone = 'primary' | 'success' | 'danger' | 'warning' | 'info' | 'neutral';
+export type Size = 'sm' | 'md' | 'lg';
+
+export interface ${name}Props {
+  children?: ReactNode;
+  variant?: Variant;
+  tone?: Tone;
+  size?: Size;
+  testID?: string;
+}
+`;
+}
+function renderComponentWeb(name, mobileOnly, importAlias) {
+  if (mobileOnly) {
+    return `import type { ${name}Props } from './${name}.types.js';
+
+/** ${name} is mobile-only and renders nothing on web. */
+export function ${name}(_props: ${name}Props) {
+  if (process.env.NODE_ENV !== 'production') {
+    console.warn('${name} is mobile-only and renders nothing on web.');
+  }
+  return null;
+}
+`;
+  }
+  return `import { Box } from '@mui/material';
+import { useTokens } from '${importAlias}/library';
+import type { ${name}Props } from './${name}.types.js';
+
+export function ${name}({ children, testID }: ${name}Props) {
+  const tokens = useTokens();
+  return (
+    <Box data-testid={testID} sx={{ borderRadius: \`\${tokens.radii.md}px\` }}>
+      {children}
+    </Box>
+  );
+}
+`;
+}
+function renderComponentNative(name, importAlias) {
+  return `import { View } from 'react-native';
+import { useTokens } from '${importAlias}/library';
+import type { ${name}Props } from './${name}.types.js';
+
+export function ${name}({ children, testID }: ${name}Props) {
+  const tokens = useTokens();
+  return (
+    <View testID={testID} style={{ borderRadius: tokens.radii.md }}>
+      {children}
+    </View>
+  );
+}
+`;
+}
+function renderComponentIndex(name) {
+  return `export { ${name} } from './${name}.js';
+export type { ${name}Props } from './${name}.types.js';
+`;
+}
+
+// src/commands/make-component.ts
+async function makeComponent(opts) {
+  const cfg = loadConfig(opts.cwd);
+  const dir = join8(opts.cwd, cfg.componentsDir, opts.name);
+  try {
+    safeWrite(join8(dir, `${opts.name}.types.ts`), renderComponentTypes(opts.name), opts.force);
+    safeWrite(join8(dir, `${opts.name}.tsx`), renderComponentWeb(opts.name, opts.mobileOnly, cfg.importAlias), opts.force);
+    safeWrite(join8(dir, `${opts.name}.native.tsx`), renderComponentNative(opts.name, cfg.importAlias), opts.force);
+    safeWrite(join8(dir, "index.ts"), renderComponentIndex(opts.name), opts.force);
+    const barrelPath = join8(opts.cwd, cfg.componentsDir, "index.ts");
+    const existing = existsSync7(barrelPath) ? readFileSync4(barrelPath, "utf8") : "";
+    safeWrite(barrelPath, updateBarrel(existing, `export * from './${opts.name}/index.js';`), true);
+    log.success(`Created ${dir}`);
+    return 0;
+  } catch (err) {
+    if (err instanceof FileExistsError) {
+      log.error(err.message);
+      return 1;
+    }
+    throw err;
+  }
+}
+
+// src/commands/theme-init.ts
+import { findPackageJSON } from "module";
+import { pathToFileURL } from "url";
+import { dirname as dirname2, join as join9 } from "path";
+
+// src/lib/generators/render-tokens.ts
+function renderTokensWrapper(importAlias) {
+  return `import data from './tokens.json';
+import type { SublimeTokens } from '${importAlias}/library';
+
+/** App design tokens. Edit tokens.json (the devkit-server customizer writes here). */
+export const tokens = data as SublimeTokens;
+`;
+}
+
+// src/commands/theme-init.ts
+async function resolveDefaultTokens(cwd) {
+  const base = pathToFileURL(join9(cwd, "noop.js")).href;
+  const pkgJsonPath = findPackageJSON("@sublime-ui/library", base);
+  if (!pkgJsonPath) throw new Error("@sublime-ui/library not found");
+  const tokensJs = join9(dirname2(pkgJsonPath), "dist", "tokens", "tokens.js");
+  const mod = await import(pathToFileURL(tokensJs).href);
+  return mod.defaultTokens;
+}
+async function themeInit(opts) {
+  const cfg = loadConfig(opts.cwd);
+  let tokens;
+  try {
+    tokens = await (opts.loadDefaultTokens ?? (() => resolveDefaultTokens(opts.cwd)))();
+  } catch {
+    log.error("Could not resolve @sublime-ui/library. Install it in this app first.");
+    return 1;
+  }
+  const jsonPath = join9(opts.cwd, cfg.themeDir, "tokens.json");
+  const wrapperPath = join9(opts.cwd, cfg.themeDir, "tokens.ts");
+  try {
+    safeWrite(jsonPath, JSON.stringify(tokens, null, 2) + "\n", opts.force);
+    safeWrite(wrapperPath, renderTokensWrapper(cfg.importAlias), opts.force);
+    log.success(`Created ${jsonPath} and ${wrapperPath}`);
+    return 0;
+  } catch (err) {
+    if (err instanceof FileExistsError) {
+      log.error(err.message);
+      return 1;
+    }
+    throw err;
+  }
+}
+
+// src/commands/build-nav.ts
+import { join as join10 } from "path";
+import { readFileSync as readFileSync5, watch as fsWatch } from "fs";
+
+// src/lib/navigation/load-storybook.ts
+import { pathToFileURL as pathToFileURL2 } from "url";
+function componentName(component) {
+  if (typeof component === "function" && component.name) return component.name;
+  if (component != null && typeof component === "object" && "displayName" in component && typeof component.displayName === "string") {
+    return component.displayName;
+  }
+  return "Anonymous";
+}
+function isBookDef(value) {
+  return value != null && typeof value === "object" && value.kind === "book" && typeof value.pages === "object";
+}
+function bookToNode(def, key, options) {
+  const children = [];
+  for (const [childKey, entry] of Object.entries(def.pages)) {
+    children.push(entryToNode(entry, childKey));
+  }
+  return { key, kind: "book", format: def.format, options: { ...options }, children };
+}
+function entryToNode(entry, key) {
+  if (entry.kind === "link") {
+    if (!isBookDef(entry.book)) {
+      return {
+        key,
+        kind: "book",
+        options: { ...entry.options ?? {} },
+        children: [],
+        linkError: `link("${key}") does not reference a book().`
+      };
+    }
+    return bookToNode(entry.book, key, entry.options ?? {});
+  }
+  return {
+    key,
+    kind: "page",
+    component: componentName(entry.component),
+    options: { ...entry.options ?? {} }
+  };
+}
+async function loadStorybook(absFile) {
+  const mod = await import(pathToFileURL2(absFile).href);
+  const root = mod.default;
+  if (!isBookDef(root)) {
+    throw new Error(`Storybook ${absFile} must default-export a book().`);
+  }
+  return bookToNode(root, "root", {});
+}
+
+// src/lib/navigation/validate.ts
+var MOBILE_FORMATS = /* @__PURE__ */ new Set(["drawer", "stack", "bottomNav"]);
+var WEB_FORMATS = /* @__PURE__ */ new Set(["sidebar", "stack", "tabs"]);
+function validate(root, platform) {
+  const diagnostics = [];
+  const formats = platform === "mobile" ? MOBILE_FORMATS : WEB_FORMATS;
+  const keyCounts = /* @__PURE__ */ new Map();
+  const error = (rule, message) => {
+    diagnostics.push({ level: "error", rule, message });
+  };
+  const walk = (node, isRoot) => {
+    if (!isRoot) {
+      keyCounts.set(node.key, (keyCounts.get(node.key) ?? 0) + 1);
+    }
+    if (node.kind === "page") {
+      if (!node.component) {
+        error("dangling", `Page "${node.key}" has no component.`);
+      }
+      return;
+    }
+    const children = node.children ?? [];
+    if (node.linkError !== void 0) {
+      error(
+        "bad-link",
+        `Book "${node.key}": ${node.linkError} Fix: pass a value returned by book() to link().`
+      );
+      return;
+    }
+    if (children.length === 0) {
+      error("dangling", `Book "${node.key}" has no children.`);
+    }
+    if (node.format && !formats.has(node.format)) {
+      error(
+        "format-platform",
+        `Book "${node.key}" uses format "${node.format}" which is not valid on ${platform}.`
+      );
+    }
+    if (node.format === "bottomNav") {
+      const directPages = children.filter((c) => c.kind === "page").length;
+      if (directPages > 5) {
+        error(
+          "bottomNav-max-5",
+          `Book "${node.key}" has ${directPages} bottomNav pages; the maximum is 5.`
+        );
+      }
+    }
+    const initialCount = children.filter((c) => c.options.initial === true).length;
+    if (initialCount > 1) {
+      error(
+        "multiple-initial",
+        `Book "${node.key}" has ${initialCount} children marked initial; only one is allowed.`
+      );
+    }
+    for (const child of children) {
+      walk(child, false);
+    }
+  };
+  walk(root, true);
+  for (const [key, count] of keyCounts) {
+    if (count > 1) {
+      error("duplicate-key", `Key "${key}" is used ${count} times across the tree.`);
+    }
+  }
+  return diagnostics;
+}
+
+// src/lib/navigation/flatten.ts
+function kebab(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+function segmentHasParams(segment) {
+  return segment.includes(":");
+}
+function flatten(root) {
+  const routes = [];
+  const walk = (node, prefix, isRoot) => {
+    if (node.kind === "page") {
+      const segment2 = node.options.path ?? kebab(node.key);
+      const path = `${prefix}/${segment2}`;
+      routes.push({ key: node.key, path, hasParams: segmentHasParams(path) });
+      return;
+    }
+    const segment = node.options.path ?? kebab(node.key);
+    const nextPrefix = isRoot ? prefix : `${prefix}/${segment}`;
+    for (const child of node.children ?? []) {
+      walk(child, nextPrefix, false);
+    }
+  };
+  walk(root, "", true);
+  return { routes };
+}
+
+// src/lib/navigation/extract-params.ts
+import ts from "typescript";
+function extractParams(source) {
+  const sf = ts.createSourceFile("storybook.ts", source, ts.ScriptTarget.Latest, true);
+  const params = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts.isPropertyAssignment(node) && ts.isCallExpression(node.initializer) && isPageCall(node.initializer) && node.initializer.typeArguments && node.initializer.typeArguments.length > 0) {
+      const key = propertyName(node.name);
+      if (key !== void 0) {
+        params.set(key, node.initializer.typeArguments[0].getText(sf).trim());
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return params;
+}
+function isPageCall(call) {
+  return ts.isIdentifier(call.expression) && call.expression.text === "page";
+}
+function propertyName(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return void 0;
+}
+
+// src/lib/navigation/merge-route-params.ts
+function mergeRouteParams(input2) {
+  const { nativeKeys, webKeys, nativeParams, webParams } = input2;
+  const keys = [.../* @__PURE__ */ new Set([...nativeKeys, ...webKeys])].sort();
+  const routes = [];
+  const conflicts = [];
+  for (const key of keys) {
+    const nativeType = nativeParams.get(key);
+    const webType = webParams.get(key);
+    if (nativeType !== void 0 && webType !== void 0 && nativeType !== webType) {
+      conflicts.push(key);
+    }
+    routes.push({ key, params: nativeType ?? webType ?? "void" });
+  }
+  return { routes, conflicts };
+}
+
+// src/lib/navigation/render-native.ts
+var NATIVE_FACTORY = {
+  bottomNav: { factory: "createBottomTabNavigator", nav: "Tab" },
+  drawer: { factory: "createDrawerNavigator", nav: "Drawer" },
+  stack: { factory: "createNativeStackNavigator", nav: "Stack" }
+};
+var FACTORY_MODULE = {
+  createBottomTabNavigator: "@react-navigation/bottom-tabs",
+  createDrawerNavigator: "@react-navigation/drawer",
+  createNativeStackNavigator: "@react-navigation/native-stack"
+};
+function factoryFor(format) {
+  return NATIVE_FACTORY[format ?? "stack"] ?? NATIVE_FACTORY.stack;
+}
+function screenOptions(node, supportsIcon) {
+  const parts = [];
+  const { title, icon } = node.options;
+  if (title !== void 0) parts.push(`title: ${JSON.stringify(title)}`);
+  if (icon !== void 0 && supportsIcon) {
+    parts.push(`tabBarIcon: () => <NavIcon name={${JSON.stringify(icon)}} />`);
+  }
+  return parts.join(", ");
+}
+function pascal(key) {
+  return key.replace(/[_\s-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(" ").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function renderNative(root, opts) {
+  const screenNames = /* @__PURE__ */ new Set();
+  const navigatorBlocks = [];
+  const usedFactories = /* @__PURE__ */ new Map();
+  let usesIcon = false;
+  const navVarFor = (factory, nav) => {
+    if (!usedFactories.has(factory)) usedFactories.set(factory, nav);
+    return usedFactories.get(factory);
+  };
+  const renderBook = (book) => {
+    const { factory, nav } = factoryFor(book.format);
+    const navVar = navVarFor(factory, nav);
+    const componentName2 = book.key === "root" ? "RootNavigator" : `${pascal(book.key)}Navigator`;
+    const supportsIcon = factory === "createBottomTabNavigator" || factory === "createDrawerNavigator";
+    const children = book.children ?? [];
+    const screens = [];
+    for (const child of children) {
+      const name = child.kind === "page" ? child.component ?? pascal(child.key) : renderBook(child);
+      if (child.kind === "page") screenNames.add(name);
+      if (supportsIcon && child.options.icon !== void 0) usesIcon = true;
+      const options = screenOptions(child, supportsIcon);
+      const optionsAttr = options ? ` options={{ ${options} }}` : "";
+      screens.push(
+        `      <${navVar}.Screen name="${child.key}" component={${name}}${optionsAttr} />`
+      );
+    }
+    const initialChild = children.find((c) => c.options.initial === true);
+    const navProps = initialChild ? ` initialRouteName="${initialChild.key}"` : "";
+    navigatorBlocks.push(
+      `function ${componentName2}() {
+  return (
+    <${navVar}.Navigator${navProps}>
+${screens.join("\n")}
+    </${navVar}.Navigator>
+  );
+}`
+    );
+    return componentName2;
+  };
+  const rootComponent = renderBook(root);
+  const factoryImports = [...usedFactories.entries()].map(([factory, nav]) => {
+    const mod = FACTORY_MODULE[factory];
+    return `import { ${factory} } from '${mod}';
+const ${nav} = ${factory}();`;
+  }).join("\n");
+  const screenImport = [...screenNames].sort().join(", ");
+  const header = "// AUTO-GENERATED by sublime build:nav \u2014 do not edit";
+  const navIconBlock = usesIcon ? `function NavIcon(_props: { name: string }): ReactNode {
+  return null;
+}
+
+` : "";
+  return `${header}
+import type { ReactNode } from 'react';
+import { NavigationContainer } from '@react-navigation/native';
+${factoryImports}
+import { NavProvider } from '@sublime-ui/ui/navigation';
+import { useNativeNav } from '@sublime-ui/ui/navigation/bridge.native';
+import { ${screenImport} } from '${opts.screensImport}';
+
+${navIconBlock}${navigatorBlocks.join("\n\n")}
+
+function NavBridge({ children }: { children: ReactNode }) {
+  const nav = useNativeNav();
+  return <NavProvider value={nav}>{children}</NavProvider>;
+}
+
+export function Navigation() {
+  return (
+    <NavigationContainer>
+      <NavBridge>
+        <${rootComponent} />
+      </NavBridge>
+    </NavigationContainer>
+  );
+}
+`;
+}
+
+// src/lib/navigation/render-web.ts
+var WEB_LAYOUT = {
+  sidebar: "Sidebar",
+  tabs: "Tabs",
+  stack: "Stack"
+};
+function layoutFor(format) {
+  return WEB_LAYOUT[format ?? "stack"] ?? WEB_LAYOUT.stack;
+}
+function pascal2(key) {
+  return key.replace(/[_\s-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(" ").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function kebab2(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+function renderWeb(root, opts) {
+  const screenNames = /* @__PURE__ */ new Set();
+  const layoutNames = /* @__PURE__ */ new Set();
+  const layoutBlocks = [];
+  const renderBook = (book, isRoot) => {
+    const layout = layoutFor(book.format);
+    layoutNames.add(layout);
+    const segment = book.options.path ?? kebab2(book.key);
+    const routePath = isRoot ? "/" : segment;
+    const children = [];
+    for (const child of book.children ?? []) {
+      if (child.kind === "page") {
+        const comp = child.component ?? pascal2(child.key);
+        screenNames.add(comp);
+        const childSegment = child.options.path ?? kebab2(child.key);
+        if (child.options.initial === true) {
+          children.push(`        <Route index element={<${comp} />} />`);
+        }
+        children.push(
+          `        <Route path="${childSegment}" element={<${comp} />} />`
+        );
+      } else {
+        children.push(renderBook(child, false));
+      }
+    }
+    return `      <Route path="${routePath}" element={<${layout} />}>
+${children.join("\n")}
+      </Route>`;
+  };
+  const routesTree = renderBook(root, true);
+  for (const layout of [...layoutNames].sort()) {
+    layoutBlocks.push(
+      `function ${layout}() {
+  return <Outlet />;
+}`
+    );
+  }
+  const { routes } = flatten(root);
+  const pathEntries = routes.map((r) => `  ${JSON.stringify(r.key)}: ${JSON.stringify(r.path)},`).join("\n");
+  const titleEntries = [];
+  const collectTitles = (node) => {
+    if (node.kind === "page") {
+      const fields = [];
+      if (node.options.title !== void 0) fields.push(`title: ${JSON.stringify(node.options.title)}`);
+      if (node.options.icon !== void 0) fields.push(`icon: ${JSON.stringify(node.options.icon)}`);
+      if (fields.length > 0) {
+        titleEntries.push(`  ${JSON.stringify(node.key)}: { ${fields.join(", ")} },`);
+      }
+      return;
+    }
+    for (const child of node.children ?? []) collectTitles(child);
+  };
+  collectTitles(root);
+  const screenImport = [...screenNames].sort().join(", ");
+  const header = "// AUTO-GENERATED by sublime build:nav \u2014 do not edit";
+  return `${header}
+import type { ReactNode } from 'react';
+import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom';
+import { NavProvider } from '@sublime-ui/ui/navigation';
+import { useWebNav } from '@sublime-ui/ui/navigation/bridge.web';
+import { ${screenImport} } from '${opts.screensImport}';
+
+const paths: Record<string, string> = {
+${pathEntries}
+};
+
+export const titles: Record<string, { title?: string; icon?: string }> = {
+${titleEntries.join("\n")}${titleEntries.length > 0 ? "\n" : ""}};
+
+function pathOf(name: string, params?: unknown): string {
+  let path = paths[name] ?? '/';
+  if (params && typeof params === 'object') {
+    for (const [k, v] of Object.entries(params as Record<string, unknown>)) {
+      path = path.replace(\`:\${k}\`, String(v));
+    }
+  }
+  return path;
+}
+
+function nameOf(path: string): string {
+  const norm = (p: string) => (p.length > 1 && p.endsWith('/') ? p.slice(0, -1) : p);
+  const target = norm(path);
+  for (const [name, p] of Object.entries(paths)) {
+    const pattern = norm(p);
+    if (pattern === target) return name;
+    // Match parameterized routes (':id' segments) positionally.
+    if (pattern.includes(':')) {
+      const re = new RegExp('^' + pattern.replace(/:[^/]+/g, '[^/]+') + '$');
+      if (re.test(target)) return name;
+    }
+  }
+  return path;
+}
+
+${layoutBlocks.join("\n\n")}
+
+function NavBridge({ children }: { children: ReactNode }) {
+  const nav = useWebNav(pathOf, nameOf);
+  return <NavProvider value={nav}>{children}</NavProvider>;
+}
+
+export function Navigation() {
+  return (
+    <BrowserRouter>
+      <NavBridge>
+        <Routes>
+${routesTree}
+        </Routes>
+      </NavBridge>
+    </BrowserRouter>
+  );
+}
+`;
+}
+
+// src/lib/navigation/render-routes-dts.ts
+function renderRoutesDts(routes) {
+  const header = "// AUTO-GENERATED by sublime build:nav \u2014 do not edit";
+  const entries = routes.map((r) => `  ${r.key}: ${r.params};`).join("\n");
+  return `${header}
+export interface AppRoutes {
+${entries}
+}
+`;
+}
+
+// src/commands/build-nav.ts
+var SCREENS_IMPORT = "./screens";
+var BARREL = [
+  "// AUTO-GENERATED by sublime build:nav \u2014 do not edit",
+  "export { Navigation } from './navigation.js';",
+  "export type { AppRoutes } from './routes.js';",
+  ""
+].join("\n");
+function printDiagnostics(platform, diagnostics) {
+  for (const d of diagnostics) {
+    log.error(`[${platform}] ${d.rule}: ${d.message}`);
+  }
+}
+async function buildNav(opts) {
+  const cfg = loadConfig(opts.cwd);
+  const navDir = join10(opts.cwd, cfg.navigationDir);
+  const nativeFile = join10(navDir, "storybook.native.ts");
+  const webFile = join10(navDir, "storybook.web.ts");
+  const code = await buildOnce(navDir, nativeFile, webFile);
+  if (opts.watch) {
+    watchAndRebuild(navDir, nativeFile, webFile);
+  }
+  return code;
+}
+async function buildOnce(navDir, nativeFile, webFile) {
+  let nativeRoot;
+  let webRoot;
+  try {
+    nativeRoot = await loadStorybook(nativeFile);
+    webRoot = await loadStorybook(webFile);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  const diagnostics = [
+    ...validate(nativeRoot, "mobile").map((d) => ["native", d]),
+    ...validate(webRoot, "web").map((d) => ["web", d])
+  ];
+  if (diagnostics.length > 0) {
+    for (const [platform, d] of diagnostics) printDiagnostics(platform, [d]);
+    log.error(`build:nav failed with ${diagnostics.length} error(s); wrote nothing.`);
+    return 1;
+  }
+  const nativeParams = extractParams(readFileSync5(nativeFile, "utf8"));
+  const webParams = extractParams(readFileSync5(webFile, "utf8"));
+  const { routes, conflicts } = mergeRouteParams({
+    nativeKeys: flatten(nativeRoot).routes.map((r) => r.key),
+    webKeys: flatten(webRoot).routes.map((r) => r.key),
+    nativeParams,
+    webParams
+  });
+  if (conflicts.length > 0) {
+    for (const key of conflicts) {
+      log.error(
+        `route-param-conflict ${key}: native and web declare different param types for "${key}". Fix: make both page<...>() type arguments agree.`
+      );
+    }
+    log.error(`build:nav failed with ${conflicts.length} error(s); wrote nothing.`);
+    return 1;
+  }
+  const nativeSrc = renderNative(nativeRoot, { screensImport: SCREENS_IMPORT });
+  const webSrc = renderWeb(webRoot, { screensImport: SCREENS_IMPORT });
+  const dtsSrc = renderRoutesDts(routes);
+  safeWrite(join10(navDir, "navigation.native.tsx"), nativeSrc, true);
+  safeWrite(join10(navDir, "navigation.web.tsx"), webSrc, true);
+  safeWrite(join10(navDir, "routes.d.ts"), dtsSrc, true);
+  safeWrite(join10(navDir, "index.ts"), BARREL, true);
+  log.success(`build:nav wrote 4 files to ${navDir}`);
+  return 0;
+}
+function watchAndRebuild(navDir, nativeFile, webFile) {
+  log.info(`build:nav watching ${navDir} \u2014 Ctrl-C to stop.`);
+  let timer;
+  const trigger = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      void buildOnce(navDir, nativeFile, webFile);
+    }, 50);
+  };
+  return [nativeFile, webFile].map((file) => fsWatch(file, trigger));
+}
+
+// src/commands/desktop-dev.ts
+import { join as join11 } from "path";
+var defaultRunner2 = (cmd, args, cwd) => runInherit(cmd, args, { cwd });
+async function desktopDev(opts) {
+  const cfg = loadConfig(opts.project);
+  const desktopDir = join11(opts.project, cfg.desktop?.dir ?? "desktop");
+  const runner = opts.runner ?? defaultRunner2;
+  return runner("electron-forge", ["start"], desktopDir);
+}
+
+// src/commands/desktop-build.ts
+import { join as join12 } from "path";
+var defaultRunner3 = (cmd, args, cwd) => runInherit(cmd, args, { cwd });
+async function desktopBuild(opts) {
+  const cfg = loadConfig(opts.project);
+  const desktopDir = join12(opts.project, cfg.desktop?.dir ?? "desktop");
+  const runner = opts.runner ?? defaultRunner3;
+  return runner("electron-forge", ["make"], desktopDir);
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("sublime").description("Sublime UI devkit \u2014 offline Android builds and tooling").version("0.0.0");
+program.command("doctor").description("Check the environment for offline Android builds").action(async () => {
+  process.exit(await doctorCommand());
+});
+program.command("setup").description("Install/repair the build environment").action(async () => {
+  process.exit(await setupCommand());
+});
+program.command("build").description("Build a standalone Android APK/AAB offline").option("--release", "release APK (default)", true).option("--debug", "debug APK (requires Metro)").option("--aab", "Android App Bundle (bundleRelease)").option("--project <path>", "project directory", process.cwd()).action(async (opts) => {
+  const code = await buildCommand({
+    project: opts.project,
+    release: opts.debug ? false : true,
+    aab: opts.aab ?? false
+  });
+  process.exit(code);
+});
+program.command("run").description("Install and launch the built APK on a device").option("--device <id>", "adb device serial").option("--project <path>", "project directory", process.cwd()).action(async (opts) => {
+  process.exit(
+    await runCommand(
+      opts.device === void 0 ? { project: opts.project } : { project: opts.project, device: opts.device }
+    )
+  );
+});
+program.command("make:model <name>").description("Scaffold a Model (+ registerModel) for the framework").option("--fields <spec>", 'fields, e.g. "name:string, tags:Tag[]"').option("--resource <path>", "override the REST resource path").option("--force", "overwrite existing files").action(async (name, opts) => {
+  const code = await makeModel({
+    name,
+    cwd: process.cwd(),
+    force: opts.force ?? false,
+    ...opts.fields ? { fields: opts.fields } : {},
+    ...opts.resource ? { resource: opts.resource } : {},
+    promptFields: () => input({ message: "Fields (name:type, comma-separated; blank for id-only):", default: "" })
+  });
+  process.exit(code);
+});
+program.command("make:component <name>").description("Scaffold a cross-platform component (types + web + native + index)").option("--mobile-only", "mobile-only component (web renders a null stub)").option("--force", "overwrite existing files").action(async (name, opts) => {
+  process.exit(await makeComponent({
+    name,
+    cwd: process.cwd(),
+    mobileOnly: opts.mobileOnly ?? false,
+    force: opts.force ?? false
+  }));
+});
+program.command("theme:init").description("Scaffold the app design tokens (tokens.json + typed wrapper)").option("--force", "overwrite existing files").action(async (opts) => {
+  process.exit(await themeInit({ cwd: process.cwd(), force: opts.force ?? false }));
+});
+program.command("build:nav").description("Compile per-platform storybooks into navigation artifacts").option("--watch", "rebuild on storybook changes").option("--force", "overwrite generated files").option("--project <path>", "project directory", process.cwd()).action(async (opts) => {
+  const code = await buildNav({
+    cwd: opts.project,
+    watch: opts.watch ?? false,
+    force: opts.force ?? false
+  });
+  if (!opts.watch) process.exit(code);
+});
+program.command("desktop:dev").description("Run the Electron desktop shell in development (electron-forge start)").option("--project <path>", "project directory", process.cwd()).action(async (opts) => {
+  process.exit(await desktopDev({ project: opts.project }));
+});
+program.command("desktop:build").description("Build distributable Electron artifacts (electron-forge make)").option("--project <path>", "project directory", process.cwd()).action(async (opts) => {
+  process.exit(await desktopBuild({ project: opts.project }));
+});
+program.parseAsync(process.argv).catch((err) => {
+  log.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});