@dormer/cli 0.0.0-stage → 0.1.3

package/src/host.ts

@@ -0,0 +1,85 @@
+// Locating and launching the native host binary (`dormer-host`).
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn, type ChildProcess } from "node:child_process";
+import { CliError, EXIT, c } from "./ui.ts";
+import { findPackageDir, findUp } from "./resolve.ts";
+
+export const CLI_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const EXE = process.platform === "win32" ? ".exe" : "";
+
+export interface HostLocation { path: string; source: "env" | "cargo-target" | "package"; tried: string[] }
+
+/** The npm package that carries the prebuilt host binary for this platform (optional dependency of @dormer/cli). */
+export function hostPackageName(): string { return `@dormer/host-${process.platform}-${process.arch}`; }
+
+/**
+ * Resolution order (documented in README.md):
+ *   1. $DORMER_HOST_BIN
+ *   2. <cargo workspace>/target/{release,debug}/dormer-host, searching upward from the app root
+ *      and from the CLI's own location (covers the monorepo and apps developed inside it)
+ *   3. node_modules/@dormer/host-<platform>-<arch>/bin/dormer-host (prebuilt package, an optional dependency of @dormer/cli)
+ */
+export function resolveHostBinary(appRoot: string): HostLocation {
+  const tried: string[] = [];
+  const env = process.env.DORMER_HOST_BIN;
+  if (env) {
+    if (isExecutable(env)) return { path: path.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 = new Set<string>();
+  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 ?? path.join(w, "target");
+    for (const profile of ["release", "debug"]) {
+      const candidate = path.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 ? path.join(pkg, "bin", `dormer-host${EXE}`) : path.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:\n${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)`,
+    ],
+  });
+}
+
+export function isExecutable(file: string): boolean {
+  try { fs.accessSync(file, fs.constants.X_OK); return fs.statSync(file).isFile(); } catch { return false; }
+}
+
+export interface HostLaunch {
+  host: string;
+  appDir: string;
+  entry: string;
+  node: string;
+  name: string;
+  dev?: boolean;
+  devUrl?: string;
+  /** Environment variables to forward through the host's scrubbing into the Node sidecar. */
+  passEnv?: string[];
+  env?: Record<string, string | undefined>;
+}
+
+export function hostArgs(l: HostLaunch): string[] {
+  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;
+}
+
+export function spawnHost(l: HostLaunch): ChildProcess {
+  const env = { ...process.env, ...l.env };
+  env.RUST_LOG ??= "info";
+  return spawn(l.host, hostArgs(l), { stdio: "inherit", env });
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+// Programmatic surface of @dormer/cli (the `dormer` binary is bin/dormer.mjs → src/cli.ts).
+export { loadApp, loadConfig, findAppRoot, resolvePaths, validateConfig, BUNDLE_TARGETS, type DormerConfig, type AppPaths, type BundleTarget } from "./config.ts";
+export { resolveHostBinary, hostArgs, spawnHost, hostPackageName, type HostLocation, type HostLaunch } from "./host.ts";
+export { bundleBackend, watchBackend, type BundleOptions, type BundleResult } from "./backend.ts";
+export { buildApp, makeManifest, type AppManifest } from "./commands/build.ts";
+export { makeBundleSpec, defaultTargets, resolveBundlerBinary, type BundleSpec } from "./commands/package.ts";
+export { runChecks, capabilitySummary, type Check } from "./commands/doctor.ts";
+export { CliError, EXIT } from "./ui.ts";

package/src/resolve.ts

@@ -0,0 +1,75 @@
+// Resolution helpers: find packages from the user's project (not from the CLI's own tree).
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { CliError, c } from "./ui.ts";
+
+/** Finds `node_modules/<name>` walking up from `fromDir`. Returns the package directory. */
+export function findPackageDir(fromDir: string, name: string): string | undefined {
+  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 undefined;
+    dir = parent;
+  }
+}
+
+export function readJson<T = Record<string, unknown>>(file: string): T { return JSON.parse(fs.readFileSync(file, "utf8")) as T; }
+
+/** Picks the ESM entry of a package from its exports map (or module/main fallbacks). */
+export function packageEsmEntry(pkgDir: string): string {
+  const pkg = readJson<{ exports?: unknown; module?: string; main?: string }>(path.join(pkgDir, "package.json"));
+  const pick = (v: unknown): string | undefined => {
+    if (typeof v === "string") return v;
+    if (!v || typeof v !== "object") return undefined;
+    const o = v as Record<string, unknown>;
+    for (const k of ["import", "node", "default"]) if (o[k] !== undefined) { const r = pick(o[k]); if (r) return r; }
+    return undefined;
+  };
+  const fromExports = pkg.exports && typeof pkg.exports === "object" && !Array.isArray(pkg.exports) ? pick((pkg.exports as Record<string, unknown>)["."] ?? pkg.exports) : pick(pkg.exports);
+  const rel = fromExports ?? pkg.module ?? pkg.main ?? "index.js";
+  return path.join(pkgDir, rel);
+}
+
+/** Vite's programmatic API, loaded from the user's project so their plugins share the instance. */
+export type ViteModule = typeof import("vite");
+export async function loadVite(root: string): Promise<{ vite: ViteModule; version: string; dir: string }> {
+  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<{ version: string }>(path.join(dir, "package.json")).version;
+  const vite = (await import(pathToFileURL(packageEsmEntry(dir)).href)) as ViteModule;
+  return { vite, version, dir };
+}
+
+export function findViteConfig(rendererDir: string): string | undefined {
+  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 undefined;
+}
+
+/** Finds a directory containing `marker` walking up from `start`. */
+export function findUp(start: string, marker: string): string | undefined {
+  let dir = path.resolve(start);
+  for (;;) {
+    if (fs.existsSync(path.join(dir, marker))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+/** First executable named `name` on PATH, or undefined. */
+export function which(name: string): string | undefined {
+  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 { /* keep looking */ }
+    }
+  }
+  return undefined;
+}

package/src/ui.ts

@@ -0,0 +1,57 @@
+// Terminal output helpers, error type and exit codes shared by every command.
+import { inspect } from "node:util";
+
+/** Exit codes (sysexits-inspired, documented in README.md). */
+export const 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
+} as const;
+
+export class CliError extends Error {
+  exitCode: number;
+  hints: string[];
+  constructor(message: string, options: { exitCode?: number; hints?: string[] } = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = options.exitCode ?? EXIT.failure;
+    this.hints = options.hints ?? [];
+  }
+}
+
+const useColor = !process.env.NO_COLOR && process.env.TERM !== "dumb" && (process.stdout.isTTY || process.env.FORCE_COLOR);
+const paint = (code: number) => (s: string) => (useColor ? `\u001b[${code}m${s}\u001b[0m` : s);
+export const c = { dim: paint(2), bold: paint(1), red: paint(31), green: paint(32), yellow: paint(33), blue: paint(34), cyan: paint(36) };
+
+const prefix = c.dim("[dormer]");
+export const log = {
+  info: (msg: string): void => { console.log(`${prefix} ${msg}`); },
+  step: (msg: string): void => { console.log(`${prefix} ${c.cyan("›")} ${msg}`); },
+  ok: (msg: string): void => { console.log(`${prefix} ${c.green("✓")} ${msg}`); },
+  warn: (msg: string): void => { console.error(`${prefix} ${c.yellow("warning:")} ${msg}`); },
+  error: (msg: string): void => { console.error(`${prefix} ${c.red("error:")} ${msg}`); },
+  hint: (msg: string): void => { console.error(`${prefix}   ${c.dim("hint:")} ${msg}`); },
+};
+
+/** Prints an error (with hints) and returns the exit code to use. */
+export function reportError(err: unknown): number {
+  if (err instanceof CliError) {
+    log.error(err.message);
+    for (const h of err.hints) log.hint(h);
+    return err.exitCode;
+  }
+  const e = err as { message?: string; stack?: string };
+  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;
+}
+
+export function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} kB`;
+  return `${(n / 1024 / 1024).toFixed(2)} MB`;
+}

package/templates/react/README.md

@@ -0,0 +1,34 @@
+# {{name}}
+
+A [Dormer](https://github.com/dormer) desktop app: a Node.js backend (`src/main.ts`) and a
+React renderer (`renderer/`) shown in the operating system's WebView.
+
+```sh
+npm install
+npm run dev        # Vite dev server + native window; the backend is rebuilt on change
+npm run build      # dist/renderer, dist/main.js, dist/dormer-app.json
+npm run package    # installers (needs the dormer-bundle tool)
+npx dormer doctor  # checks Node, the host binary and platform prerequisites
+```
+
+## Layout
+
+```
+dormer.config.json   name, identifier, version, per-window capabilities, Node version pin
+src/main.ts          backend: one window, ipcMain.handle("ping"), window-all-closed → quit
+renderer/            Vite project: index.html, vite.config.ts (@vitejs/plugin-react + @dormer/vite-plugin), src/App.tsx
+```
+
+## How the pieces talk
+
+* `invoke("ping")` in the renderer resolves with whatever `ipcMain.handle("ping", ...)` returns.
+* `on("backend:tick", fn)` receives events the backend pushes with `win.webContents.send(...)`.
+* `send("selftest:done", ...)` is a one-way message handled by `ipcMain.on(...)`.
+
+The renderer never has Node access; every call goes through the native host's capability gate.
+
+## Self-test
+
+With `DORMER_SELFTEST=1` the backend quits after the renderer reports the ping result and logs
+`{"kind":"template-selftest","ok":true}`. The Dormer repository's `packages/cli/test/e2e-linux.sh`
+uses this to verify the template headless.

package/templates/react/_gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+.dormer/
+*.log
+.DS_Store

package/templates/react/dormer.config.json

@@ -0,0 +1,16 @@
+{
+  "name": "{{name}}",
+  "identifier": "{{identifier}}",
+  "version": "0.1.0",
+  "description": "A Dormer desktop app (react template)",
+  "entry": "src/main.ts",
+  "renderer": "renderer",
+  "firstWindow": { "label": "main", "width": 960, "height": 640, "title": "{{name}}", "backgroundColor": "auto" },
+  "windows": {
+    "main": { "capabilities": ["app:default"] }
+  },
+  "capabilities": {
+    "app:default": { "description": "Everything the backend exposes, for the app's own windows only", "allow": ["ipc:*", "send:*"], "origins": ["local"] }
+  },
+  "node": { "version": "24" }
+}

package/templates/react/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "{{name}}",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "dormer dev",
+    "build": "dormer build",
+    "package": "dormer package",
+    "doctor": "dormer doctor",
+    "typecheck": "tsc -p . && tsc -p renderer"
+  },
+  "dependencies": {
+    "@dormer/api": "0.1.3",
+    "@dormer/renderer": "0.1.3",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
+  },
+  "devDependencies": {
+    "@dormer/cli": "0.1.3",
+    "@dormer/vite-plugin": "0.1.3",
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.2.0",
+    "typescript": "^5.9.0",
+    "vite": "^8.3.0"
+  }
+}

package/templates/react/renderer/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{name}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/templates/react/renderer/src/App.tsx

@@ -0,0 +1,34 @@
+import { useEffect, useState } from "react";
+import { invoke, on, send, isDormer } from "@dormer/renderer";
+import type { PingReply } from "../../src/shared.ts";
+
+export function App() {
+  const [reply, setReply] = useState<PingReply | null>(null);
+  const [uptime, setUptime] = useState<number | null>(null);
+  const inside = isDormer();
+
+  async function ping() {
+    // Request/response: page → host (capability check) → Node `ipcMain.handle("ping")` → back.
+    const r = await invoke<PingReply>("ping");
+    setReply(r);
+    if (r.selftest) send("selftest:done", r); // one-way message, used by the automated test
+  }
+
+  useEffect(() => {
+    if (!inside) return;
+    // Events pushed by the backend with `win.webContents.send("backend:tick", ...)`; `on` returns an unsubscribe.
+    const off = on("backend:tick", (t: { uptime: number }) => setUptime(t.uptime));
+    void ping();
+    return off;
+  }, [inside]);
+
+  return (
+    <main>
+      <h1>{"{{name}}"}</h1>
+      <p className="muted">React · Node.js backend · system WebView{import.meta.env.DORMER ? " · built with @dormer/vite-plugin" : ""}</p>
+      <button onClick={() => void ping()} disabled={!inside}>Ping the backend</button>
+      <pre>{inside ? (reply ? JSON.stringify(reply, null, 2) : "…") : "Not running inside Dormer. Start the app with `npm run dev`."}</pre>
+      <p className="muted">{uptime !== null ? `backend uptime: ${uptime} s` : ""}</p>
+    </main>
+  );
+}

package/templates/react/renderer/src/main.tsx

@@ -0,0 +1,6 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { App } from "./App.tsx";
+import "./style.css";
+
+createRoot(document.getElementById("root")!).render(<React.StrictMode><App /></React.StrictMode>);

package/templates/react/renderer/src/style.css

@@ -0,0 +1,8 @@
+:root { color-scheme: light dark; font-family: system-ui, sans-serif; line-height: 1.5; }
+body { margin: 0; }
+main { max-width: 720px; margin: 0 auto; padding: 32px 24px; }
+h1 { margin: 0 0 4px; font-size: 1.6rem; }
+.muted { opacity: 0.7; margin: 0 0 16px; }
+button { font: inherit; padding: 8px 14px; border-radius: 8px; border: 1px solid color-mix(in srgb, currentColor 30%, transparent); background: color-mix(in srgb, currentColor 8%, transparent); cursor: pointer; }
+button:hover { background: color-mix(in srgb, currentColor 16%, transparent); }
+pre { background: color-mix(in srgb, currentColor 8%, transparent); padding: 12px; border-radius: 8px; overflow: auto; min-height: 7em; font-size: 0.85rem; }

package/templates/react/renderer/src/vite-env.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="vite/client" />
+/// <reference types="@dormer/vite-plugin/client" />

package/templates/react/renderer/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/templates/react/renderer/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { dormer } from "@dormer/vite-plugin";
+
+export default defineConfig({
+  plugins: [react(), dormer()],
+});

package/templates/react/src/main.ts

@@ -0,0 +1,34 @@
+// {{name}} — backend. Runs in the Node.js sidecar; the native host owns windows and WebViews.
+import { app, BrowserWindow, ipcMain } from "@dormer/api";
+import type { PingReply } from "./shared.ts";
+
+const selftest = process.env.DORMER_SELFTEST === "1";
+const log = (kind: string, payload: Record<string, unknown>) => console.log(JSON.stringify({ kind, ...payload }));
+
+// Renderer → backend request/response: `await invoke("ping")` in the page resolves with this.
+ipcMain.handle("ping", (): PingReply => ({ reply: "pong", node: process.version, platform: process.platform, pid: process.pid, at: Date.now(), selftest }));
+
+// Fire-and-forget message from the renderer (`send("selftest:done", reply)`); used by the
+// automated template test (packages/cli/test/e2e-linux.sh) when DORMER_SELFTEST=1.
+ipcMain.on("selftest:done", (_event, result: PingReply) => {
+  if (!selftest) return;
+  const ok = result?.reply === "pong";
+  log("template-selftest", { ok, node: result?.node });
+  if (ok) app.quit(); else app.exit(1);
+});
+
+async function createWindow(): Promise<void> {
+  const win = new BrowserWindow({ width: 960, height: 640, title: "{{name}}", show: false, capabilities: ["app:default"] });
+  win.once("ready-to-show", () => win.show());
+  // `dormer dev` serves the renderer from Vite and passes its URL; production loads dormer://app/.
+  const devUrl = process.env.DORMER_DEV_URL;
+  if (devUrl) await win.loadURL(devUrl);
+  else await win.loadApp("index.html");
+  // Backend → renderer events: received in the page with `on("backend:tick", ...)`.
+  const tick = setInterval(() => win.webContents.send("backend:tick", { uptime: Math.round(process.uptime()) }), 1000);
+  win.on("closed", () => clearInterval(tick));
+}
+
+app.on("window-all-closed", () => { if (process.platform !== "darwin") app.quit(); });
+app.on("activate", () => { if (BrowserWindow.getAllWindows().length === 0) void createWindow(); });
+app.whenReady().then(createWindow);

package/templates/react/src/shared.ts

@@ -0,0 +1,10 @@
+// Types shared by the backend and the renderer (no Node.js imports here: the renderer's tsconfig
+// type-checks this file too, which is what gives the page autocompletion for backend replies).
+export interface PingReply {
+  reply: "pong";
+  node: string;
+  platform: string;
+  pid: number;
+  at: number;
+  selftest: boolean;
+}

package/templates/react/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "erasableSyntaxOnly": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}

package/templates/svelte/README.md

@@ -0,0 +1,34 @@
+# {{name}}
+
+A [Dormer](https://github.com/dormer) desktop app: a Node.js backend (`src/main.ts`) and a
+Svelte renderer (`renderer/`) shown in the operating system's WebView.
+
+```sh
+npm install
+npm run dev        # Vite dev server + native window; the backend is rebuilt on change
+npm run build      # dist/renderer, dist/main.js, dist/dormer-app.json
+npm run package    # installers (needs the dormer-bundle tool)
+npx dormer doctor  # checks Node, the host binary and platform prerequisites
+```
+
+## Layout
+
+```
+dormer.config.json   name, identifier, version, per-window capabilities, Node version pin
+src/main.ts          backend: one window, ipcMain.handle("ping"), window-all-closed → quit
+renderer/            Vite project: index.html, vite.config.ts (@sveltejs/vite-plugin-svelte + @dormer/vite-plugin), src/App.svelte
+```
+
+## How the pieces talk
+
+* `invoke("ping")` in the renderer resolves with whatever `ipcMain.handle("ping", ...)` returns.
+* `on("backend:tick", fn)` receives events the backend pushes with `win.webContents.send(...)`.
+* `send("selftest:done", ...)` is a one-way message handled by `ipcMain.on(...)`.
+
+The renderer never has Node access; every call goes through the native host's capability gate.
+
+## Self-test
+
+With `DORMER_SELFTEST=1` the backend quits after the renderer reports the ping result and logs
+`{"kind":"template-selftest","ok":true}`. The Dormer repository's `packages/cli/test/e2e-linux.sh`
+uses this to verify the template headless.

package/templates/svelte/_gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+.dormer/
+*.log
+.DS_Store

package/templates/svelte/dormer.config.json

@@ -0,0 +1,16 @@
+{
+  "name": "{{name}}",
+  "identifier": "{{identifier}}",
+  "version": "0.1.0",
+  "description": "A Dormer desktop app (svelte template)",
+  "entry": "src/main.ts",
+  "renderer": "renderer",
+  "firstWindow": { "label": "main", "width": 960, "height": 640, "title": "{{name}}", "backgroundColor": "auto" },
+  "windows": {
+    "main": { "capabilities": ["app:default"] }
+  },
+  "capabilities": {
+    "app:default": { "description": "Everything the backend exposes, for the app's own windows only", "allow": ["ipc:*", "send:*"], "origins": ["local"] }
+  },
+  "node": { "version": "24" }
+}

package/templates/svelte/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "{{name}}",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "dormer dev",
+    "build": "dormer build",
+    "package": "dormer package",
+    "doctor": "dormer doctor",
+    "typecheck": "tsc -p . && svelte-check --tsconfig renderer/tsconfig.json"
+  },
+  "dependencies": {
+    "@dormer/api": "0.1.3",
+    "@dormer/renderer": "0.1.3"
+  },
+  "devDependencies": {
+    "@dormer/cli": "0.1.3",
+    "@dormer/vite-plugin": "0.1.3",
+    "@sveltejs/vite-plugin-svelte": "^7.3.0",
+    "@types/node": "^24.0.0",
+    "svelte": "^5.57.0",
+    "svelte-check": "^4.0.0",
+    "typescript": "^5.9.0",
+    "vite": "^8.3.0"
+  }
+}

package/templates/svelte/renderer/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{name}}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/templates/svelte/renderer/src/App.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+  import { onMount } from "svelte";
+  import { invoke, on, send, isDormer } from "@dormer/renderer";
+  import type { PingReply } from "../../src/shared.ts";
+
+  const inside = isDormer();
+  let reply = $state<PingReply | null>(null);
+  let uptime = $state<number | null>(null);
+
+  async function ping() {
+    // Request/response: page → host (capability check) → Node `ipcMain.handle("ping")` → back.
+    const r = await invoke<PingReply>("ping");
+    reply = r;
+    if (r.selftest) send("selftest:done", r); // one-way message, used by the automated test
+  }
+
+  onMount(() => {
+    if (!inside) return;
+    // Events pushed by the backend with `win.webContents.send("backend:tick", ...)`; `on` returns an unsubscribe.
+    const off = on("backend:tick", (t: { uptime: number }) => { uptime = t.uptime; });
+    void ping();
+    return off;
+  });
+</script>
+
+<main>
+  <h1>{{name}}</h1>
+  <p class="muted">Svelte · Node.js backend · system WebView{import.meta.env.DORMER ? " · built with @dormer/vite-plugin" : ""}</p>
+  <button disabled={!inside} onclick={() => void ping()}>Ping the backend</button>
+  <pre>{inside ? (reply ? JSON.stringify(reply, null, 2) : "…") : "Not running inside Dormer. Start the app with `npm run dev`."}</pre>
+  <p class="muted">{uptime !== null ? `backend uptime: ${uptime} s` : ""}</p>
+</main>

package/templates/svelte/renderer/src/main.ts

@@ -0,0 +1,5 @@
+import { mount } from "svelte";
+import App from "./App.svelte";
+import "./style.css";
+
+mount(App, { target: document.getElementById("app")! });

package/templates/svelte/renderer/src/style.css

@@ -0,0 +1,8 @@
+:root { color-scheme: light dark; font-family: system-ui, sans-serif; line-height: 1.5; }
+body { margin: 0; }
+main { max-width: 720px; margin: 0 auto; padding: 32px 24px; }
+h1 { margin: 0 0 4px; font-size: 1.6rem; }
+.muted { opacity: 0.7; margin: 0 0 16px; }
+button { font: inherit; padding: 8px 14px; border-radius: 8px; border: 1px solid color-mix(in srgb, currentColor 30%, transparent); background: color-mix(in srgb, currentColor 8%, transparent); cursor: pointer; }
+button:hover { background: color-mix(in srgb, currentColor 16%, transparent); }
+pre { background: color-mix(in srgb, currentColor 8%, transparent); padding: 12px; border-radius: 8px; overflow: auto; min-height: 7em; font-size: 0.85rem; }

package/templates/svelte/renderer/src/vite-env.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="vite/client" />
+/// <reference types="@dormer/vite-plugin/client" />

package/templates/svelte/renderer/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}