@dormer/cli 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1301 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli.ts
+import path10 from "node:path";
+
+// src/ui.ts
+import { inspect } from "node:util";
+var EXIT = {
+  ok: 0,
+  failure: 1,
+  // build failed, host exited non-zero, doctor found a failing check
+  missingTool: 2,
+  // dormer-host / dormer-bundle not found
+  usage: 64,
+  // bad arguments
+  config: 65,
+  // dormer.config.json missing or invalid
+  noInput: 66
+  // a required input (template, entry, renderer dir) does not exist
+};
+var CliError = class extends Error {
+  exitCode;
+  hints;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = options.exitCode ?? EXIT.failure;
+    this.hints = options.hints ?? [];
+  }
+};
+var useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && (process.stdout.isTTY || process.env.FORCE_COLOR);
+var paint = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c = { dim: paint(2), bold: paint(1), red: paint(31), green: paint(32), yellow: paint(33), blue: paint(34), cyan: paint(36) };
+var prefix = c.dim("[dormer]");
+var log = {
+  info: (msg) => {
+    console.log(`${prefix} ${msg}`);
+  },
+  step: (msg) => {
+    console.log(`${prefix} ${c.cyan("\u203A")} ${msg}`);
+  },
+  ok: (msg) => {
+    console.log(`${prefix} ${c.green("\u2713")} ${msg}`);
+  },
+  warn: (msg) => {
+    console.error(`${prefix} ${c.yellow("warning:")} ${msg}`);
+  },
+  error: (msg) => {
+    console.error(`${prefix} ${c.red("error:")} ${msg}`);
+  },
+  hint: (msg) => {
+    console.error(`${prefix}   ${c.dim("hint:")} ${msg}`);
+  }
+};
+function reportError(err) {
+  if (err instanceof CliError) {
+    log.error(err.message);
+    for (const h of err.hints) log.hint(h);
+    return err.exitCode;
+  }
+  const e = err;
+  log.error(e?.message ?? inspect(err));
+  if (process.env.DORMER_CLI_DEBUG && e?.stack) console.error(e.stack);
+  else log.hint("set DORMER_CLI_DEBUG=1 for a stack trace");
+  return EXIT.failure;
+}
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} kB`;
+  return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}
+
+// src/args.ts
+var GLOBAL_OPTIONS = { help: { type: "boolean", description: "Show help for this command", alias: "h" } };
+function parseArgs(argv, spec7) {
+  const options = { ...GLOBAL_OPTIONS, ...spec7.options };
+  const aliases = /* @__PURE__ */ new Map();
+  for (const [name, o] of Object.entries(options)) if (o.alias) aliases.set(o.alias, name);
+  const flags = {};
+  const positionals = [];
+  const usage = (msg) => new CliError(msg, { exitCode: EXIT.usage, hints: [`run ${c.bold(`dormer ${spec7.name} --help`)} for usage`] });
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (!a.startsWith("-") || a === "-") {
+      positionals.push(a);
+      continue;
+    }
+    let name;
+    let inline;
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      name = eq === -1 ? a.slice(2) : a.slice(2, eq);
+      if (eq !== -1) inline = a.slice(eq + 1);
+    } else {
+      const short = a.slice(1);
+      const full = aliases.get(short);
+      if (!full) throw usage(`unknown option ${a}`);
+      name = full;
+    }
+    let negated = false;
+    if (!options[name] && name.startsWith("no-") && options[name.slice(3)]?.type === "boolean") {
+      name = name.slice(3);
+      negated = true;
+    }
+    const o = options[name];
+    if (!o) throw usage(`unknown option --${name}`);
+    if (o.type === "boolean") {
+      if (inline !== void 0) throw usage(`--${name} does not take a value`);
+      flags[name] = !negated;
+      continue;
+    }
+    const value = inline ?? argv[++i];
+    if (value === void 0) throw usage(`--${name} requires a value`);
+    if (o.values && !o.values.includes(value)) throw usage(`--${name} must be one of: ${o.values.join(", ")} (got "${value}")`);
+    if (o.type === "number") {
+      const n = Number(value);
+      if (!Number.isFinite(n)) throw usage(`--${name} must be a number`);
+      flags[name] = n;
+      continue;
+    }
+    if (o.type === "list") {
+      flags[name] = flags[name] ?? [];
+      flags[name].push(value);
+      continue;
+    }
+    flags[name] = value;
+  }
+  for (const [name, o] of Object.entries(spec7.options)) if (o.default !== void 0 && flags[name] === void 0) flags[name] = o.default;
+  return { positionals, flags };
+}
+function renderHelp(spec7) {
+  const lines = [`${c.bold(`dormer ${spec7.name}`)} \u2014 ${spec7.summary}`, "", `Usage: dormer ${spec7.usage}`];
+  if (spec7.description) lines.push("", spec7.description.trim());
+  const options = { ...spec7.options, ...GLOBAL_OPTIONS };
+  const names = Object.entries(options).map(([n, o]) => [`--${n}${o.alias ? `, -${o.alias}` : ""}${o.type === "boolean" ? "" : o.type === "list" ? " <value>\u2026" : " <value>"}`, o]);
+  const width = Math.max(...names.map(([n]) => n.length)) + 2;
+  lines.push("", "Options:");
+  for (const [n, o] of names) {
+    const extras = [o.values ? `one of ${o.values.join("|")}` : "", o.default !== void 0 ? `default ${String(o.default)}` : ""].filter(Boolean).join(", ");
+    lines.push(`  ${n.padEnd(width)}${o.description}${extras ? c.dim(` (${extras})`) : ""}`);
+  }
+  if (spec7.examples?.length) {
+    lines.push("", "Examples:");
+    for (const e of spec7.examples) lines.push(`  ${e}`);
+  }
+  return lines.join("\n");
+}
+var flagString = (flags, name) => typeof flags[name] === "string" ? flags[name] : void 0;
+var flagBool = (flags, name) => flags[name] === true;
+var flagNumber = (flags, name) => typeof flags[name] === "number" ? flags[name] : void 0;
+var flagList = (flags, name) => Array.isArray(flags[name]) ? flags[name] : [];
+
+// src/host.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+// src/resolve.ts
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+function findPackageDir(fromDir, name) {
+  let dir = path.resolve(fromDir);
+  for (; ; ) {
+    const candidate = path.join(dir, "node_modules", name);
+    if (fs.existsSync(path.join(candidate, "package.json"))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+function packageEsmEntry(pkgDir) {
+  const pkg = readJson(path.join(pkgDir, "package.json"));
+  const pick = (v) => {
+    if (typeof v === "string") return v;
+    if (!v || typeof v !== "object") return void 0;
+    const o = v;
+    for (const k of ["import", "node", "default"]) if (o[k] !== void 0) {
+      const r = pick(o[k]);
+      if (r) return r;
+    }
+    return void 0;
+  };
+  const fromExports = pkg.exports && typeof pkg.exports === "object" && !Array.isArray(pkg.exports) ? pick(pkg.exports["."] ?? pkg.exports) : pick(pkg.exports);
+  const rel = fromExports ?? pkg.module ?? pkg.main ?? "index.js";
+  return path.join(pkgDir, rel);
+}
+async function loadVite(root) {
+  const dir = findPackageDir(root, "vite");
+  if (!dir) throw new CliError(`vite is not installed in ${root}`, { hints: [`run ${c.bold("npm install")} in the app directory (vite is a devDependency of every template)`] });
+  const version2 = readJson(path.join(dir, "package.json")).version;
+  const vite = await import(pathToFileURL(packageEsmEntry(dir)).href);
+  return { vite, version: version2, dir };
+}
+function findViteConfig(rendererDir) {
+  for (const n of ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"]) {
+    const f = path.join(rendererDir, n);
+    if (fs.existsSync(f)) return f;
+  }
+  return void 0;
+}
+function findUp(start, marker) {
+  let dir = path.resolve(start);
+  for (; ; ) {
+    if (fs.existsSync(path.join(dir, marker))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function which(name) {
+  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    for (const ext of exts) {
+      const f = path.join(dir, name + ext.toLowerCase());
+      try {
+        fs.accessSync(f, fs.constants.X_OK);
+        if (fs.statSync(f).isFile()) return f;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/host.ts
+var CLI_DIR = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..");
+var EXE = process.platform === "win32" ? ".exe" : "";
+function hostPackageName() {
+  return `@dormer/host-${process.platform}-${process.arch}`;
+}
+function resolveHostBinary(appRoot) {
+  const tried = [];
+  const env = process.env.DORMER_HOST_BIN;
+  if (env) {
+    if (isExecutable(env)) return { path: path2.resolve(env), source: "env", tried };
+    throw new CliError(`DORMER_HOST_BIN is set but ${env} is not an executable file`, { exitCode: EXIT.missingTool, hints: ["unset DORMER_HOST_BIN or point it at a dormer-host binary"] });
+  }
+  const workspaces = /* @__PURE__ */ new Set();
+  for (const start of [appRoot, CLI_DIR]) {
+    const w = findUp(start, "Cargo.toml");
+    if (w) workspaces.add(w);
+  }
+  for (const w of workspaces) {
+    const targetDir = process.env.CARGO_TARGET_DIR ?? path2.join(w, "target");
+    for (const profile of ["release", "debug"]) {
+      const candidate = path2.join(targetDir, profile, `dormer-host${EXE}`);
+      tried.push(candidate);
+      if (isExecutable(candidate)) return { path: candidate, source: "cargo-target", tried };
+    }
+  }
+  const pkg = findPackageDir(appRoot, hostPackageName()) ?? findPackageDir(CLI_DIR, hostPackageName());
+  const fromPkg = pkg ? path2.join(pkg, "bin", `dormer-host${EXE}`) : path2.join(appRoot, "node_modules", hostPackageName(), "bin", `dormer-host${EXE}`);
+  tried.push(fromPkg);
+  if (isExecutable(fromPkg)) return { path: fromPkg, source: "package", tried };
+  throw new CliError("the native host binary (dormer-host) was not found", {
+    exitCode: EXIT.missingTool,
+    hints: [
+      `looked at:
+${tried.map((t) => `      ${t}`).join("\n")}`,
+      `inside the Dormer repository: ${c.bold("cargo build --release -p dormer-host")}`,
+      `or set ${c.bold("DORMER_HOST_BIN=/path/to/dormer-host")}`,
+      `(prebuilt binaries will ship as ${hostPackageName()} once published)`
+    ]
+  });
+}
+function isExecutable(file) {
+  try {
+    fs2.accessSync(file, fs2.constants.X_OK);
+    return fs2.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function hostArgs(l) {
+  const args = ["--app-dir", l.appDir, "--entry", l.entry, "--node", l.node, "--name", l.name];
+  if (l.dev) args.push("--dev");
+  if (l.devUrl) args.push("--dev-url", l.devUrl);
+  for (const v of new Set(l.passEnv ?? [])) args.push("--pass-env", v);
+  return args;
+}
+function spawnHost(l) {
+  const env = { ...process.env, ...l.env };
+  env.RUST_LOG ??= "info";
+  return spawn(l.host, hostArgs(l), { stdio: "inherit", env });
+}
+
+// src/commands/create.ts
+var create_exports = {};
+__export(create_exports, {
+  MONOREPO_PACKAGES: () => MONOREPO_PACKAGES,
+  TEMPLATES: () => TEMPLATES,
+  copyTemplate: () => copyTemplate,
+  identifierFor: () => identifierFor,
+  linkMonorepoPackages: () => linkMonorepoPackages,
+  monorepoRoot: () => monorepoRoot,
+  packageNameFor: () => packageNameFor,
+  run: () => run,
+  spec: () => spec,
+  templatesDir: () => templatesDir
+});
+import fs3 from "node:fs";
+import path3 from "node:path";
+var TEMPLATES = ["vanilla", "react", "vue", "svelte"];
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var spec = {
+  name: "create",
+  summary: "Scaffold a new Dormer app from a template",
+  usage: "create <dir> --template <name> [--pm npm] [--link] [--force]",
+  description: `Copies templates/<name> into <dir>, sets the package name and bundle identifier
+(com.example.<name>) and prints the next steps. Templates depend on the published @dormer/*
+packages; inside the Dormer monorepo pass --link to reference the local packages instead.`,
+  options: {
+    template: { type: "string", alias: "t", description: "Template to copy", values: TEMPLATES },
+    pm: { type: "string", description: "Package manager used in the printed next steps", values: PACKAGE_MANAGERS, default: "npm" },
+    link: { type: "boolean", description: "Write file: paths to this monorepo's @dormer/* packages (no publishing needed)" },
+    force: { type: "boolean", description: "Allow writing into a non-empty directory" }
+  },
+  examples: ["dormer create my-app --template react", "dormer create ../scratch/app --template svelte --link"]
+};
+var MONOREPO_PACKAGES = {
+  "@dormer/api": "packages/api",
+  "@dormer/renderer": "packages/renderer",
+  "@dormer/vite-plugin": "packages/vite-plugin",
+  "@dormer/cli": "packages/cli",
+  // transitive dependencies of @dormer/api, linked too so npm can satisfy them without a registry
+  "@dormer/node-runtime": "runtime/node-runtime",
+  "@dormer/ipc": "runtime/ipc/ts"
+};
+function templatesDir() {
+  for (const d of [path3.join(CLI_DIR, "templates"), path3.resolve(CLI_DIR, "..", "..", "templates")]) {
+    if (fs3.existsSync(path3.join(d, "vanilla", "package.json"))) return d;
+  }
+  throw new CliError("templates directory not found", { exitCode: EXIT.noInput, hints: [`expected ${path3.join(CLI_DIR, "templates")} or ${path3.resolve(CLI_DIR, "..", "..", "templates")}`] });
+}
+function monorepoRoot() {
+  const root = path3.resolve(CLI_DIR, "..", "..");
+  return fs3.existsSync(path3.join(root, "packages", "api", "package.json")) && fs3.existsSync(path3.join(root, "runtime", "ipc", "ts", "package.json")) ? root : void 0;
+}
+function packageNameFor(dir) {
+  const base = path3.basename(path3.resolve(dir)).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "");
+  return base || "dormer-app";
+}
+function identifierFor(name) {
+  const seg = name.replace(/[^a-z0-9-]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "app";
+  return `com.example.${/^[a-z]/.test(seg) ? seg : `app-${seg}`}`;
+}
+var TEXT_EXT = /* @__PURE__ */ new Set([".json", ".md", ".html", ".ts", ".tsx", ".vue", ".svelte", ".js", ".mjs", ".cjs", ".css", ".txt", ".yml", ".yaml"]);
+function copyTemplate(src, dest, vars) {
+  const written = [];
+  const walk = (from, to) => {
+    fs3.mkdirSync(to, { recursive: true });
+    for (const entry of fs3.readdirSync(from, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".dormer") continue;
+      const target = path3.join(to, entry.name === "_gitignore" ? ".gitignore" : entry.name);
+      const source = path3.join(from, entry.name);
+      if (entry.isDirectory()) {
+        walk(source, target);
+        continue;
+      }
+      if (TEXT_EXT.has(path3.extname(entry.name)) || entry.name === "_gitignore") {
+        let text = fs3.readFileSync(source, "utf8");
+        for (const [k, v] of Object.entries(vars)) text = text.replaceAll(`{{${k}}}`, v);
+        fs3.writeFileSync(target, text);
+      } else fs3.copyFileSync(source, target);
+      written.push(target);
+    }
+  };
+  walk(src, dest);
+  return written;
+}
+function linkMonorepoPackages(pkgJsonPath, repoRoot) {
+  const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
+  const linked = [];
+  for (const field of ["dependencies", "devDependencies"]) {
+    const deps = pkg[field];
+    if (!deps) continue;
+    for (const name of Object.keys(deps)) {
+      const rel = MONOREPO_PACKAGES[name];
+      if (rel) {
+        deps[name] = `file:${path3.join(repoRoot, rel)}`;
+        linked.push(name);
+      }
+    }
+  }
+  pkg.devDependencies ??= {};
+  for (const [name, rel] of Object.entries(MONOREPO_PACKAGES)) {
+    if (!pkg.dependencies?.[name] && !pkg.devDependencies[name]) {
+      pkg.devDependencies[name] = `file:${path3.join(repoRoot, rel)}`;
+      linked.push(name);
+    }
+  }
+  fs3.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+  return linked;
+}
+async function run(args) {
+  const target = args.positionals[0];
+  const template = flagString(args.flags, "template");
+  if (!target) throw new CliError("missing <dir>", { exitCode: EXIT.usage, hints: [`example: ${c.bold("dormer create my-app --template vanilla")}`] });
+  if (!template) throw new CliError("missing --template", { exitCode: EXIT.usage, hints: [`choose one of: ${TEMPLATES.join(", ")}`] });
+  const dest = path3.resolve(target);
+  const src = path3.join(templatesDir(), template);
+  if (!fs3.existsSync(path3.join(src, "package.json"))) throw new CliError(`template "${template}" not found at ${src}`, { exitCode: EXIT.noInput });
+  if (fs3.existsSync(dest) && fs3.readdirSync(dest).length > 0 && !flagBool(args.flags, "force")) {
+    throw new CliError(`${dest} exists and is not empty`, { exitCode: EXIT.usage, hints: ["choose another directory or pass --force"] });
+  }
+  const name = packageNameFor(dest);
+  const vars = { name, identifier: identifierFor(name), template };
+  log.step(`creating ${c.bold(name)} from the ${template} template in ${dest}`);
+  const files = copyTemplate(src, dest, vars);
+  log.info(`${files.length} files written`);
+  if (flagBool(args.flags, "link")) {
+    const repo = monorepoRoot();
+    if (!repo) throw new CliError("--link requires running the CLI from a checkout of the Dormer monorepo", { exitCode: EXIT.usage, hints: ["without --link the templates reference the published @dormer/* packages"] });
+    const linked = linkMonorepoPackages(path3.join(dest, "package.json"), repo);
+    log.info(`linked ${linked.length} @dormer packages to ${repo} via file: paths`);
+  }
+  const pm = flagString(args.flags, "pm") ?? "npm";
+  const runCmd = (s) => pm === "npm" ? `npm run ${s}` : `${pm} ${s}`;
+  const rel = path3.relative(process.cwd(), dest) || ".";
+  console.log(`
+${c.green("Done.")} Next steps:
+
+  cd ${rel}
+  ${pm} install
+  ${runCmd("dev")}        ${c.dim("# Vite dev server + native window with live backend rebuilds")}
+  ${runCmd("build")}      ${c.dim("# dist/renderer + dist/main.js + dist/dormer-app.json")}
+  ${runCmd("package")}    ${c.dim("# installers via dormer-bundle")}
+
+Run ${c.bold("npx dormer doctor")} if the window does not open.
+`);
+  return EXIT.ok;
+}
+
+// src/commands/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  findFreePort: () => findFreePort,
+  run: () => run2,
+  spec: () => spec2
+});
+import net from "node:net";
+import { once } from "node:events";
+
+// src/config.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+var CONFIG_FILE = "dormer.config.json";
+var BUNDLE_TARGETS = ["deb", "rpm", "appimage", "app", "dmg", "nsis", "msi"];
+function findAppRoot(start = process.cwd()) {
+  let dir = path4.resolve(start);
+  for (; ; ) {
+    if (fs4.existsSync(path4.join(dir, CONFIG_FILE))) return dir;
+    const parent = path4.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+var IDENTIFIER_RE = /^[A-Za-z][A-Za-z0-9-]*(\.[A-Za-z0-9-]+)+$/;
+var VERSION_RE = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/;
+function validateConfig(cfg) {
+  const problems = [];
+  if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) return ["top level must be an object"];
+  const o = cfg;
+  const str = (k, required) => {
+    if (o[k] === void 0) {
+      if (required) problems.push(`"${k}" is required`);
+      return;
+    }
+    if (typeof o[k] !== "string" || o[k].length === 0) problems.push(`"${k}" must be a non-empty string`);
+  };
+  str("name", true);
+  str("identifier", true);
+  str("version", true);
+  str("description", false);
+  str("entry", false);
+  str("renderer", false);
+  if (typeof o.identifier === "string" && !IDENTIFIER_RE.test(o.identifier)) problems.push(`"identifier" must be reverse-DNS like com.example.myapp (got "${o.identifier}")`);
+  if (typeof o.version === "string" && !VERSION_RE.test(o.version)) problems.push(`"version" must be semver like 1.2.3 (got "${o.version}")`);
+  if (o.windows !== void 0) {
+    if (!o.windows || typeof o.windows !== "object" || Array.isArray(o.windows)) problems.push(`"windows" must be an object keyed by window name`);
+    else for (const [name, w] of Object.entries(o.windows)) {
+      const caps = w?.capabilities;
+      if (caps !== void 0 && (!Array.isArray(caps) || caps.some((x) => typeof x !== "string"))) problems.push(`"windows.${name}.capabilities" must be an array of strings`);
+    }
+  }
+  const node = o.node;
+  if (node !== void 0) {
+    if (!node || typeof node !== "object") problems.push(`"node" must be an object`);
+    else {
+      if (node.version !== void 0 && (typeof node.version !== "string" || !/^\d+(\.\d+){0,2}$/.test(node.version))) problems.push(`"node.version" must be a version like "24" or "24.4.0"`);
+      if (node.binary !== void 0 && typeof node.binary !== "string") problems.push(`"node.binary" must be a path string`);
+    }
+  }
+  const bundle = o.bundle;
+  if (bundle?.targets !== void 0) {
+    if (!Array.isArray(bundle.targets)) problems.push(`"bundle.targets" must be an array`);
+    else for (const t of bundle.targets) if (!BUNDLE_TARGETS.includes(String(t))) problems.push(`"bundle.targets" contains unknown target "${String(t)}" (known: ${BUNDLE_TARGETS.join(", ")})`);
+  }
+  return problems;
+}
+function loadConfig(root) {
+  const file = path4.join(root, CONFIG_FILE);
+  if (!fs4.existsSync(file)) {
+    throw new CliError(`no ${CONFIG_FILE} found in ${root} (or any parent directory)`, {
+      exitCode: EXIT.config,
+      hints: [`run this command inside a Dormer app, or create one with ${c.bold("dormer create my-app --template vanilla")}`]
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+  } catch (e) {
+    throw new CliError(`${file} is not valid JSON: ${e.message}`, { exitCode: EXIT.config });
+  }
+  const problems = validateConfig(parsed);
+  if (problems.length) throw new CliError(`${file} is invalid:
+  - ${problems.join("\n  - ")}`, { exitCode: EXIT.config, hints: ["see packages/cli/README.md for the config schema"] });
+  return parsed;
+}
+function resolvePaths(root, config) {
+  const distDir = path4.join(root, "dist");
+  const devDir = path4.join(root, ".dormer", "dev");
+  return {
+    root,
+    configPath: path4.join(root, CONFIG_FILE),
+    entry: path4.resolve(root, config.entry ?? "src/main.ts"),
+    rendererDir: path4.resolve(root, config.renderer ?? "renderer"),
+    distDir,
+    rendererOut: path4.join(distDir, "renderer"),
+    backendOut: path4.join(distDir, "main.js"),
+    devDir,
+    devBackendOut: path4.join(devDir, "main.js")
+  };
+}
+function loadApp(cwd = process.cwd()) {
+  const root = findAppRoot(cwd) ?? cwd;
+  const config = loadConfig(root);
+  return { root, config, paths: resolvePaths(root, config) };
+}
+
+// src/backend.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { isBuiltin } from "node:module";
+import * as esbuild from "esbuild";
+var NATIVE_DEP_RE = /^(node-gyp-build|node-gyp-build-optional-packages|bindings|prebuild-install|prebuildify|@mapbox\/node-pre-gyp|node-pre-gyp|node-addon-api|cmake-js|nan|napi-build-utils|pkg-prebuilds)$/;
+function packageName(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:")) return void 0;
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0 : parts[0];
+}
+function findPackageJson(fromDir, name) {
+  let dir = fromDir;
+  for (; ; ) {
+    const f = path5.join(dir, "node_modules", name, "package.json");
+    if (fs5.existsSync(f)) {
+      try {
+        return JSON.parse(fs5.readFileSync(f, "utf8"));
+      } catch {
+        return void 0;
+      }
+    }
+    const parent = path5.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function looksNative(pkg) {
+  if (pkg.gypfile || pkg.binary || pkg.napi) return true;
+  for (const k of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+    const deps = pkg[k];
+    if (deps && typeof deps === "object" && Object.keys(deps).some((d) => NATIVE_DEP_RE.test(d))) return true;
+  }
+  return false;
+}
+function externalsPlugin(externals, explicit) {
+  return {
+    name: "dormer-externals",
+    setup(build2) {
+      build2.onResolve({ filter: /\.node$/ }, (args) => ({ path: args.path, external: true }));
+      build2.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (args.kind === "entry-point") return void 0;
+        const name = packageName(args.path);
+        if (!name) return void 0;
+        if (isBuiltin(name)) return { path: args.path, external: true };
+        if (explicit.includes(name)) {
+          externals.add(name);
+          return { path: args.path, external: true };
+        }
+        if (name.startsWith("@dormer/")) return void 0;
+        const pkg = findPackageJson(args.resolveDir, name);
+        if (pkg && looksNative(pkg)) {
+          externals.add(name);
+          return { path: args.path, external: true };
+        }
+        return void 0;
+      });
+    }
+  };
+}
+var BANNER = `import { createRequire as __dormerCreateRequire } from "node:module";
+const require = __dormerCreateRequire(import.meta.url);
+`;
+function buildOptions(o, externals) {
+  return {
+    entryPoints: [o.entry],
+    outfile: o.outfile,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    target: "node22",
+    conditions: ["node", "import", "module", "default"],
+    mainFields: ["module", "main"],
+    sourcemap: o.sourcemap === false ? false : true,
+    minify: o.minify === true,
+    legalComments: "none",
+    logLevel: "silent",
+    absWorkingDir: o.root,
+    banner: { js: BANNER },
+    define: { "process.env.DORMER_BUNDLED": '"1"', ...o.define },
+    plugins: [externalsPlugin(externals, o.external ?? [])],
+    metafile: true
+  };
+}
+function formatMessages(messages, kind) {
+  return esbuild.formatMessagesSync(messages, { kind, color: Boolean(process.stdout.isTTY) }).join("");
+}
+async function bundleBackend(o) {
+  if (!fs5.existsSync(o.entry)) throw new CliError(`backend entry not found: ${o.entry}`, { exitCode: EXIT.noInput, hints: [`set "entry" in dormer.config.json (default src/main.ts)`] });
+  const externals = /* @__PURE__ */ new Set();
+  fs5.mkdirSync(path5.dirname(o.outfile), { recursive: true });
+  let result;
+  try {
+    result = await esbuild.build(buildOptions(o, externals));
+  } catch (e) {
+    const err = e;
+    if (err.errors?.length) throw new CliError(`backend bundle failed:
+${formatMessages(err.errors, "error")}`, { hints: [`entry: ${o.entry}`] });
+    throw e;
+  }
+  const bytes = fs5.statSync(o.outfile).size;
+  return { outfile: o.outfile, bytes, externals: [...externals].sort(), warnings: result.warnings };
+}
+async function watchBackend(o, onBuild) {
+  if (!fs5.existsSync(o.entry)) throw new CliError(`backend entry not found: ${o.entry}`, { exitCode: EXIT.noInput, hints: [`set "entry" in dormer.config.json (default src/main.ts)`] });
+  const externals = /* @__PURE__ */ new Set();
+  fs5.mkdirSync(path5.dirname(o.outfile), { recursive: true });
+  const options = buildOptions(o, externals);
+  options.plugins.push({
+    name: "dormer-watch-notify",
+    setup(build2) {
+      build2.onEnd((r) => onBuild({ ok: r.errors.length === 0, errors: r.errors, warnings: r.warnings, externals: [...externals].sort() }));
+    }
+  });
+  const ctx = await esbuild.context(options);
+  await ctx.watch();
+  return { dispose: () => ctx.dispose() };
+}
+function summarizeExternals(externals) {
+  return externals.length ? `${externals.length} native/external package(s) kept out of the bundle: ${c.bold(externals.join(", "))}` : "no external packages (everything bundled)";
+}
+
+// src/commands/dev.ts
+var spec2 = {
+  name: "dev",
+  summary: "Run the app with the Vite dev server, backend rebuilds and the native host",
+  usage: "dev [--port <n>] [--host <name>] [--pass-env <VAR>]...",
+  description: `Starts Vite for renderer/ (HMR), bundles the backend with esbuild in watch mode to
+.dormer/dev/main.js and launches dormer-host with --dev --dev-url <vite url>. The backend sees
+DORMER_DEV_URL and should call win.loadURL(process.env.DORMER_DEV_URL) (templates do). When the
+backend bundle changes the host is restarted. Ctrl-C or closing the last window stops everything.`,
+  options: {
+    port: { type: "number", description: "Preferred Vite port (the next free port is used if busy)" },
+    host: { type: "string", description: "Host name Vite listens on", default: "localhost" },
+    "pass-env": { type: "list", description: "Environment variable to forward into the Node sidecar (repeatable)" }
+  },
+  examples: ["dormer dev", "dormer dev --port 3000 --pass-env MY_API_KEY"]
+};
+async function portFree(port, host) {
+  return new Promise((resolve) => {
+    const s = net.createServer();
+    s.once("error", () => resolve(false));
+    s.listen(port, host, () => s.close(() => resolve(true)));
+  });
+}
+async function findFreePort(preferred, host) {
+  for (let p = preferred; p < preferred + 50; p++) if (await portFree(p, host)) return p;
+  throw new Error(`no free port in ${preferred}-${preferred + 49}`);
+}
+var alive = (p) => Boolean(p && p.exitCode === null && p.signalCode === null);
+async function run2(args) {
+  const app = loadApp();
+  const { config, paths } = app;
+  const host = resolveHostBinary(app.root);
+  const hostName = flagString(args.flags, "host") ?? "localhost";
+  const port = await findFreePort(flagNumber(args.flags, "port") ?? config.dev?.port ?? 5173, hostName);
+  const { vite, version: version2 } = await loadVite(app.root);
+  const configFile = findViteConfig(paths.rendererDir);
+  if (!configFile) log.warn(`no vite.config.* in ${paths.rendererDir}; add one using @dormer/vite-plugin`);
+  const server = await vite.createServer({
+    root: paths.rendererDir,
+    configFile: configFile ?? false,
+    clearScreen: false,
+    logLevel: "info",
+    server: { port, strictPort: true, host: hostName }
+  });
+  await server.listen();
+  const url = server.resolvedUrls?.local[0] ?? `http://${hostName}:${port}/`;
+  log.ok(`vite ${version2} dev server ready at ${c.bold(url)}`);
+  const passEnv = /* @__PURE__ */ new Set(["DORMER_DEV_URL", "DORMER_APP_VERSION", ...config.dev?.passEnv ?? [], ...flagList(args.flags, "pass-env")]);
+  if (process.env.DORMER_SELFTEST !== void 0) passEnv.add("DORMER_SELFTEST");
+  let child;
+  let generation = 0;
+  let pendingRestart = false;
+  let shuttingDown = false;
+  let watcher;
+  const shutdown = async (code) => {
+    if (shuttingDown) await new Promise(() => {
+    });
+    shuttingDown = true;
+    if (alive(child)) {
+      child.kill("SIGTERM");
+      await Promise.race([once(child, "exit"), new Promise((r) => setTimeout(r, 3e3))]);
+      if (alive(child)) child.kill("SIGKILL");
+    }
+    await watcher?.dispose().catch(() => {
+    });
+    await server.close().catch(() => {
+    });
+    process.exit(code);
+  };
+  const launch = () => {
+    const myGeneration = ++generation;
+    const proc = spawnHost({
+      host: host.path,
+      appDir: app.root,
+      entry: paths.devBackendOut,
+      node: process.execPath,
+      name: config.name,
+      dev: true,
+      devUrl: url,
+      passEnv: [...passEnv],
+      env: { DORMER_DEV_URL: url, DORMER_APP_VERSION: config.version }
+    });
+    child = proc;
+    log.ok(`host started (pid ${proc.pid}) from ${host.path} [${host.source}]`);
+    proc.on("error", (e) => {
+      log.error(`failed to start host: ${e.message}`);
+      void shutdown(EXIT.failure);
+    });
+    proc.on("exit", (code, signal) => {
+      if (shuttingDown || myGeneration !== generation) return;
+      if (pendingRestart) {
+        pendingRestart = false;
+        launch();
+        return;
+      }
+      log.info(`host exited (${signal ?? `code ${code}`}); stopping dev server`);
+      void shutdown(code ?? EXIT.ok);
+    });
+  };
+  const restart = () => {
+    if (!alive(child)) {
+      launch();
+      return;
+    }
+    pendingRestart = true;
+    log.step("backend changed \u2014 restarting host (windows are recreated)");
+    const victim = child;
+    victim.kill("SIGTERM");
+    setTimeout(() => {
+      if (alive(victim)) victim.kill("SIGKILL");
+    }, 3e3).unref();
+  };
+  let builds = 0;
+  watcher = await watchBackend({ root: app.root, entry: paths.entry, outfile: paths.devBackendOut, sourcemap: true, external: config.backend?.external }, (r) => {
+    builds++;
+    if (r.warnings.length) console.error(formatMessages(r.warnings, "warning"));
+    if (!r.ok) {
+      log.error(`backend bundle failed (${builds === 1 ? "fix the error to start the host" : "keeping the previous host running"})
+${formatMessages(r.errors, "error")}`);
+      return;
+    }
+    if (builds === 1) {
+      log.ok(`backend bundled \u2192 ${paths.devBackendOut} (${summarizeExternals(r.externals)})`);
+      launch();
+    } else restart();
+  });
+  process.on("SIGINT", () => {
+    console.log();
+    void shutdown(130);
+  });
+  process.on("SIGTERM", () => void shutdown(143));
+  return new Promise(() => {
+  });
+}
+
+// src/commands/build.ts
+var build_exports = {};
+__export(build_exports, {
+  buildApp: () => buildApp,
+  cliVersion: () => cliVersion,
+  makeManifest: () => makeManifest,
+  run: () => run3,
+  spec: () => spec3
+});
+import fs6 from "node:fs";
+import path6 from "node:path";
+var spec3 = {
+  name: "build",
+  summary: "Build the renderer and the backend into dist/",
+  usage: "build [--minify] [--no-sourcemap] [--quiet]",
+  description: `Runs \`vite build\` for the renderer (\u2192 dist/renderer), bundles the backend with esbuild
+(\u2192 dist/main.js + .map), copies ${CONFIG_FILE} and writes dist/dormer-app.json. dist/ is owned by
+this command and is recreated on every run.`,
+  options: {
+    minify: { type: "boolean", description: "Minify the backend bundle" },
+    sourcemap: { type: "boolean", description: "Emit dist/main.js.map (use --no-sourcemap to disable)", default: true },
+    quiet: { type: "boolean", description: "Only print warnings and errors from Vite" }
+  }
+};
+function cliVersion() {
+  try {
+    return readJson(path6.join(CLI_DIR, "package.json")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function makeManifest(config, externals) {
+  return {
+    manifestVersion: 1,
+    name: config.name,
+    identifier: config.identifier,
+    version: config.version,
+    description: config.description,
+    entry: "main.js",
+    assets: "renderer",
+    node: { version: config.node?.version },
+    externals,
+    windows: config.windows,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cli: cliVersion()
+  };
+}
+async function buildApp(app, opts = {}) {
+  const { config, paths } = app;
+  if (!fs6.existsSync(paths.rendererDir)) throw new CliError(`renderer directory not found: ${paths.rendererDir}`, { exitCode: EXIT.noInput, hints: [`set "renderer" in ${CONFIG_FILE} (default "renderer")`] });
+  if (!fs6.existsSync(paths.entry)) throw new CliError(`backend entry not found: ${paths.entry}`, { exitCode: EXIT.noInput, hints: [`set "entry" in ${CONFIG_FILE} (default "src/main.ts")`] });
+  fs6.rmSync(paths.distDir, { recursive: true, force: true });
+  fs6.mkdirSync(paths.distDir, { recursive: true });
+  const { vite, version: version2 } = await loadVite(app.root);
+  log.step(`building renderer with vite ${version2} \u2192 ${path6.relative(app.root, paths.rendererOut)}`);
+  const configFile = findViteConfig(paths.rendererDir);
+  if (!configFile) log.warn(`no vite.config.* in ${paths.rendererDir}; add one using @dormer/vite-plugin`);
+  await vite.build({
+    root: paths.rendererDir,
+    configFile: configFile ?? false,
+    logLevel: opts.quiet ? "warn" : "info",
+    build: { outDir: paths.rendererOut, emptyOutDir: true }
+  });
+  if (!fs6.existsSync(path6.join(paths.rendererOut, "index.html"))) {
+    throw new CliError(`vite build produced no ${path6.join(paths.rendererOut, "index.html")}`, { hints: ["the renderer must have an index.html at its root; check build.outDir is not overridden"] });
+  }
+  log.step(`bundling backend ${path6.relative(app.root, paths.entry)} \u2192 ${path6.relative(app.root, paths.backendOut)}`);
+  const backend = await bundleBackend({ root: app.root, entry: paths.entry, outfile: paths.backendOut, minify: opts.minify, sourcemap: opts.sourcemap !== false, external: config.backend?.external });
+  if (backend.warnings.length) console.error(formatMessages(backend.warnings, "warning"));
+  log.info(`backend ${formatBytes(backend.bytes)}; ${summarizeExternals(backend.externals)}`);
+  fs6.copyFileSync(paths.configPath, path6.join(paths.distDir, CONFIG_FILE));
+  const manifest = makeManifest(config, backend.externals);
+  const manifestPath = path6.join(paths.distDir, "dormer-app.json");
+  fs6.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  log.ok(`built ${c.bold(`${config.name} ${config.version}`)} \u2192 ${paths.distDir}`);
+  return { manifest, backend, manifestPath };
+}
+async function run3(args) {
+  const app = loadApp();
+  await buildApp(app, { minify: flagBool(args.flags, "minify"), sourcemap: args.flags.sourcemap !== false, quiet: flagBool(args.flags, "quiet") });
+  return EXIT.ok;
+}
+
+// src/commands/package.ts
+var package_exports = {};
+__export(package_exports, {
+  bundlePackageName: () => bundlePackageName,
+  defaultTargets: () => defaultTargets,
+  findIcuData: () => findIcuData,
+  makeBundleSpec: () => makeBundleSpec,
+  resolveBundlerBinary: () => resolveBundlerBinary,
+  resolveNodeBinary: () => resolveNodeBinary,
+  run: () => run4,
+  spec: () => spec4
+});
+import fs7 from "node:fs";
+import path7 from "node:path";
+import { spawnSync } from "node:child_process";
+var spec4 = {
+  name: "package",
+  summary: "Produce installers for the current platform with dormer-bundle",
+  usage: "package [--target <t>]... [--out <dir>] [--skip-build] [--dry-run]",
+  description: `Builds the app (unless --skip-build), writes dist/bundle.json describing it, then runs
+\`dormer-bundle --config dist/bundle.json --out <dir>\`. The bundler binary is looked up in
+$DORMER_BUNDLE_BIN, the cargo target directory and PATH; when missing, instructions are printed
+and the exit code is 2. --dry-run stops after writing bundle.json.`,
+  options: {
+    target: { type: "list", alias: "t", description: "Installer format (repeatable)", values: BUNDLE_TARGETS },
+    out: { type: "string", description: "Output directory", default: "dist/bundle" },
+    "skip-build": { type: "boolean", description: "Reuse the existing dist/ instead of rebuilding" },
+    "dry-run": { type: "boolean", description: "Only write dist/bundle.json" }
+  }
+};
+function findIcuData(nodeBinary) {
+  const dir = path7.dirname(nodeBinary);
+  try {
+    const f = fs7.readdirSync(dir).find((n) => /^icudt\d+l\.dat$/.test(n));
+    return f ? path7.join(dir, f) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function defaultTargets(platform = process.platform) {
+  if (platform === "darwin") return ["app", "dmg"];
+  if (platform === "win32") return ["nsis"];
+  return ["deb", "appimage"];
+}
+var DEFAULT_LINUX_DEPENDS = ["libwebkit2gtk-4.1-0", "libgtk-3-0"];
+function makeBundleSpec(config, o) {
+  const b = config.bundle ?? {};
+  let icons = (b.icons ?? []).map((p) => path7.resolve(o.root, p));
+  if (icons.length === 0 && fs7.existsSync(path7.join(o.root, "icons"))) {
+    icons = fs7.readdirSync(path7.join(o.root, "icons")).filter((f) => /\.(png|icns|ico|svg)$/i.test(f)).map((f) => path7.join(o.root, "icons", f));
+  }
+  return {
+    name: config.name,
+    identifier: config.identifier,
+    version: config.version,
+    description: config.description ?? "",
+    appDir: o.appDir,
+    entry: "main.js",
+    hostBinary: o.hostBinary,
+    nodeBinary: o.nodeBinary,
+    targets: o.targets,
+    icons,
+    linux: { depends: b.linux?.depends ?? DEFAULT_LINUX_DEPENDS },
+    macos: { entitlements: b.macos?.entitlements ? path7.resolve(o.root, b.macos.entitlements) : null, signingIdentity: b.macos?.signingIdentity ?? null, minimumSystemVersion: b.macos?.minimumSystemVersion ?? "13.0" },
+    windows: { signCommand: b.windows?.signCommand ?? null },
+    sourceMaps: b.sourceMaps ?? false,
+    nodeIcuData: config.node?.icu === "full" ? findIcuData(o.nodeBinary) ?? null : null
+  };
+}
+function resolveBundlerBinary(appRoot) {
+  const exe = process.platform === "win32" ? "dormer-bundle.exe" : "dormer-bundle";
+  const tried = [];
+  if (process.env.DORMER_BUNDLE_BIN) {
+    tried.push(process.env.DORMER_BUNDLE_BIN);
+    if (isExecutable(process.env.DORMER_BUNDLE_BIN)) return { path: process.env.DORMER_BUNDLE_BIN, tried };
+  }
+  const workspaces = /* @__PURE__ */ new Set();
+  for (const start of [appRoot, CLI_DIR]) {
+    const ws = findUp(start, "Cargo.toml");
+    if (ws) workspaces.add(ws);
+  }
+  for (const ws of workspaces) {
+    for (const profile of ["release", "debug"]) {
+      const candidate = path7.join(process.env.CARGO_TARGET_DIR ?? path7.join(ws, "target"), profile, exe);
+      tried.push(candidate);
+      if (isExecutable(candidate)) return { path: candidate, tried };
+    }
+  }
+  const pkg = findPackageDir(appRoot, bundlePackageName()) ?? findPackageDir(CLI_DIR, bundlePackageName());
+  const fromPkg = pkg ? path7.join(pkg, "bin", exe) : path7.join(appRoot, "node_modules", bundlePackageName(), "bin", exe);
+  tried.push(fromPkg);
+  if (isExecutable(fromPkg)) return { path: fromPkg, tried };
+  const onPath = which("dormer-bundle");
+  tried.push("$PATH");
+  return { path: onPath, tried };
+}
+function bundlePackageName() {
+  return `@dormer/bundle-${process.platform}-${process.arch}`;
+}
+function resolveNodeBinary(config) {
+  const candidate = config.node?.binary ?? process.env.DORMER_NODE_BIN ?? process.execPath;
+  if (!isExecutable(candidate)) throw new CliError(`Node binary not found: ${candidate}`, { exitCode: EXIT.noInput, hints: ['set "node.binary" in dormer.config.json or DORMER_NODE_BIN'] });
+  return candidate;
+}
+async function run4(args) {
+  const app = loadApp();
+  const { config, paths } = app;
+  if (!flagBool(args.flags, "skip-build")) await buildApp(app, { quiet: true });
+  else if (!fs7.existsSync(path7.join(paths.distDir, "dormer-app.json"))) throw new CliError("--skip-build given but dist/dormer-app.json does not exist", { exitCode: EXIT.noInput, hints: [`run ${c.bold("dormer build")} first`] });
+  const requested = flagList(args.flags, "target");
+  const targets = requested.length ? requested : config.bundle?.targets ?? defaultTargets();
+  const host = resolveHostBinary(app.root);
+  const nodeBinary = resolveNodeBinary(config);
+  const pinned = config.node?.version;
+  if (pinned && pinned.split(".")[0] !== process.versions.node.split(".")[0] && nodeBinary === process.execPath) {
+    log.warn(`dormer.config.json pins Node ${pinned} but the app is packaged with the running Node ${process.versions.node}; set "node.binary" to a Node ${pinned} executable to ship that one`);
+  }
+  const bundle = makeBundleSpec(config, { root: app.root, appDir: paths.distDir, hostBinary: host.path, nodeBinary, targets });
+  const specPath = path7.join(paths.distDir, "bundle.json");
+  fs7.writeFileSync(specPath, JSON.stringify(bundle, null, 2) + "\n");
+  log.ok(`wrote ${specPath} (targets: ${targets.join(", ")})`);
+  if (flagBool(args.flags, "dry-run")) return EXIT.ok;
+  const outDir = path7.resolve(app.root, flagString(args.flags, "out") ?? "dist/bundle");
+  const bundler = resolveBundlerBinary(app.root);
+  if (!bundler.path) {
+    log.error("dormer-bundle (the Rust packaging tool from tools/bundler) was not found");
+    log.hint(`looked at: ${bundler.tried.join(", ")}`);
+    log.hint(`inside the Dormer repository: ${c.bold("cargo build --release -p dormer-bundle")}`);
+    log.hint(`or set ${c.bold("DORMER_BUNDLE_BIN=/path/to/dormer-bundle")}`);
+    log.hint(`the generated ${specPath} can be passed to it manually: dormer-bundle --config ${specPath} --out ${outDir}`);
+    return EXIT.missingTool;
+  }
+  log.step(`running ${bundler.path} --config ${specPath} --out ${outDir}`);
+  fs7.mkdirSync(outDir, { recursive: true });
+  const r = spawnSync(bundler.path, ["--config", specPath, "--out", outDir], { stdio: "inherit" });
+  if (r.error) throw new CliError(`failed to run dormer-bundle: ${r.error.message}`);
+  if (r.status !== 0) {
+    log.error(`dormer-bundle exited with ${r.status ?? r.signal}`);
+    return r.status ?? EXIT.failure;
+  }
+  log.ok(`installers written to ${outDir}`);
+  return EXIT.ok;
+}
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  capabilitySummary: () => capabilitySummary,
+  nodeCheck: () => nodeCheck,
+  run: () => run5,
+  runChecks: () => runChecks,
+  spec: () => spec5
+});
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var spec5 = {
+  name: "doctor",
+  summary: "Check the toolchain, the native host and platform prerequisites",
+  usage: "doctor",
+  description: `Exit code 1 when a check fails (warnings do not fail). Windows and macOS checks are
+written from documentation and have not been verified on those platforms yet.`,
+  options: {}
+};
+function sh(cmd, args) {
+  const r = spawnSync2(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return { ok: !r.error && r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
+}
+function nodeCheck(version2 = process.versions.node) {
+  const [major, minor] = version2.split(".").map(Number);
+  if (major < 22) return { name: "Node.js", status: "fail", detail: `v${version2} (22 or newer required)`, hint: "install Node 24 LTS from https://nodejs.org or with your version manager" };
+  if (major === 22 && minor < 18) return { name: "Node.js", status: "warn", detail: `v${version2} (type stripping needs --experimental-strip-types before 22.18; the CLI re-executes itself with it)`, hint: "upgrade to Node 22.18+ or 24 to avoid the re-exec" };
+  return { name: "Node.js", status: "ok", detail: `v${version2}` };
+}
+function hostCheck(root) {
+  try {
+    const h = resolveHostBinary(root);
+    return { name: "dormer-host", status: "ok", detail: `${h.path} (${h.source === "env" ? "DORMER_HOST_BIN" : h.source === "cargo-target" ? "cargo target dir" : hostPackageName()})` };
+  } catch (e) {
+    const err = e;
+    return { name: "dormer-host", status: "fail", detail: err.message, hint: err.hints?.slice(1).join("; ") };
+  }
+}
+function linuxChecks() {
+  const checks = [];
+  if (sh("pkg-config", ["--exists", "webkit2gtk-4.1"]).ok) checks.push({ name: "WebKitGTK 4.1", status: "ok", detail: `development package present (${sh("pkg-config", ["--modversion", "webkit2gtk-4.1"]).out})` });
+  else {
+    const ld = sh("ldconfig", ["-p"]);
+    if (ld.ok && /libwebkit2gtk-4\.1/.test(ld.out)) checks.push({ name: "WebKitGTK 4.1", status: "ok", detail: "runtime library present (dev headers missing: only needed to build the host)", hint: "to build dormer-host: sudo apt install libwebkit2gtk-4.1-dev libgtk-3-dev librsvg2-dev pkg-config" });
+    else checks.push({ name: "WebKitGTK 4.1", status: "fail", detail: "libwebkit2gtk-4.1 not found", hint: "sudo apt install libwebkit2gtk-4.1-0 (runtime) or libwebkit2gtk-4.1-dev (to build the host); Fedora: webkit2gtk4.1" });
+  }
+  const bus = process.env.DBUS_SESSION_BUS_ADDRESS || (process.env.XDG_RUNTIME_DIR && fs8.existsSync(path8.join(process.env.XDG_RUNTIME_DIR, "bus")) ? `unix:path=${path8.join(process.env.XDG_RUNTIME_DIR, "bus")}` : "");
+  checks.push(bus ? { name: "session D-Bus", status: "ok", detail: bus } : { name: "session D-Bus", status: "warn", detail: "no session bus (DBUS_SESSION_BUS_ADDRESS unset, no $XDG_RUNTIME_DIR/bus)", hint: "WebKitGTK and notifications want one: run under dbus-run-session -- <command>" });
+  const display = process.env.WAYLAND_DISPLAY ? `wayland (${process.env.WAYLAND_DISPLAY})` : process.env.DISPLAY ? `x11 (${process.env.DISPLAY})` : "";
+  checks.push(display ? { name: "display", status: "ok", detail: display } : { name: "display", status: "warn", detail: "no DISPLAY or WAYLAND_DISPLAY", hint: 'headless machines: xvfb-run -a -s "-screen 0 1280x800x24" dbus-run-session -- npm run dev' });
+  const nvidia = fs8.existsSync("/proc/driver/nvidia/version") || Boolean(which("nvidia-smi"));
+  if (nvidia) checks.push({ name: "GPU driver", status: "warn", detail: "NVIDIA driver detected", hint: "if windows stay blank or crash in the compositor, set WEBKIT_DISABLE_DMABUF_RENDERER=1" });
+  const headless = ["xvfb-run", "dbus-run-session"].filter((t) => !which(t));
+  checks.push(headless.length ? { name: "headless tools", status: "warn", detail: `missing ${headless.join(", ")} (only needed for headless test runs)`, hint: "sudo apt install xvfb dbus" } : { name: "headless tools", status: "ok", detail: "xvfb-run and dbus-run-session available" });
+  return checks;
+}
+function macosChecks() {
+  const clt = sh("xcode-select", ["-p"]);
+  const sw = sh("sw_vers", ["-productVersion"]);
+  const major = Number(sw.out.split(".")[0]);
+  return [
+    clt.ok ? { name: "Xcode command line tools", status: "ok", detail: clt.out } : { name: "Xcode command line tools", status: "fail", detail: "not installed", hint: "run: xcode-select --install" },
+    sw.ok ? major >= 13 ? { name: "macOS", status: "ok", detail: sw.out } : { name: "macOS", status: "warn", detail: `${sw.out} (13+ recommended for WKWebView features Dormer relies on)` } : { name: "macOS", status: "warn", detail: "sw_vers unavailable" }
+  ];
+}
+function windowsChecks() {
+  const keys = [
+    "HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}",
+    "HKLM\\SOFTWARE\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}",
+    "HKCU\\SOFTWARE\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"
+  ];
+  for (const k of keys) {
+    const r = sh("reg", ["query", k, "/v", "pv"]);
+    const m = r.ok ? /pv\s+REG_SZ\s+(\S+)/.exec(r.out) : null;
+    if (m && m[1] !== "0.0.0.0") return [{ name: "WebView2 runtime", status: "ok", detail: `version ${m[1]}` }];
+  }
+  return [{ name: "WebView2 runtime", status: "fail", detail: "Evergreen WebView2 runtime not registered", hint: "install it from https://developer.microsoft.com/microsoft-edge/webview2/ (Windows 11 ships it)" }];
+}
+function projectChecks(root) {
+  const checks = [];
+  const esb = findPackageDir(CLI_DIR, "esbuild");
+  checks.push(esb ? { name: "esbuild", status: "ok", detail: `v${readJson(path8.join(esb, "package.json")).version}` } : { name: "esbuild", status: "fail", detail: "not resolvable from @dormer/cli", hint: "reinstall @dormer/cli" });
+  if (!root) return checks;
+  const vite = findPackageDir(root, "vite");
+  checks.push(vite ? { name: "vite", status: "ok", detail: `v${readJson(path8.join(vite, "package.json")).version} (${vite})` } : { name: "vite", status: "fail", detail: `not installed in ${root}`, hint: "npm install (vite is a devDependency of every template)" });
+  for (const p of ["@dormer/api", "@dormer/renderer", "@dormer/vite-plugin"]) {
+    const dir = findPackageDir(root, p);
+    checks.push(dir ? { name: p, status: "ok", detail: fs8.realpathSync(dir) } : { name: p, status: "warn", detail: "not installed", hint: `npm install ${p}` });
+  }
+  return checks;
+}
+function capabilitySummary(config, root) {
+  const paths = resolvePaths(root, config);
+  const lines = [
+    `${c.bold(config.name)} ${config.version} (${config.identifier})${config.description ? ` \u2014 ${config.description}` : ""}`,
+    `entry ${path8.relative(root, paths.entry)} \xB7 renderer ${path8.relative(root, paths.rendererDir)}/ \xB7 node pin ${config.node?.version ?? c.dim("none")}`
+  ];
+  const windows = Object.entries(config.windows ?? {});
+  if (windows.length === 0) lines.push(`windows: ${c.dim("none declared (renderers get app-local ipc:*/send:* only)")}`);
+  for (const [name, w] of windows) lines.push(`window ${c.bold(name)}: ${(w.capabilities ?? []).length ? w.capabilities.join(", ") : c.dim("no capabilities")}`);
+  if (config.backend?.external?.length) lines.push(`backend externals: ${config.backend.external.join(", ")}`);
+  return lines;
+}
+function runChecks(root) {
+  const checks = [nodeCheck(), hostCheck(root ?? process.cwd())];
+  if (process.platform === "linux") checks.push(...linuxChecks());
+  else if (process.platform === "darwin") checks.push(...macosChecks());
+  else if (process.platform === "win32") checks.push(...windowsChecks());
+  checks.push(...projectChecks(root));
+  return checks;
+}
+async function run5(_args) {
+  const root = findAppRoot(process.cwd());
+  console.log(`${c.bold("dormer doctor")} \u2014 ${process.platform} ${process.arch}${root ? `, app at ${root}` : ` (no ${CONFIG_FILE} found from ${process.cwd()})`}`);
+  const checks = runChecks(root);
+  const icon = { ok: c.green("\u2713"), warn: c.yellow("!"), fail: c.red("\u2717") };
+  const width = Math.max(...checks.map((k) => k.name.length)) + 2;
+  for (const k of checks) {
+    console.log(`  ${icon[k.status]} ${k.name.padEnd(width)}${k.detail}`);
+    if (k.hint && k.status !== "ok") console.log(`      ${c.dim("hint:")} ${k.hint}`);
+  }
+  if (root) {
+    console.log(`
+${c.bold("App")} (${path8.join(root, CONFIG_FILE)})`);
+    try {
+      for (const l of capabilitySummary(loadConfig(root), root)) console.log(`  ${l}`);
+    } catch (e) {
+      console.log(`  ${c.red("\u2717")} ${e.message}`);
+      return EXIT.config;
+    }
+  }
+  if (process.platform === "darwin" || process.platform === "win32") console.log(`
+${c.dim("note: platform checks on this OS are unverified; please report false results")}`);
+  const fails = checks.filter((k) => k.status === "fail").length;
+  const warns = checks.filter((k) => k.status === "warn").length;
+  console.log(`
+${fails ? c.red(`${fails} problem(s)`) : c.green("no problems")}${warns ? `, ${warns} warning(s)` : ""}`);
+  return fails ? EXIT.failure : EXIT.ok;
+}
+
+// src/commands/inspect.ts
+var inspect_exports = {};
+__export(inspect_exports, {
+  run: () => run6,
+  spec: () => spec6
+});
+import fs9 from "node:fs";
+import path9 from "node:path";
+var spec6 = {
+  name: "inspect",
+  summary: "Launch the app, capture each window's element tree (and snapshot), print an outline",
+  usage: "inspect [--out <dir>] [--skip-build] [--json] [--timeout <ms>] [--settle <ms>] [--lines <n>]",
+  description: `Runs the built app with DORMER_INSPECT_OUT set. @dormer/api then captures every window once it
+has loaded: an accessibility-style element tree (roles, names, states, bounds) as JSON and text, and a
+PNG snapshot where the platform supports it (macOS today). The app exits by itself; the outline is
+printed here. Files land in .dormer/inspect/ by default.`,
+  options: {
+    out: { type: "string", description: "Output directory (default .dormer/inspect)" },
+    "skip-build": { type: "boolean", description: "Reuse dist/ instead of rebuilding" },
+    json: { type: "boolean", description: "Print inspect.json instead of the outline" },
+    timeout: { type: "number", description: "Give up after this many milliseconds (default 20000)" },
+    settle: { type: "number", description: "Wait this long after page load before capturing (default 700)" },
+    lines: { type: "number", description: "Outline lines to print per window (default 80)" }
+  },
+  examples: ["dormer inspect", "dormer inspect --skip-build --lines 200", "dormer inspect --json | jq .windows[0].nodes"]
+};
+async function run6(args) {
+  const app = loadApp();
+  if (!flagBool(args.flags, "skip-build")) await buildApp(app, { quiet: true });
+  const host = resolveHostBinary(app.root);
+  const out = path9.resolve(app.root, flagString(args.flags, "out") ?? path9.join(".dormer", "inspect"));
+  fs9.rmSync(out, { recursive: true, force: true });
+  fs9.mkdirSync(out, { recursive: true });
+  const timeout = flagNumber(args.flags, "timeout") ?? 2e4;
+  const proc = spawnHost({
+    host: host.path,
+    appDir: app.paths.rendererOut,
+    entry: app.paths.backendOut,
+    node: process.execPath,
+    name: app.config.name,
+    passEnv: ["DORMER_INSPECT_OUT", "DORMER_INSPECT_SETTLE_MS", "DORMER_INSPECT_TIMEOUT_MS"],
+    env: { DORMER_INSPECT_OUT: out, DORMER_INSPECT_SETTLE_MS: String(flagNumber(args.flags, "settle") ?? 700), DORMER_INSPECT_TIMEOUT_MS: String(timeout), DORMER_APP_VERSION: app.config.version, RUST_LOG: process.env.RUST_LOG ?? "warn" }
+  });
+  const code = await new Promise((res) => {
+    const t = setTimeout(() => {
+      proc.kill("SIGKILL");
+      res(124);
+    }, timeout + 1e4);
+    proc.on("exit", (c2) => {
+      clearTimeout(t);
+      res(c2 ?? 1);
+    });
+  });
+  const summaryPath = path9.join(out, "inspect.json");
+  if (!fs9.existsSync(summaryPath)) throw new CliError(`no inspection result (host exited with ${code})`, { exitCode: EXIT.failure, hints: ["does the app create a window on ready?", "run with RUST_LOG=info for the host log"] });
+  const summary = JSON.parse(fs9.readFileSync(summaryPath, "utf8"));
+  if (flagBool(args.flags, "json")) {
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+    return summary.ok ? EXIT.ok : EXIT.failure;
+  }
+  const lines = flagNumber(args.flags, "lines") ?? 80;
+  for (const w of summary.windows) {
+    if (w.error) {
+      log.error(`window ${w.route}: ${w.error}`);
+      continue;
+    }
+    console.log(`${c.bold(`window ${w.route}`)} ${c.dim(w.url)}  ${w.nodes} nodes${w.truncated ? " (truncated)" : ""}`);
+    console.log(`  snapshot: ${w.png ?? c.dim(`none (${w.pngError ?? "not supported here"})`)}`);
+    console.log(`  tree:     ${w.outline.replace(/\.outline\.txt$/, ".tree.json")}`);
+    const outline = fs9.readFileSync(w.outline, "utf8").split("\n").filter(Boolean);
+    console.log(outline.slice(0, lines).map((l) => `  ${l}`).join("\n"));
+    if (outline.length > lines) console.log(c.dim(`  \u2026 ${outline.length - lines} more lines in ${w.outline}`));
+  }
+  if (summary.timedOut) log.error("timed out before any window could be inspected");
+  return summary.ok ? EXIT.ok : EXIT.failure;
+}
+
+// src/cli.ts
+var COMMANDS = { create: create_exports, dev: dev_exports, build: build_exports, package: package_exports, doctor: doctor_exports, inspect: inspect_exports };
+function version() {
+  try {
+    return readJson(path10.join(CLI_DIR, "package.json")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function globalHelp() {
+  const width = Math.max(...Object.keys(COMMANDS).map((n) => n.length)) + 2;
+  return [
+    `${c.bold("dormer")} ${version()} \u2014 build desktop apps with Node.js and the system WebView`,
+    "",
+    "Usage: dormer <command> [options]",
+    "",
+    "Commands:",
+    ...Object.values(COMMANDS).map((cmd) => `  ${cmd.spec.name.padEnd(width)}${cmd.spec.summary}`),
+    "",
+    "Run `dormer <command> --help` for the options of a command.",
+    "Environment: DORMER_HOST_BIN (host binary), DORMER_BUNDLE_BIN (packaging tool), DORMER_CLI_DEBUG=1 (stack traces)."
+  ].join("\n");
+}
+async function main(argv) {
+  const [name, ...rest] = argv;
+  if (!name || name === "--help" || name === "-h" || name === "help") {
+    console.log(globalHelp());
+    return EXIT.ok;
+  }
+  if (name === "--version" || name === "-v") {
+    console.log(version());
+    return EXIT.ok;
+  }
+  const cmd = COMMANDS[name];
+  if (!cmd) throw new CliError(`unknown command "${name}"`, { exitCode: EXIT.usage, hints: [`commands: ${Object.keys(COMMANDS).join(", ")}`, "run `dormer --help`"] });
+  const args = parseArgs(rest, cmd.spec);
+  if (args.flags.help) {
+    console.log(renderHelp(cmd.spec));
+    return EXIT.ok;
+  }
+  return cmd.run(args);
+}
+main(process.argv.slice(2)).then((code) => process.exit(code), (err) => process.exit(reportError(err)));
+export {
+  main
+};