@lunora/cli 1.0.0-alpha.5 → 1.0.0-alpha.6

package/dist/packem_chunks/runInitCommand.mjs

@@ -1,16 +1,18 @@
-import { existsSync, mkdirSync, writeFileSync, readdirSync, mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, mkdtempSync, cpSync, rmSync, renameSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { detectFramework as detectFramework$1, isInteractive } from '@lunora/config';
 import { walkSync } from '@visulima/fs';
-import { resolve, join as join$1, relative, dirname as dirname$1, basename } from '@visulima/path';
+import { join as join$1, dirname as dirname$1, basename, resolve, relative } from '@visulima/path';
 import { downloadTemplate } from 'giget';
 import { modify, applyEdits } from 'jsonc-parser';
 import { join, dirname } from 'node:path';
 import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { a as detectInstalledManagers, i as installArgsFor } from '../packem_shared/detect-package-manager-DYp7n3mJ.mjs';
 import MagicString from 'magic-string';
 import { Project, SyntaxKind } from 'ts-morph';
-import { c as resolveSourceRef, d as resolveDistTag, r as runAddCommand } from '../packem_shared/commands-B9nASOYd.mjs';
-import { b as tuiIntro, d as tuiOutro, t as tuiSelect, e as tuiMultiSelect, w as withTuiSpinner } from '../packem_shared/tui-prompts-Bm15GPJA.mjs';
+import { c as resolveDistTag, d as resolveSourceRef, r as runAddCommand } from '../packem_shared/commands-DqsEzojt.mjs';
+import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+import { b as tuiOutro, d as tuiBanner, e as tuiText, f as tuiIntro, t as tuiSelect, w as withTuiSpinner, a as tuiConfirm, g as tuiMultiSelect } from '../packem_shared/tui-prompts-XHFxlOg5.mjs';
 import { p as promptAuthProvider, E as EMAIL_ITEM } from '../packem_shared/features-ocSSpZtS.mjs';
 
 const GITHUB_CONTENT = `name: Deploy
@@ -285,11 +287,16 @@ const patchViteConfig = (source) => {
 
 const STACK_FEATURE_OPTIONS = [
   { description: "Sign-up / sign-in (asks which provider)", label: "Authentication", value: "auth" },
-  { description: "Cloudflare Email Workers + a dev mail catcher", label: "Transactional email", value: "email" }
+  { description: "Cloudflare Email Workers + a dev mail catcher", label: "Transactional email", value: "email" },
+  { description: "Typed R2 buckets + signed URLs (@lunora/storage)", label: "File storage", value: "storage" },
+  { description: "Token-bucket / sliding-window limits (@lunora/ratelimit)", label: "Rate limiting", value: "ratelimit" },
+  { description: "Scheduled jobs via Cron Triggers (@lunora/scheduler)", label: "Cron jobs", value: "crons" },
+  { description: "Live presence / who's-online over hibernated WebSockets", label: "Presence", value: "presence" },
+  { description: "Snapshot + restore your Durable Object data", label: "Backups", value: "backup" }
 ];
 const offerRegistryExtras = async (deps) => {
   if (!deps.interactive) {
-    deps.logger.info("tip: add authentication or email later with `lunora add auth` / `lunora add email`.");
+    deps.logger.info("tip: add features later with `lunora add <auth|email|storage|ratelimit|crons|presence|backup>`.");
     return;
   }
   const picked = await deps.multiSelect("Which features do you want to add?", STACK_FEATURE_OPTIONS, { defaults: [] });
@@ -298,11 +305,268 @@ const offerRegistryExtras = async (deps) => {
       const provider = await promptAuthProvider(deps.select);
       await deps.apply([provider]);
     } else {
-      await deps.apply([EMAIL_ITEM]);
+      await deps.apply([feature === "email" ? EMAIL_ITEM : feature]);
     }
   }
 };
 
+const READ_URL = `const url = (import.meta.env.VITE_LUNORA_URL as string | undefined) ?? globalThis.location.origin;`;
+const REACT_MAIN = `import "./index.css";
+
+import { LunoraProvider } from "@lunora/react";
+import { LunoraClient } from "lunorash/client";
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+
+import App from "./App.tsx";
+
+// \`@lunora/vite\` runs the Worker on the same origin as Vite, so default to
+// \`location.origin\`. Point \`VITE_LUNORA_URL\` at a deployed Worker to develop
+// the client against production data.
+${READ_URL}
+const client = new LunoraClient({ url });
+
+const root = document.getElementById("root");
+
+if (!root) {
+    throw new Error("missing #root mount node");
+}
+
+createRoot(root).render(
+    <StrictMode>
+        <LunoraProvider client={client}>
+            <App />
+        </LunoraProvider>
+    </StrictMode>,
+);
+`;
+const VUE_MAIN = `import "./style.css";
+
+import { createLunora } from "@lunora/vue";
+import { LunoraClient } from "lunorash/client";
+import { createApp } from "vue";
+
+import App from "./App.vue";
+
+// Provide one LunoraClient at the app root via the Vue plugin form.
+${READ_URL}
+createApp(App).use(createLunora(new LunoraClient({ url }))).mount("#app");
+`;
+const SOLID_INDEX = `import "./index.css";
+
+import { LunoraContext } from "@lunora/solid";
+import { LunoraClient } from "lunorash/client";
+import { render } from "solid-js/web";
+
+import App from "./App";
+
+${READ_URL}
+const client = new LunoraClient({ url });
+const root = document.getElementById("root");
+
+render(
+    () => (
+        <LunoraContext.Provider value={client}>
+            <App />
+        </LunoraContext.Provider>
+    ),
+    root!,
+);
+`;
+const SVELTE_ROOT = `<script lang="ts">
+    import { setLunoraClient } from "@lunora/svelte";
+    import { LunoraClient } from "lunorash/client";
+
+    import App from "./App.svelte";
+
+    ${READ_URL}
+    setLunoraClient(new LunoraClient({ url }));
+<\/script>
+
+<App />
+`;
+const SVELTE_MAIN = `import "./app.css";
+
+import { mount } from "svelte";
+
+import Root from "./Root.svelte";
+
+// Mount \`Root\` (it sets the ambient LunoraClient) rather than \`App\` directly.
+const app = mount(Root, { target: document.getElementById("app")! });
+
+export default app;
+`;
+const VANILLA_MAIN = `import "./style.css";
+
+import { LunoraClient } from "lunorash/client";
+
+import { api } from "../lunora/_generated/api";
+
+// Vanilla starter: no framework provider — talk to Lunora through the client
+// directly. \`@lunora/vite\` runs the Worker on the same origin as Vite.
+${READ_URL}
+const client = new LunoraClient({ url });
+
+const root = document.querySelector<HTMLDivElement>("#app")!;
+
+const heading = document.createElement("h1");
+heading.textContent = "Vite + Lunora";
+
+const output = document.createElement("pre");
+root.replaceChildren(heading, output);
+
+const render = (messages: unknown): void => {
+    // textContent (not innerHTML) — never inject server data as markup.
+    output.textContent = JSON.stringify(messages, null, 2);
+};
+
+// Live subscription: the list re-renders on every server delta.
+client.onUpdate(api.messages.list, { channelId: "channel:demo" }, render);
+`;
+const ADAPTERS = {
+  react: { adapter: "@lunora/react", createViteTemplate: "react-ts", files: [{ contents: REACT_MAIN, path: "src/main.tsx" }], label: "React" },
+  solid: { adapter: "@lunora/solid", createViteTemplate: "solid", files: [{ contents: SOLID_INDEX, path: "src/index.tsx" }], label: "Solid" },
+  svelte: {
+    adapter: "@lunora/svelte",
+    createViteTemplate: "svelte-ts",
+    files: [
+      { contents: SVELTE_ROOT, path: "src/Root.svelte" },
+      { contents: SVELTE_MAIN, path: "src/main.ts" }
+    ],
+    label: "Svelte"
+  },
+  vanilla: { adapter: "lunorash/client", createViteTemplate: "vanilla-ts", files: [{ contents: VANILLA_MAIN, path: "src/main.ts" }], label: "Vanilla" },
+  vue: { adapter: "@lunora/vue", createViteTemplate: "vue-ts", files: [{ contents: VUE_MAIN, path: "src/main.ts" }], label: "Vue" }
+};
+const isOverlayFramework = (value) => Object.hasOwn(ADAPTERS, value);
+
+const LUNORA_SCHEMA = `import { defineSchema, defineTable, v } from "lunorash/server";
+
+export default defineSchema({
+    messages: defineTable({
+        channelId: v.string(),
+        text: v.string(),
+    })
+        .shardBy("channelId")
+        .index("by_channel", ["channelId"]),
+});
+`;
+const LUNORA_MESSAGES = `import { mutation, query, v } from "./_generated/server.js";
+
+export const list = query.input({ channelId: v.string(), limit: v.optional(v.number()) }).query(async ({ args }) => {
+    return { channelId: args.channelId, limit: args.limit ?? 50, messages: [] };
+});
+
+export const send = mutation.input({ channelId: v.string(), text: v.string() }).mutation(async ({ args }) => {
+    return { channelId: args.channelId, text: args.text };
+});
+`;
+const SERVER_ENTRY = `import type { ShardNamespaceLike } from "lunorash/runtime";
+
+import { defineApp } from "../lunora/_generated/app.js";
+
+interface Env extends Record<string, unknown> {
+    SHARD: ShardNamespaceLike;
+}
+
+const app = defineApp<Env>()
+    .shard((env) => env.SHARD)
+    .build();
+
+export const ShardDO = app.ShardDO;
+export default app;
+`;
+const WRANGLER = `{
+    "$schema": "node_modules/wrangler/config-schema.json",
+    "name": "__NAME__",
+    "main": "src/server.ts",
+    "compatibility_date": "2026-06-10",
+    "compatibility_flags": ["nodejs_compat"],
+    "durable_objects": {
+        "bindings": [{ "name": "SHARD", "class_name": "ShardDO" }],
+    },
+    "migrations": [{ "tag": "v1", "new_sqlite_classes": ["ShardDO"] }],
+    "observability": { "enabled": true, "head_sampling_rate": 1 },
+}
+`;
+const GITIGNORE_ADDITIONS = [".wrangler", ".lunora/", ".lunora-cache", "lunora/_generated"];
+const COMMON_DEV_DEPENDENCIES = {
+  "@cloudflare/workers-types": "^4.20260611.1",
+  wrangler: "^4.100.0"
+};
+const writeFile = (target, relativePath, contents, written) => {
+  const destination = join$1(target, relativePath);
+  mkdirSync(dirname$1(destination), { recursive: true });
+  writeFileSync(destination, contents, "utf8");
+  written.push(destination);
+};
+const NEWLINE = /\r?\n/;
+const ensureGitignore = (target) => {
+  const path = join$1(target, ".gitignore");
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const missing = GITIGNORE_ADDITIONS.filter((entry) => !existing.split(NEWLINE).includes(entry));
+  if (missing.length === 0) {
+    return;
+  }
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  writeFileSync(path, `${existing}${prefix}
+# Lunora
+${missing.join("\n")}
+`, "utf8");
+};
+const stampRange = (name, range, distTag) => name === "lunorash" || name.startsWith("@lunora/") ? distTag : range;
+const withDependency = (map, name, range, distTag) => {
+  return { ...map, [name]: stampRange(name, range, distTag) };
+};
+const restampLunora = (map, distTag) => Object.fromEntries(Object.entries(map).map(([name, range]) => [name, stampRange(name, range, distTag)]));
+const patchPackageJson = (target, name, adapter, distTag) => {
+  const path = join$1(target, "package.json");
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  let dependencies = withDependency(parsed.dependencies ?? {}, "lunorash", distTag, distTag);
+  if (adapter.adapter.startsWith("@lunora/")) {
+    dependencies = withDependency(dependencies, adapter.adapter, distTag, distTag);
+  }
+  for (const [depName, range] of Object.entries(adapter.extraDependencies ?? {})) {
+    dependencies = withDependency(dependencies, depName, range, distTag);
+  }
+  let devDependencies = withDependency(parsed.devDependencies ?? {}, "@lunora/vite", distTag, distTag);
+  for (const [depName, range] of Object.entries(COMMON_DEV_DEPENDENCIES)) {
+    devDependencies = withDependency(devDependencies, depName, range, distTag);
+  }
+  parsed.name = name;
+  parsed.dependencies = restampLunora(dependencies, distTag);
+  parsed.devDependencies = restampLunora(devDependencies, distTag);
+  parsed.scripts = { ...parsed.scripts, codegen: "lunora codegen", deploy: "vite build && lunora deploy" };
+  writeFileSync(path, `${JSON.stringify(parsed, void 0, 4)}
+`, "utf8");
+};
+const patchBaseViteConfig = (target, logger) => {
+  const candidate = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"].map((file) => join$1(target, file)).find((path) => existsSync(path));
+  if (candidate === void 0) {
+    logger.warn("overlay: no vite.config found in the create-vite base — add `lunora()` to your Vite plugins manually.");
+    return;
+  }
+  const result = patchViteConfig(readFileSync(candidate, "utf8"));
+  if (result.changed) {
+    writeFileSync(candidate, result.code, "utf8");
+  }
+};
+const applyLunoraOverlay = (options) => {
+  const { adapter, distTag, logger, name, target } = options;
+  const written = [];
+  writeFile(target, join$1("lunora", "schema.ts"), LUNORA_SCHEMA, written);
+  writeFile(target, join$1("lunora", "messages.ts"), LUNORA_MESSAGES, written);
+  writeFile(target, join$1("src", "server.ts"), SERVER_ENTRY, written);
+  writeFile(target, "wrangler.jsonc", WRANGLER.replaceAll("__NAME__", name), written);
+  for (const file of adapter.files) {
+    writeFile(target, file.path, file.contents, written);
+  }
+  patchBaseViteConfig(target, logger);
+  patchPackageJson(target, name, adapter, distTag);
+  ensureGitignore(target);
+  return written;
+};
+
 const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".gitignore", ".html", ".js", ".json", ".jsonc", ".md", ".mjs", ".ts", ".tsx"]);
 const VITE_CONFIG_CANDIDATES = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
 const MINIMAL_VITE_CONFIG = `import { defineConfig } from "vite";
@@ -405,12 +669,60 @@ const isSafeSource = (source) => {
   }
   return source.startsWith("gh:") || source.startsWith("github:") || source.startsWith("https://");
 };
-const logScaffoldSuccess = (logger, written, target, name) => {
+const logScaffoldSuccess = (logger, written, target) => {
   logger.success(`scaffolded ${String(written.length)} files into ${target}`);
+};
+const runScriptCommand = (manager, script) => {
+  if (manager === "npm") {
+    return `npm run ${script}`;
+  }
+  if (manager === "bun") {
+    return `bun run ${script}`;
+  }
+  return `${manager} ${script}`;
+};
+const printNextSteps = (logger, name, installed) => {
+  const manager = installed ?? "pnpm";
   logger.info("next steps:");
   logger.info(`  cd ${name}`);
-  logger.info("  pnpm install");
-  logger.info("  pnpm dev");
+  if (installed === void 0) {
+    logger.info(`  ${manager} install`);
+  }
+  logger.info(`  ${runScriptCommand(manager, "dev")}`);
+};
+const offerInstallIsInteractive = (options) => options.yes !== true && (options.installPrompt !== void 0 || isInteractive());
+const maybeOfferInstall = async (options, target) => {
+  if (!offerInstallIsInteractive(options)) {
+    return void 0;
+  }
+  const managers = detectInstalledManagers(options.packageManagerProbe);
+  const [defaultManager] = managers;
+  if (defaultManager === void 0) {
+    return void 0;
+  }
+  const confirm = options.installPrompt?.confirmInstall ?? (async () => tuiConfirm("Install dependencies now?", { defaultYes: true }));
+  if (!await confirm()) {
+    return void 0;
+  }
+  let manager = defaultManager;
+  if (managers.length > 1) {
+    manager = options.installPrompt ? await options.installPrompt.selectManager(managers) : await tuiSelect(
+      "Which package manager?",
+      managers.map((candidate) => {
+        return { label: candidate, value: candidate };
+      }),
+      { default: defaultManager }
+    ) ?? defaultManager;
+  }
+  const spawner = options.spawner ?? defaultSpawner;
+  const { args, command } = installArgsFor(manager);
+  const result = await withTuiSpinner(`Installing dependencies with ${manager}…`, () => spawner({ args, command, cwd: target }));
+  if (result.code !== 0) {
+    options.logger.warn(`\`${command} install\` exited with code ${String(result.code)} — run it yourself in ${basename(target)}/.`);
+    return void 0;
+  }
+  options.logger.success(`installed dependencies with ${manager}`);
+  return manager;
 };
 const scaffoldFromLocal = (fromRoot, templateType, target, name, logger) => {
   const templateDirectory = join$1(fromRoot, templateType);
@@ -419,7 +731,7 @@ const scaffoldFromLocal = (fromRoot, templateType, target, name, logger) => {
     return { code: 1, files: [], target };
   }
   const written = copyTemplate(templateDirectory, target, name);
-  logScaffoldSuccess(logger, written, target, name);
+  logScaffoldSuccess(logger, written, target);
   return { code: 0, files: written, target };
 };
 const scaffoldFromRemote = async (options) => {
@@ -428,22 +740,25 @@ const scaffoldFromRemote = async (options) => {
   const stagingDirectory = join$1(stagingRoot, "template");
   try {
     const remote = resolveTemplateSource(templateType, source, ref);
-    logger.info(`fetching template from ${remote}`);
-    const downloaded = await downloadTemplate(remote, {
-      cwd: stagingRoot,
-      dir: stagingDirectory,
-      force: true,
-      install: false,
-      silent: true
-    });
+    const downloaded = await withTuiSpinner(
+      `Fetching the ${templateType} template…`,
+      () => downloadTemplate(remote, {
+        cwd: stagingRoot,
+        dir: stagingDirectory,
+        force: true,
+        install: false,
+        silent: true
+      })
+    );
     const staged = collectFiles(stagingDirectory);
-    if (downloaded.commit) {
-      logger.info(`resolved ${downloaded.source} @ ${downloaded.commit} (${String(staged.length)} file(s))`);
-    } else {
-      logger.info(`resolved ${downloaded.source} (${String(staged.length)} file(s))`);
-    }
-    const written = copyTemplate(stagingDirectory, target, name);
-    logScaffoldSuccess(logger, written, target, name);
+    logger.info(
+      downloaded.commit ? `template: ${downloaded.source} @ ${downloaded.commit} (${String(staged.length)} files)` : `template: ${downloaded.source} (${String(staged.length)} files)`
+    );
+    const written = await withTuiSpinner(
+      `Scaffolding ${String(staged.length)} files into ${name}/…`,
+      () => Promise.resolve(copyTemplate(stagingDirectory, target, name))
+    );
+    logScaffoldSuccess(logger, written, target);
     return { code: 0, files: written, target };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -453,6 +768,50 @@ const scaffoldFromRemote = async (options) => {
     rmSync(stagingRoot, { force: true, recursive: true });
   }
 };
+const renameCreateViteDotfiles = (directory) => {
+  for (const file of ["_gitignore", "_npmrc", "_gitattributes"]) {
+    const from = join$1(directory, file);
+    if (existsSync(from)) {
+      renameSync(from, join$1(directory, `.${file.slice(1)}`));
+    }
+  }
+};
+const scaffoldViteOverlay = async (options) => {
+  const { framework, logger, name, overlayBaseFrom, target } = options;
+  const adapter = ADAPTERS[framework];
+  const stagingRoot = mkdtempSync(join$1(tmpdir(), "lunora-vite-base-"));
+  try {
+    if (overlayBaseFrom === void 0) {
+      const stagingDirectory = join$1(stagingRoot, "base");
+      const remote = `github:vitejs/vite/packages/create-vite/template-${adapter.createViteTemplate}#main`;
+      await withTuiSpinner(
+        `Fetching the ${adapter.label} (create-vite) base…`,
+        () => downloadTemplate(remote, { cwd: stagingRoot, dir: stagingDirectory, force: true, install: false, silent: true })
+      );
+      renameCreateViteDotfiles(stagingDirectory);
+      cpSync(stagingDirectory, target, { recursive: true });
+    } else {
+      const localBase = join$1(overlayBaseFrom, `template-${adapter.createViteTemplate}`);
+      if (!existsSync(localBase)) {
+        logger.error(`create-vite base not found on disk: ${localBase}`);
+        return { code: 1, files: [], target };
+      }
+      cpSync(localBase, target, { recursive: true });
+    }
+    const written = await withTuiSpinner(
+      `Applying the Lunora overlay (${adapter.label})…`,
+      () => Promise.resolve(applyLunoraOverlay({ adapter, distTag: resolveDistTag(), logger, name, target }))
+    );
+    logScaffoldSuccess(logger, written, target);
+    return { code: 0, files: [...collectFiles(target)], target };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`failed to scaffold the ${adapter.label} base: ${message}`);
+    return { code: 1, files: [], target };
+  } finally {
+    rmSync(stagingRoot, { force: true, recursive: true });
+  }
+};
 const createMinimalViteConfig = (cwd, logger) => {
   const target = join$1(cwd, "vite.config.ts");
   try {
@@ -606,15 +965,62 @@ const maybeOfferExtras = async (options, projectDirectory) => {
     multiSelect: options.prompt?.multiSelect ?? ((message, choices, settings) => tuiMultiSelect(message, choices, settings)),
     select: options.prompt?.select ?? ((message, choices, settings) => tuiSelect(message, choices, settings))
   });
-  await tuiOutro("you're all set — run `pnpm dev` to start.");
+};
+const DEFAULT_FRAMEWORK = "react";
+const FRAMEWORK_CHOICES = [
+  { description: "React SPA — official create-vite base + the Lunora layer (the default)", label: "React", value: "react" },
+  { description: "Vue SPA — create-vite base + Lunora", label: "Vue", value: "vue" },
+  { description: "Solid SPA — create-vite base + Lunora", label: "Solid", value: "solid" },
+  { description: "Svelte SPA — create-vite base + Lunora", label: "Svelte", value: "svelte" },
+  { description: "TanStack Start (React) — SSR with live-loader routes", label: "TanStack Start · React", value: "tanstack-start-react" },
+  { description: "TanStack Start (Solid)", label: "TanStack Start · Solid", value: "tanstack-start-solid" },
+  { description: "React Router (v7, framework mode) — SSR composed into the Lunora worker", label: "React Router", value: "react-router" },
+  { description: "Astro + a standalone Lunora worker", label: "Astro", value: "astro" },
+  { description: "AnalogJS (Angular) — single-worker, Lunora mounted in Nitro", label: "Analog", value: "analog" },
+  { description: "Nuxt (Vue) — single-worker, Lunora mounted in Nitro", label: "Nuxt", value: "nuxt" },
+  { description: "SvelteKit + a standalone Lunora worker", label: "SvelteKit", value: "sveltekit" },
+  { description: "Worker only — no frontend", label: "Standalone", value: "standalone" }
+];
+const OVERLAY_VALUES = Object.keys(ADAPTERS).join("|");
+const TEMPLATE_VALUES = FRAMEWORK_CHOICES.filter((choice) => !isOverlayFramework(choice.value)).map((choice) => choice.value).join("|");
+const toScaffoldChoice = (value) => isOverlayFramework(value) ? { framework: value, kind: "overlay" } : { kind: "template", templateType: value };
+const resolveScaffoldChoice = async (options) => {
+  if (options.vite !== void 0) {
+    return { framework: options.vite, kind: "overlay" };
+  }
+  if (options.templateType !== void 0) {
+    return { kind: "template", templateType: options.templateType };
+  }
+  if (!isInteractive() || options.yes === true) {
+    return { framework: DEFAULT_FRAMEWORK, kind: "overlay" };
+  }
+  return toScaffoldChoice(await tuiSelect("Which framework would you like?", FRAMEWORK_CHOICES, { default: DEFAULT_FRAMEWORK }) ?? DEFAULT_FRAMEWORK);
+};
+const nonInteractiveInitError = (options) => {
+  if (isInteractive() || options.yes === true) {
+    return void 0;
+  }
+  const missing = [];
+  if (options.name === void 0) {
+    missing.push("a project name (`lunora init <name>`)");
+  }
+  if (options.templateType === void 0 && options.vite === void 0) {
+    missing.push(`a framework — \`--vite <${OVERLAY_VALUES}>\` for an SPA, or \`-t <${TEMPLATE_VALUES}>\` for a bespoke template`);
+  }
+  if (missing.length === 0) {
+    return void 0;
+  }
+  return `lunora init can't prompt in a non-interactive terminal — provide ${missing.join(" and ")}, or pass --yes to accept the defaults.`;
 };
 const scaffoldNewProject = async (options, cwd) => {
-  const name = options.name ?? "lunora-app";
-  const templateType = options.templateType ?? "vite-react";
-  if (templateType === "next") {
-    options.logger.warn('template "next" is not yet available — re-run with `-t vite-react` or `-t standalone`.');
+  await tuiBanner("realtime backend on Cloudflare Workers + Durable Objects");
+  const blocked = nonInteractiveInitError(options);
+  if (blocked !== void 0) {
+    options.logger.error(blocked);
     return { code: 1, files: [], target: "" };
   }
+  const name = options.name ?? await tuiText("What should we call your project?", { default: "lunora-app", placeholder: "lunora-app" });
+  const choice = await resolveScaffoldChoice(options);
   if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
     options.logger.error(`init: refusing project name "${name}" — must not contain path separators or be "." / "..".`);
     return { code: 1, files: [], target: "" };
@@ -627,6 +1033,19 @@ const scaffoldNewProject = async (options, cwd) => {
       return { code: 1, files: [], target };
     }
   }
+  if (choice.kind === "overlay") {
+    if (!isOverlayFramework(choice.framework)) {
+      options.logger.error(`init: unknown framework "${choice.framework}". Supported overlays: ${Object.keys(ADAPTERS).join(", ")}.`);
+      return { code: 1, files: [], target };
+    }
+    mkdirSync(target, { recursive: true });
+    return scaffoldViteOverlay({ framework: choice.framework, logger: options.logger, name, overlayBaseFrom: options.overlayBaseFrom, target });
+  }
+  const { templateType } = choice;
+  if (templateType === "next") {
+    options.logger.warn('template "next" is not yet available — re-run with `--vite react` or `-t standalone`.');
+    return { code: 1, files: [], target };
+  }
   if (options.from !== void 0) {
     return scaffoldFromLocal(options.from, templateType, target, name, options.logger);
   }
@@ -643,13 +1062,18 @@ const runInitCommand = async (options) => {
   const result = options.inPlace === true ? runInPlaceInit(cwd, options.logger) : await scaffoldNewProject(options, cwd);
   if (result.code === 0 && result.target !== "") {
     await maybeOfferExtras(options, result.target);
+    const installedManager = options.inPlace === true ? void 0 : await maybeOfferInstall(options, result.target);
+    if (options.inPlace !== true) {
+      await tuiOutro("you're all set 🎉");
+      printNextSteps(options.logger, basename(result.target), installedManager);
+    }
   }
   if (result.code === 0 && options.ci !== void 0) {
     scaffoldCiWorkflow(options.inPlace === true ? cwd : result.target, options.ci, options.logger);
   }
   return result;
 };
-const isTemplate = (value) => value === "astro" || value === "next" || value === "nuxt" || value === "standalone" || value === "sveltekit" || value === "tanstack-start-react" || value === "tanstack-start-solid" || value === "vite-react";
+const isTemplate = (value) => value === "analog" || value === "astro" || value === "next" || value === "nuxt" || value === "react-router" || value === "standalone" || value === "sveltekit" || value === "tanstack-start-react" || value === "tanstack-start-solid";
 const resolveCiProvider = (raw, logger) => {
   if (raw === void 0) {
     return void 0;
@@ -661,8 +1085,7 @@ const resolveCiProvider = (raw, logger) => {
   return void 0;
 };
 const execute = defineHandler(({ argument, cwd, logger, options }) => {
-  const templateRaw = options.template ?? "vite-react";
-  const template = isTemplate(templateRaw) ? templateRaw : "vite-react";
+  const templateType = options.template !== void 0 && isTemplate(options.template) ? options.template : void 0;
   return runInitCommand({
     allowUnsafeSource: options.allowUnsafeSource === true,
     cwd,
@@ -674,7 +1097,8 @@ const execute = defineHandler(({ argument, cwd, logger, options }) => {
     name: argument[0],
     ref: options.ref,
     source: options.source,
-    templateType: template,
+    templateType,
+    vite: options.vite,
     yes: options.yes === true
   });
 });

package/dist/packem_chunks/runMigrateGenerateCommand.mjs

@@ -1,13 +1,13 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, mkdtempSync, rmSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { discoverMigrations, discoverSchema } from '@lunora/codegen';
+import { discoverSchema, discoverMigrations } from '@lunora/codegen';
 import { join } from '@visulima/path';
 import { Project } from 'ts-morph';
 import { r as resolveAdminBaseUrl } from '../packem_shared/admin-url-4UzT-CI4.mjs';
 import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
-import { diffSnapshots, renderMigrationFile } from '../packem_shared/diffSnapshots-RR2ZE8Ya.mjs';
+import { diffSnapshots, renderMigrationFile } from '../packem_shared/diffSnapshots-BeDvvNiF.mjs';
 import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
-import schemaIrToSnapshot from '../packem_shared/schemaIrToSnapshot-aBTo7TM5.mjs';
+import schemaIrToSnapshot from '../packem_shared/schemaIrToSnapshot-DdsljJT-.mjs';
 import { runExportCommand, runImportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs';
 
 const SNAPSHOT_FILENAME = ".snapshot.json";

package/dist/packem_chunks/runResetCommand.mjs

@@ -1,7 +1,7 @@
 import { existsSync, rmSync } from 'node:fs';
 import { join } from '@visulima/path';
 import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
-import { a as tuiConfirm } from '../packem_shared/tui-prompts-Bm15GPJA.mjs';
+import { a as tuiConfirm } from '../packem_shared/tui-prompts-XHFxlOg5.mjs';
 
 const runResetCommand = async (options) => {
   const cwd = options.cwd ?? process.cwd();

package/dist/packem_shared/{COMMANDS-DXaq12xm.mjs → COMMANDS-Bn8luojF.mjs}

@@ -361,11 +361,19 @@ const initCommand = {
   options: [
     {
       alias: "t",
-      defaultValue: "vite-react",
-      description: "Template to scaffold (vite-react | standalone | astro | nuxt | sveltekit | tanstack-start-react | tanstack-start-solid)",
+      // No default: when omitted, an interactive run shows the framework
+      // picker (default React overlay) and a non-interactive run errors.
+      // For React/Vue/Solid/Svelte SPAs use `--vite <framework>` (overlay);
+      // `-t` selects a bespoke template.
+      description: "Bespoke template (standalone | astro | nuxt | sveltekit | tanstack-start-react | tanstack-start-solid). For an SPA use --vite react|vue|solid|svelte.",
       name: "template",
       type: String
     },
+    {
+      description: "Scaffold via the create-vite overlay for a framework (react | vue | solid | svelte | vanilla) — official create-vite base + Lunora layer",
+      name: "vite",
+      type: String
+    },
     {
       description: "Local templates root to copy from (offline-friendly; expects <type>/ subdirs)",
       name: "from",