@sublime-ui/devkit 0.1.0 → 0.1.1

package/dist/chunk-PPA6U663.js

@@ -0,0 +1,810 @@
+#!/usr/bin/env node
+
+// src/util/log.ts
+import pc from "picocolors";
+var log = {
+  info: (m) => console.log(m),
+  step: (m) => console.log(pc.cyan(`\u2192 ${m}`)),
+  success: (m) => console.log(pc.green(`\u2713 ${m}`)),
+  warn: (m) => console.log(pc.yellow(`! ${m}`)),
+  error: (m) => console.error(pc.red(`\u2717 ${m}`)),
+  table: (rows) => {
+    const width = rows.reduce((m, r) => Math.max(m, r.label.length), 0);
+    for (const r of rows) {
+      const mark = r.ok ? pc.green("\u2713") : pc.red("\u2717");
+      console.log(`${mark} ${r.label.padEnd(width)}  ${pc.dim(r.detail)}`);
+    }
+  }
+};
+
+// src/lib/scaffold/init.ts
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join, basename } from "path";
+
+// src/lib/scaffold/versions.ts
+var SUBLIME_VERSIONS = {
+  framework: "^0.1.0",
+  library: "^0.1.0",
+  ui: "^0.1.0",
+  desktop: "^0.1.0"
+};
+var PEER_VERSIONS = {
+  react: "^18.3.1",
+  "react-dom": "^18.3.1",
+  "@mui/material": "^6.1.6",
+  "@emotion/react": "^11.13.3",
+  "@emotion/styled": "^11.13.0",
+  "react-router-dom": "^6.27.0",
+  "react-native": "^0.76.1",
+  "react-native-paper": "^5.12.5",
+  "react-native-safe-area-context": "^4.14.0",
+  "@react-navigation/native": "^6.1.18",
+  "@react-navigation/native-stack": "^6.11.0",
+  "@react-navigation/bottom-tabs": "^6.6.1",
+  electron: "^33.0.0",
+  vite: "^5.4.0",
+  "@vitejs/plugin-react": "^4.3.0",
+  typescript: "^5.6.0"
+};
+
+// src/lib/scaffold/templates/app.ts
+var has = (targets, t) => targets.includes(t);
+function renderAppPackageJson(name, targets) {
+  const deps = {
+    "@sublime-ui/framework": SUBLIME_VERSIONS.framework,
+    "@sublime-ui/library": SUBLIME_VERSIONS.library,
+    "@sublime-ui/ui": SUBLIME_VERSIONS.ui,
+    react: PEER_VERSIONS["react"]
+  };
+  const devDeps = {
+    "@sublime-ui/devkit": SUBLIME_VERSIONS.framework,
+    // shares the lockstep version
+    typescript: PEER_VERSIONS["typescript"],
+    "@types/react": "^18.3.12",
+    "@types/node": "^22.0.0"
+  };
+  const scripts = { "build:nav": "sublime build:nav" };
+  if (has(targets, "web") || has(targets, "desktop")) {
+    deps["react-dom"] = PEER_VERSIONS["react-dom"];
+    deps["react-router-dom"] = PEER_VERSIONS["react-router-dom"];
+    deps["@mui/material"] = PEER_VERSIONS["@mui/material"];
+    deps["@emotion/react"] = PEER_VERSIONS["@emotion/react"];
+    deps["@emotion/styled"] = PEER_VERSIONS["@emotion/styled"];
+    devDeps["@types/react-dom"] = "^18.3.1";
+    devDeps["vite"] = PEER_VERSIONS["vite"];
+    devDeps["@vitejs/plugin-react"] = PEER_VERSIONS["@vitejs/plugin-react"];
+    scripts["dev:web"] = "vite";
+    scripts["build:web"] = "vite build";
+  }
+  if (has(targets, "mobile")) {
+    deps["react-native"] = PEER_VERSIONS["react-native"];
+    deps["react-native-paper"] = PEER_VERSIONS["react-native-paper"];
+    deps["react-native-safe-area-context"] = PEER_VERSIONS["react-native-safe-area-context"];
+    deps["@react-navigation/native"] = PEER_VERSIONS["@react-navigation/native"];
+    deps["@react-navigation/native-stack"] = PEER_VERSIONS["@react-navigation/native-stack"];
+    deps["@react-navigation/bottom-tabs"] = PEER_VERSIONS["@react-navigation/bottom-tabs"];
+    scripts["dev:mobile"] = "sublime build --debug";
+    scripts["build:mobile"] = "sublime build";
+  }
+  if (has(targets, "desktop")) {
+    deps["@sublime-ui/desktop"] = SUBLIME_VERSIONS.desktop;
+    devDeps["electron"] = PEER_VERSIONS["electron"];
+    scripts["desktop:dev"] = "sublime desktop:dev";
+    scripts["desktop:build"] = "sublime desktop:build";
+  }
+  const pkg = {
+    name,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts,
+    dependencies: deps,
+    devDependencies: devDeps
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function renderSublimeConfig(targets) {
+  const cfg = {
+    modelsDir: "src/models",
+    componentsDir: "src/components",
+    themeDir: "src/theme",
+    navigationDir: "src/navigation",
+    importAlias: "@sublime-ui"
+  };
+  if (has(targets, "desktop")) cfg["desktop"] = { dir: "desktop" };
+  return JSON.stringify(cfg, null, 2) + "\n";
+}
+function renderTsconfig(targets = ["web", "mobile", "desktop"]) {
+  const wantsWeb = has(targets, "web") || has(targets, "desktop");
+  const types = ["react", "node"];
+  if (wantsWeb) types.splice(1, 0, "react-dom");
+  const include = ["src"];
+  if (wantsWeb) include.push("web");
+  if (has(targets, "mobile")) include.push("mobile");
+  if (has(targets, "desktop")) include.push("desktop/src");
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        jsx: "react-jsx",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        noUncheckedIndexedAccess: true,
+        resolveJsonModule: true,
+        types
+      },
+      include
+    },
+    null,
+    2
+  ) + "\n";
+}
+function renderGitignore() {
+  return [
+    "node_modules",
+    "dist",
+    "build",
+    ".DS_Store",
+    "",
+    "# Generated by `sublime build:nav`",
+    "src/navigation/navigation.tsx",
+    "src/navigation/navigation.native.tsx",
+    "src/navigation/routes.d.ts",
+    "src/navigation/index.ts",
+    "",
+    "# Native build output",
+    "android",
+    "ios",
+    ""
+  ].join("\n");
+}
+function renderAppReadme(name, targets) {
+  const lines = [
+    `# ${name}`,
+    "",
+    "A [Sublime UI](https://sublime-ui.github.io/sublime-ui/) app \u2014 write the",
+    "non-UI parts once, run on mobile, web, and desktop.",
+    "",
+    "## Getting started",
+    "",
+    "```bash",
+    "npm install",
+    "npm run build:nav   # compile navigation"
+  ];
+  if (has(targets, "web")) lines.push("npm run dev:web     # web (Vite)");
+  if (has(targets, "mobile")) lines.push("npm run dev:mobile  # Android (debug)");
+  if (has(targets, "desktop")) lines.push("npm run desktop:dev # Electron");
+  lines.push("```", "");
+  return lines.join("\n");
+}
+
+// src/lib/scaffold/templates/shared.ts
+function renderTaskModel() {
+  return `import { Model, registerModel } from '@sublime-ui/framework';
+
+/** A sample model. Replace with your own \u2014 see the docs on the Model layer. */
+export class Task extends Model {
+  protected static resource = '/tasks';
+  declare id: number;
+  declare name: string;
+  declare done: boolean;
+}
+registerModel(Task);
+`;
+}
+function renderModelsBarrel() {
+  return `export * from './Task.js';
+`;
+}
+function renderThemeTokensJson() {
+  return JSON.stringify(
+    {
+      colors: { primary: "#4F46E5", background: "#FFFFFF", text: "#111827" },
+      spacing: { sm: 8, md: 16, lg: 24 },
+      radius: { md: 12 }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function renderThemeTokensTs() {
+  return `import tokensJson from './tokens.json' with { type: 'json' };
+import type { SublimeTokens } from '@sublime-ui/library';
+
+/** Typed app design tokens. Edit tokens.json; this stays a thin typed wrapper. */
+export const tokens = tokensJson as unknown as SublimeTokens;
+`;
+}
+
+// src/lib/scaffold/templates/web.ts
+function renderWebTaskList() {
+  return `import { Screen, Stack } from '@sublime-ui/ui';
+import { useNav } from '@sublime-ui/ui/navigation';
+import { Task } from '../../models/Task';
+
+export function TaskList() {
+  const tasks = Task.rxAll();
+  const nav = useNav();
+  return (
+    <Screen>
+      <Stack>
+        {tasks.map((t) => (
+          <button key={t.id} onClick={() => nav.turnTo('task', { id: t.id })}>
+            {t.name}
+          </button>
+        ))}
+      </Stack>
+    </Screen>
+  );
+}
+`;
+}
+function renderWebTaskDetail() {
+  return `import { Screen, Stack } from '@sublime-ui/ui';
+import { useNav } from '@sublime-ui/ui/navigation';
+import type { AppRoutes } from '../../navigation';
+import { Task } from '../../models/Task';
+
+export function TaskDetail() {
+  const nav = useNav<AppRoutes>();
+  const { id } = nav.params<'task'>();
+  const task = Task.rxFind(id);
+  return (
+    <Screen>
+      <Stack>
+        <h1>{task?.name ?? 'Loading\u2026'}</h1>
+        <button onClick={() => nav.turnBack()}>Back</button>
+      </Stack>
+    </Screen>
+  );
+}
+`;
+}
+function renderStorybookWeb() {
+  return `import { book, page } from '@sublime-ui/ui/navigation';
+import { TaskList } from '../screens/web/TaskList';
+import { TaskDetail } from '../screens/web/TaskDetail';
+
+export default book({
+  format: 'sidebar', // web: 'sidebar' | 'stack' | 'tabs'
+  pages: {
+    tasks: page(TaskList, { title: 'Tasks', initial: true }),
+    task: page<{ id: number }>(TaskDetail, { title: 'Task' }),
+  },
+});
+`;
+}
+function renderWebScreensBarrel() {
+  return `export { TaskList } from '../screens/web/TaskList';
+export { TaskDetail } from '../screens/web/TaskDetail';
+`;
+}
+function renderWebIndexHtml(name) {
+  return `<!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="/web/main.tsx"></script>
+  </body>
+</html>
+`;
+}
+function renderWebMain() {
+  return `import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { SublimeProvider } from '@sublime-ui/library';
+import { Navigation } from '../src/navigation';
+import { tokens } from '../src/theme/tokens';
+
+function App() {
+  return (
+    <SublimeProvider tokens={tokens}>
+      <Navigation />
+    </SublimeProvider>
+  );
+}
+
+createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`;
+}
+function renderViteConfig() {
+  return `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});
+`;
+}
+
+// src/lib/scaffold/templates/mobile.ts
+function renderMobileTaskList() {
+  return `import { Screen, Stack } from '@sublime-ui/ui';
+import { useNav } from '@sublime-ui/ui/navigation';
+import { Button } from 'react-native-paper';
+import { Task } from '../../models/Task';
+
+export function TaskList() {
+  const tasks = Task.rxAll();
+  const nav = useNav();
+  return (
+    <Screen>
+      <Stack>
+        {tasks.map((t) => (
+          <Button key={t.id} onPress={() => nav.turnTo('task', { id: t.id })}>
+            {t.name}
+          </Button>
+        ))}
+      </Stack>
+    </Screen>
+  );
+}
+`;
+}
+function renderMobileTaskDetail() {
+  return `import { Screen, Stack } from '@sublime-ui/ui';
+import { useNav } from '@sublime-ui/ui/navigation';
+import { Text, Button } from 'react-native-paper';
+import type { AppRoutes } from '../../navigation';
+import { Task } from '../../models/Task';
+
+export function TaskDetail() {
+  const nav = useNav<AppRoutes>();
+  const { id } = nav.params<'task'>();
+  const task = Task.rxFind(id);
+  return (
+    <Screen>
+      <Stack>
+        <Text variant="headlineMedium">{task?.name ?? 'Loading\u2026'}</Text>
+        <Button onPress={() => nav.turnBack()}>Back</Button>
+      </Stack>
+    </Screen>
+  );
+}
+`;
+}
+function renderStorybookNative() {
+  return `import { book, page } from '@sublime-ui/ui/navigation';
+import { TaskList } from '../screens/mobile/TaskList.native';
+import { TaskDetail } from '../screens/mobile/TaskDetail.native';
+
+export default book({
+  format: 'bottomNav', // mobile: 'drawer' | 'stack' | 'bottomNav' (<= 5 pages)
+  pages: {
+    tasks: page(TaskList, { title: 'Tasks', icon: 'format-list-bulleted', initial: true }),
+    task: page<{ id: number }>(TaskDetail, { title: 'Task', icon: 'note' }),
+  },
+});
+`;
+}
+function renderMobileScreensBarrel() {
+  return `export { TaskList } from '../screens/mobile/TaskList.native';
+export { TaskDetail } from '../screens/mobile/TaskDetail.native';
+`;
+}
+function renderMobileEntry() {
+  return `import { AppRegistry } from 'react-native';
+import { App } from './App.native';
+import { name as appName } from '../app.json';
+
+AppRegistry.registerComponent(appName, () => App);
+`;
+}
+function renderMobileApp() {
+  return `import { SublimeProvider } from '@sublime-ui/library';
+import { Navigation } from '../src/navigation';
+import { tokens } from '../src/theme/tokens';
+
+export function App() {
+  return (
+    <SublimeProvider tokens={tokens}>
+      <Navigation />
+    </SublimeProvider>
+  );
+}
+`;
+}
+
+// src/lib/desktop/templates.ts
+function renderForgeConfig() {
+  return `import type { ForgeConfig } from '@electron-forge/shared-types';
+import { MakerSquirrel } from '@electron-forge/maker-squirrel';
+import { MakerZIP } from '@electron-forge/maker-zip';
+import { MakerDeb } from '@electron-forge/maker-deb';
+import { MakerRpm } from '@electron-forge/maker-rpm';
+import { AutoUnpackNativesPlugin } from '@electron-forge/plugin-auto-unpack-natives';
+import { WebpackPlugin } from '@electron-forge/plugin-webpack';
+import { FusesPlugin } from '@electron-forge/plugin-fuses';
+import { FuseV1Options, FuseVersion } from '@electron/fuses';
+
+import { mainConfig } from './webpack.main.config';
+import { rendererConfig } from './webpack.renderer.config';
+
+const config: ForgeConfig = {
+  packagerConfig: {
+    asar: true,
+  },
+  rebuildConfig: {},
+  makers: [
+    new MakerSquirrel({}),
+    new MakerZIP({}, ['darwin']),
+    new MakerRpm({}),
+    new MakerDeb({}),
+  ],
+  plugins: [
+    new AutoUnpackNativesPlugin({}),
+    new WebpackPlugin({
+      mainConfig,
+      renderer: {
+        config: rendererConfig,
+        entryPoints: [
+          {
+            name: 'main_window',
+            html: './src/renderer/index.html',
+            js: './src/renderer/index.ts',
+            preload: {
+              js: './src/main/preload.ts',
+            },
+          },
+        ],
+      },
+    }),
+    // Harden the packaged app at make time.
+    new FusesPlugin({
+      version: FuseVersion.V1,
+      [FuseV1Options.RunAsNode]: false,
+      [FuseV1Options.EnableCookieEncryption]: true,
+      [FuseV1Options.EnableNodeOptionsEnvironmentVariable]: false,
+      [FuseV1Options.EnableNodeCliInspectArguments]: false,
+      [FuseV1Options.EnableEmbeddedAsarIntegrityValidation]: true,
+      [FuseV1Options.OnlyLoadAppFromAsar]: true,
+    }),
+  ],
+};
+
+export default config;
+`;
+}
+function renderWebpackMain() {
+  return `import type { Configuration } from 'webpack';
+import { rules } from './webpack.rules';
+
+export const mainConfig: Configuration = {
+  entry: './src/main/main.ts',
+  module: {
+    rules,
+  },
+  resolve: {
+    extensions: ['.js', '.ts', '.jsx', '.tsx', '.css', '.json'],
+  },
+};
+`;
+}
+function renderWebpackRenderer() {
+  return `import type { Configuration } from 'webpack';
+import { rules } from './webpack.rules';
+
+// Entry points wire \`main_window\` and inject \`./src/main/preload.ts\` as its
+// preload, which the Webpack plugin surfaces as MAIN_WINDOW_PRELOAD_WEBPACK_ENTRY.
+export const rendererEntryPoints = [
+  {
+    name: 'main_window',
+    html: './src/renderer/index.html',
+    js: './src/renderer/index.ts',
+    preload: './src/main/preload.ts',
+  },
+];
+
+export const rendererConfig: Configuration = {
+  module: {
+    rules,
+  },
+  resolve: {
+    extensions: ['.js', '.ts', '.jsx', '.tsx', '.css'],
+  },
+};
+`;
+}
+function renderMainTs() {
+  return `import { app, ipcMain } from 'electron';
+import { startDesktop } from '@sublime-ui/desktop';
+
+// These constants are injected by the Electron Forge Webpack plugin.
+declare const MAIN_WINDOW_WEBPACK_ENTRY: string;
+declare const MAIN_WINDOW_PRELOAD_WEBPACK_ENTRY: string;
+
+startDesktop({
+  app,
+  ipcMain,
+  entry: MAIN_WINDOW_WEBPACK_ENTRY,
+  preload: MAIN_WINDOW_PRELOAD_WEBPACK_ENTRY,
+  isDev: !app.isPackaged,
+});
+`;
+}
+function renderPreloadTs() {
+  return `import { contextBridge, ipcRenderer } from 'electron';
+import { exposeNativeBridge } from '@sublime-ui/desktop';
+
+// Exposes exactly one function (\`window.sublimeNative.invoke\`) over the single
+// \`native:invoke\` channel \u2014 nothing else crosses the isolation boundary.
+exposeNativeBridge(contextBridge, ipcRenderer);
+`;
+}
+
+// src/lib/scaffold/templates/desktop.ts
+function renderGreeterService() {
+  return `import { defineNative } from '@sublime-ui/desktop';
+
+/** A sample native service. Runs in the main process; the renderer calls it via useNative. */
+export const greeter = defineNative('greeter', {
+  async hello(name: string): Promise<string> {
+    return \`Hello from the desktop main process, \${name}!\`;
+  },
+});
+`;
+}
+function renderDesktopPackageJson(name) {
+  const pkg = {
+    name: `${name}-desktop`,
+    version: "0.0.0",
+    private: true,
+    main: ".webpack/main",
+    scripts: {
+      start: "electron-forge start",
+      package: "electron-forge package",
+      make: "electron-forge make"
+    },
+    devDependencies: {
+      "@electron-forge/cli": "^7.5.0",
+      "@electron-forge/maker-deb": "^7.5.0",
+      "@electron-forge/maker-rpm": "^7.5.0",
+      "@electron-forge/maker-squirrel": "^7.5.0",
+      "@electron-forge/maker-zip": "^7.5.0",
+      "@electron-forge/plugin-auto-unpack-natives": "^7.5.0",
+      "@electron-forge/plugin-fuses": "^7.5.0",
+      "@electron-forge/plugin-webpack": "^7.5.0",
+      "@electron/fuses": "^1.8.0",
+      "@vercel/webpack-asset-relocator-loader": "^1.7.3",
+      "css-loader": "^7.1.2",
+      electron: PEER_VERSIONS["electron"],
+      "node-loader": "^2.0.0",
+      "style-loader": "^4.0.0",
+      "ts-loader": "^9.5.1",
+      typescript: PEER_VERSIONS["typescript"]
+    },
+    dependencies: {
+      "@sublime-ui/desktop": SUBLIME_VERSIONS.desktop
+    }
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function renderWebpackRules() {
+  return `import type { ModuleOptions } from 'webpack';
+
+export const rules: Required<ModuleOptions>['rules'] = [
+  { test: /native_modules[/\\\\].+\\.node$/, use: 'node-loader' },
+  {
+    test: /[/\\\\]node_modules[/\\\\].+\\.(m?js|node)$/,
+    parser: { amd: false },
+    use: {
+      loader: '@vercel/webpack-asset-relocator-loader',
+      options: { outputAssetBase: 'native_modules' },
+    },
+  },
+  {
+    test: /\\.tsx?$/,
+    exclude: /(node_modules|\\.webpack)/,
+    use: { loader: 'ts-loader', options: { transpileOnly: true } },
+  },
+  { test: /\\.css$/, use: ['style-loader', 'css-loader'] },
+];
+`;
+}
+function renderRendererIndexHtml(name) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>${name}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>
+`;
+}
+function renderRendererIndexTs() {
+  return `import '../../../web/main.tsx';
+`;
+}
+
+// src/lib/scaffold/plan.ts
+var has2 = (t, x) => t.includes(x);
+function buildScaffoldPlan(opts) {
+  const { name, targets } = opts;
+  const files = [
+    { path: "package.json", contents: renderAppPackageJson(name, targets) },
+    { path: "sublime.config.json", contents: renderSublimeConfig(targets) },
+    { path: "tsconfig.json", contents: renderTsconfig(targets) },
+    { path: ".gitignore", contents: renderGitignore() },
+    { path: "README.md", contents: renderAppReadme(name, targets) },
+    { path: "src/models/Task.ts", contents: renderTaskModel() },
+    { path: "src/models/index.ts", contents: renderModelsBarrel() },
+    { path: "src/theme/tokens.json", contents: renderThemeTokensJson() },
+    { path: "src/theme/tokens.ts", contents: renderThemeTokensTs() }
+  ];
+  if (has2(targets, "web") || has2(targets, "desktop")) {
+    files.push(
+      { path: "src/screens/web/TaskList.tsx", contents: renderWebTaskList() },
+      { path: "src/screens/web/TaskDetail.tsx", contents: renderWebTaskDetail() },
+      { path: "src/navigation/screens.ts", contents: renderWebScreensBarrel() },
+      { path: "src/navigation/storybook.web.ts", contents: renderStorybookWeb() },
+      { path: "web/index.html", contents: renderWebIndexHtml(name) },
+      { path: "web/main.tsx", contents: renderWebMain() },
+      { path: "vite.config.ts", contents: renderViteConfig() }
+    );
+  }
+  if (has2(targets, "mobile")) {
+    files.push(
+      { path: "src/screens/mobile/TaskList.native.tsx", contents: renderMobileTaskList() },
+      { path: "src/screens/mobile/TaskDetail.native.tsx", contents: renderMobileTaskDetail() },
+      { path: "src/navigation/screens.native.ts", contents: renderMobileScreensBarrel() },
+      { path: "src/navigation/storybook.native.ts", contents: renderStorybookNative() },
+      { path: "mobile/index.js", contents: renderMobileEntry() },
+      { path: "mobile/App.native.tsx", contents: renderMobileApp() },
+      { path: "app.json", contents: JSON.stringify({ name }, null, 2) + "\n" }
+    );
+  }
+  if (has2(targets, "desktop")) {
+    files.push(
+      { path: "src/native/greeter.service.ts", contents: renderGreeterService() },
+      { path: "desktop/package.json", contents: renderDesktopPackageJson(name) },
+      { path: "desktop/forge.config.ts", contents: renderForgeConfig() },
+      { path: "desktop/webpack.main.config.ts", contents: renderWebpackMain() },
+      { path: "desktop/webpack.renderer.config.ts", contents: renderWebpackRenderer() },
+      { path: "desktop/webpack.rules.ts", contents: renderWebpackRules() },
+      { path: "desktop/src/main/main.ts", contents: renderMainTs() },
+      { path: "desktop/src/main/preload.ts", contents: renderPreloadTs() },
+      { path: "desktop/src/renderer/index.html", contents: renderRendererIndexHtml(name) },
+      { path: "desktop/src/renderer/index.ts", contents: renderRendererIndexTs() }
+    );
+  }
+  return files;
+}
+
+// src/lib/generators/write.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var FileExistsError = class _FileExistsError extends Error {
+  path;
+  constructor(path) {
+    super(`File already exists: ${path} (use --force to overwrite)`);
+    this.name = "FileExistsError";
+    this.path = path;
+    Object.setPrototypeOf(this, _FileExistsError.prototype);
+  }
+};
+function safeWrite(path, content, force) {
+  if (existsSync(path) && !force) throw new FileExistsError(path);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content);
+}
+
+// src/util/exec.ts
+import { execa } from "execa";
+async function run(file, args, opts = {}) {
+  const result = await execa(file, args, {
+    ...opts.cwd === void 0 ? {} : { cwd: opts.cwd },
+    env: { ...process.env, ...opts.env },
+    reject: false,
+    all: false
+  });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.exitCode ?? 1
+  };
+}
+async function runInherit(file, args, opts = {}) {
+  const result = await execa(file, args, {
+    ...opts.cwd === void 0 ? {} : { cwd: opts.cwd },
+    env: { ...process.env, ...opts.env },
+    stdio: "inherit",
+    reject: false
+  });
+  return result.exitCode ?? 1;
+}
+
+// src/lib/scaffold/init.ts
+var defaultRunner = (cmd, args, cwd) => runInherit(cmd, args, { cwd });
+function isValidNpmName(s) {
+  return /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(s) && s.length <= 214;
+}
+function isEmptyDir(dir) {
+  if (!existsSync2(dir)) return true;
+  return readdirSync(dir).length === 0;
+}
+async function initApp(opts) {
+  const runner = opts.runner ?? defaultRunner;
+  let name = opts.name;
+  let targets = opts.targets;
+  if ((name === void 0 || targets === void 0) && !opts.yes && opts.prompt) {
+    const answered = await opts.prompt({ dir: opts.dir });
+    name ??= answered.name;
+    targets ??= answered.targets;
+  }
+  name ??= basename(opts.dir);
+  targets ??= ["web", "mobile", "desktop"];
+  if (!isValidNpmName(name)) {
+    log.error(`Invalid app name "${name}". Use a valid npm package name (lowercase, url-safe).`);
+    return 1;
+  }
+  if (targets.length === 0) {
+    log.error("Select at least one target (web, mobile, desktop).");
+    return 1;
+  }
+  if (targets.includes("desktop") && !targets.includes("web")) {
+    log.error('The desktop target renders the web UI \u2014 enable "web" alongside "desktop".');
+    return 1;
+  }
+  const force = opts.force ?? false;
+  if (!isEmptyDir(opts.dir) && !force) {
+    log.error(`Target directory ${opts.dir} is not empty (use --force to scaffold into it).`);
+    return 1;
+  }
+  const plan = buildScaffoldPlan({ name, targets });
+  try {
+    for (const file of plan) safeWrite(join(opts.dir, file.path), file.contents, force);
+  } catch (err) {
+    if (err instanceof FileExistsError) {
+      log.error(err.message);
+      return 1;
+    }
+    throw err;
+  }
+  log.success(`Scaffolded ${name} (${targets.join(", ")}) in ${opts.dir}`);
+  if (opts.git ?? true) {
+    await runner("git", ["init", "-q"], opts.dir);
+  }
+  if (opts.install ?? true) {
+    log.step("Installing dependencies\u2026");
+    const installCode = await runner("npm", ["install", "--legacy-peer-deps"], opts.dir);
+    if (installCode !== 0) {
+      log.warn("npm install failed \u2014 run it manually.");
+      return 0;
+    }
+    log.step("Compiling navigation (build:nav)\u2026");
+    await runner("npx", ["sublime", "build:nav"], opts.dir);
+  }
+  log.info("");
+  log.info(`Next:  cd ${basename(opts.dir)}`);
+  if (!(opts.install ?? true)) log.info("       npm install && npm run build:nav");
+  if (targets.includes("web")) log.info("       npm run dev:web");
+  if (targets.includes("mobile")) log.info("       npm run dev:mobile");
+  if (targets.includes("desktop")) log.info("       npm run desktop:dev");
+  return 0;
+}
+
+export {
+  run,
+  runInherit,
+  log,
+  FileExistsError,
+  safeWrite,
+  isValidNpmName,
+  initApp
+};