@dormer/cli 0.0.0-stage → 0.1.3

package/dist/index.js

@@ -0,0 +1,676 @@
+// src/config.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// src/ui.ts
+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 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/config.ts
+var CONFIG_FILE = "dormer.config.json";
+var BUNDLE_TARGETS = ["deb", "rpm", "appimage", "app", "dmg", "nsis", "msi"];
+function findAppRoot(start = process.cwd()) {
+  let dir = path.resolve(start);
+  for (; ; ) {
+    if (fs.existsSync(path.join(dir, CONFIG_FILE))) return dir;
+    const parent = path.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 = path.join(root, CONFIG_FILE);
+  if (!fs.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(fs.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 = path.join(root, "dist");
+  const devDir = path.join(root, ".dormer", "dev");
+  return {
+    root,
+    configPath: path.join(root, CONFIG_FILE),
+    entry: path.resolve(root, config.entry ?? "src/main.ts"),
+    rendererDir: path.resolve(root, config.renderer ?? "renderer"),
+    distDir,
+    rendererOut: path.join(distDir, "renderer"),
+    backendOut: path.join(distDir, "main.js"),
+    devDir,
+    devBackendOut: path.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/host.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+// src/resolve.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { pathToFileURL } from "node:url";
+function findPackageDir(fromDir, name) {
+  let dir = path2.resolve(fromDir);
+  for (; ; ) {
+    const candidate = path2.join(dir, "node_modules", name);
+    if (fs2.existsSync(path2.join(candidate, "package.json"))) return candidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readJson(file) {
+  return JSON.parse(fs2.readFileSync(file, "utf8"));
+}
+function packageEsmEntry(pkgDir) {
+  const pkg = readJson(path2.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 path2.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 version = readJson(path2.join(dir, "package.json")).version;
+  const vite = await import(pathToFileURL(packageEsmEntry(dir)).href);
+  return { vite, version, dir };
+}
+function findViteConfig(rendererDir) {
+  for (const n of ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"]) {
+    const f = path2.join(rendererDir, n);
+    if (fs2.existsSync(f)) return f;
+  }
+  return void 0;
+}
+function findUp(start, marker) {
+  let dir = path2.resolve(start);
+  for (; ; ) {
+    if (fs2.existsSync(path2.join(dir, marker))) return dir;
+    const parent = path2.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(path2.delimiter)) {
+    for (const ext of exts) {
+      const f = path2.join(dir, name + ext.toLowerCase());
+      try {
+        fs2.accessSync(f, fs2.constants.X_OK);
+        if (fs2.statSync(f).isFile()) return f;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/host.ts
+var CLI_DIR = path3.resolve(path3.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: path3.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 ?? path3.join(w, "target");
+    for (const profile of ["release", "debug"]) {
+      const candidate = path3.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 ? path3.join(pkg, "bin", `dormer-host${EXE}`) : path3.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 {
+    fs3.accessSync(file, fs3.constants.X_OK);
+    return fs3.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/backend.ts
+import fs4 from "node:fs";
+import path4 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 = path4.join(dir, "node_modules", name, "package.json");
+    if (fs4.existsSync(f)) {
+      try {
+        return JSON.parse(fs4.readFileSync(f, "utf8"));
+      } catch {
+        return void 0;
+      }
+    }
+    const parent = path4.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 (!fs4.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();
+  fs4.mkdirSync(path4.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 = fs4.statSync(o.outfile).size;
+  return { outfile: o.outfile, bytes, externals: [...externals].sort(), warnings: result.warnings };
+}
+async function watchBackend(o, onBuild) {
+  if (!fs4.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();
+  fs4.mkdirSync(path4.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/build.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+var spec = {
+  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(path5.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 (!fs5.existsSync(paths.rendererDir)) throw new CliError(`renderer directory not found: ${paths.rendererDir}`, { exitCode: EXIT.noInput, hints: [`set "renderer" in ${CONFIG_FILE} (default "renderer")`] });
+  if (!fs5.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")`] });
+  fs5.rmSync(paths.distDir, { recursive: true, force: true });
+  fs5.mkdirSync(paths.distDir, { recursive: true });
+  const { vite, version } = await loadVite(app.root);
+  log.step(`building renderer with vite ${version} \u2192 ${path5.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 (!fs5.existsSync(path5.join(paths.rendererOut, "index.html"))) {
+    throw new CliError(`vite build produced no ${path5.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 ${path5.relative(app.root, paths.entry)} \u2192 ${path5.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)}`);
+  fs5.copyFileSync(paths.configPath, path5.join(paths.distDir, CONFIG_FILE));
+  const manifest = makeManifest(config, backend.externals);
+  const manifestPath = path5.join(paths.distDir, "dormer-app.json");
+  fs5.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  log.ok(`built ${c.bold(`${config.name} ${config.version}`)} \u2192 ${paths.distDir}`);
+  return { manifest, backend, manifestPath };
+}
+
+// src/commands/package.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+function findIcuData(nodeBinary) {
+  const dir = path6.dirname(nodeBinary);
+  try {
+    const f = fs6.readdirSync(dir).find((n) => /^icudt\d+l\.dat$/.test(n));
+    return f ? path6.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) => path6.resolve(o.root, p));
+  if (icons.length === 0 && fs6.existsSync(path6.join(o.root, "icons"))) {
+    icons = fs6.readdirSync(path6.join(o.root, "icons")).filter((f) => /\.(png|icns|ico|svg)$/i.test(f)).map((f) => path6.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 ? path6.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 = path6.join(process.env.CARGO_TARGET_DIR ?? path6.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 ? path6.join(pkg, "bin", exe) : path6.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}`;
+}
+
+// src/commands/doctor.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+import { spawnSync } from "node:child_process";
+function sh(cmd, args) {
+  const r = spawnSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return { ok: !r.error && r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
+}
+function nodeCheck(version = process.versions.node) {
+  const [major, minor] = version.split(".").map(Number);
+  if (major < 22) return { name: "Node.js", status: "fail", detail: `v${version} (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${version} (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${version}` };
+}
+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 && fs7.existsSync(path7.join(process.env.XDG_RUNTIME_DIR, "bus")) ? `unix:path=${path7.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 = fs7.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(path7.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(path7.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: fs7.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 ${path7.relative(root, paths.entry)} \xB7 renderer ${path7.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;
+}
+export {
+  BUNDLE_TARGETS,
+  CliError,
+  EXIT,
+  buildApp,
+  bundleBackend,
+  capabilitySummary,
+  defaultTargets,
+  findAppRoot,
+  hostArgs,
+  hostPackageName,
+  loadApp,
+  loadConfig,
+  makeBundleSpec,
+  makeManifest,
+  resolveBundlerBinary,
+  resolveHostBinary,
+  resolvePaths,
+  runChecks,
+  spawnHost,
+  validateConfig,
+  watchBackend
+};