@lunora/cli 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/packem_chunks/runInitCommand.mjs

@@ -1,16 +1,21 @@
-import { existsSync, mkdirSync, writeFileSync, readdirSync, mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, mkdtempSync, cpSync, renameSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { detectFramework as detectFramework$1, isInteractive, promptSelect, promptMultiSelect } from '@lunora/config';
+import { detectFramework as detectFramework$1, isInteractive, LUNA_ART, LUNA_NAME, LUNA_SIGNOFF, paintAnswer, BADGES } from '@lunora/config';
 import { walkSync } from '@visulima/fs';
-import { resolve, join as join$1, relative, dirname as dirname$1 } 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 { d as defineHandler } from '../packem_shared/command-BC30oSBW.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 { p as promptAuthProvider, E as EMAIL_ITEM } from '../packem_shared/features-ocSSpZtS.mjs';
-import { runAddCommand } from '../packem_shared/runAddCommand-BZGkRnBs.mjs';
+import { c as resolveSourceRef, d as resolveDistTag, r as runAddCommand } from '../packem_shared/commands-DPKWlqqX.mjs';
+import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+import { d as tuiMascot, e as tuiStep, P as PromptCancelledError, f as tuiMoonrise, t as tuiText, g as tuiHeadline, h as tuiInfo, a as tuiSelect, w as withTuiSpinner, b as tuiConfirm, i as tuiNextSteps, j as tuiTasks, k as tuiMultiSelect, l as withTuiBadgeProgress } from '../packem_shared/tui-prompts-DEiPCKV-.mjs';
+import { logStep } from '../packem_shared/createLogger-B40gPzQo.mjs';
+import { E as EMAIL_ITEM, p as promptBucketName, w as withStorageBucketName, M as MAIL_DESTINATION_PROMPT, r as resolveTypedDestination, f as withMailDestination, e as promptAuthProvider, c as promptDatabaseName, g as withAuthDatabaseName } from '../packem_shared/storage-2RJBhUC4.mjs';
+import dns from 'node:dns/promises';
 
 const GITHUB_CONTENT = `name: Deploy
 
@@ -20,6 +25,10 @@ on:
   pull_request:
   workflow_dispatch:
 
+# Prerequisite: commit your pnpm-lock.yaml. \`pnpm install --frozen-lockfile\`
+# (below) and the pnpm cache both require it — run \`pnpm install\` locally and
+# commit the lockfile before pushing, or the first CI run fails.
+#
 # Set these repository secrets (Settings → Secrets and variables → Actions):
 #   CLOUDFLARE_API_TOKEN   — a Workers-scoped API token
 #   CLOUDFLARE_ACCOUNT_ID  — your Cloudflare account id
@@ -66,6 +75,10 @@ jobs:
 const GITLAB_CONTENT = `stages:
   - deploy
 
+# Prerequisite: commit your pnpm-lock.yaml. \`pnpm install --frozen-lockfile\`
+# (below) requires it — run \`pnpm install\` locally and commit the lockfile
+# before pushing, or the first pipeline fails.
+#
 # Set these as masked CI/CD variables (Settings → CI/CD → Variables):
 #   CLOUDFLARE_API_TOKEN   — a Workers-scoped API token
 #   CLOUDFLARE_ACCOUNT_ID  — your Cloudflare account id
@@ -127,6 +140,9 @@ const scaffoldCiWorkflow = (projectRoot, provider, logger, options = {}) => {
     } else {
       logger.success(`--ci ${provider}: wrote ${spec.file}`);
       logger.info(`--ci ${provider}: set CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID as ${spec.secretsHint} to enable deploys.`);
+      logger.info(
+        `--ci ${provider}: run \`pnpm install\` and commit pnpm-lock.yaml before pushing — the pipeline runs \`pnpm install --frozen-lockfile\`.`
+      );
     }
     return result;
   } catch (error) {
@@ -271,26 +287,468 @@ const patchViteConfig = (source) => {
   return { changed: true, code: ms.toString() };
 };
 
+const emitStep = async (type, message, answer) => {
+  if (isInteractive()) {
+    await tuiStep(BADGES[type], message, answer);
+    return;
+  }
+  process.stdout.write("\n");
+  if (answer === void 0 || answer === "") {
+    logStep(type, message);
+    return;
+  }
+  const dimmed = answer.split("\n").map((line) => paintAnswer(line)).join("\n");
+  logStep(type, `${message}
+${dimmed}`);
+};
+const emitMascot = async (logger) => {
+  if (isInteractive()) {
+    await tuiMascot();
+    return;
+  }
+  logger.info(`
+${LUNA_ART}
+${LUNA_NAME}: ${LUNA_SIGNOFF}`);
+};
+
 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 STACK_FEATURE_VALUES = STACK_FEATURE_OPTIONS.map((option) => option.value);
+const featureItem = (feature) => feature === "email" ? EMAIL_ITEM : feature;
+const parseFeatureList = (raw, warn) => {
+  const features = [];
+  for (const part of raw.split(",").map((entry) => entry.trim()).filter(Boolean)) {
+    if (STACK_FEATURE_VALUES.includes(part)) {
+      if (!features.includes(part)) {
+        features.push(part);
+      }
+    } else {
+      warn(`init: unknown --add feature "${part}" — expected ${STACK_FEATURE_VALUES.join(" | ")}; skipping.`);
+    }
+  }
+  return features;
+};
+const collectAuthFeature = async (deps) => {
+  const provider = await promptAuthProvider(deps.select);
+  const databaseName = await promptDatabaseName(deps.text, deps.projectName);
+  return { label: "auth", names: [provider], transformManifest: (manifest) => withAuthDatabaseName(manifest, databaseName) };
+};
+const collectEmailFeature = async (deps) => {
+  const answer = await deps.text(MAIL_DESTINATION_PROMPT, { placeholder: "you@yourdomain.com" });
+  const destination = resolveTypedDestination(answer, (message) => {
+    deps.logger.warn(message);
+  });
+  return {
+    label: "email",
+    names: [EMAIL_ITEM],
+    transformManifest: destination === void 0 ? void 0 : (manifest) => withMailDestination(manifest, destination)
+  };
+};
+const collectStorageFeature = async (deps) => {
+  const bucketName = await promptBucketName(deps.text, deps.projectName);
+  return { label: "storage", names: ["storage"], transformManifest: (manifest) => withStorageBucketName(manifest, bucketName) };
+};
+const FEATURE_COLLECTORS = {
+  auth: collectAuthFeature,
+  email: collectEmailFeature,
+  storage: collectStorageFeature
+};
 const offerRegistryExtras = async (deps) => {
+  if (deps.preselected !== void 0 && deps.preselected.length > 0) {
+    await deps.applyAll(
+      deps.preselected.map((feature) => {
+        return { label: feature, names: [featureItem(feature)] };
+      })
+    );
+    return;
+  }
   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: [] });
+  if (picked.length === 0) {
+    return;
+  }
+  const plans = [];
   for (const feature of picked) {
-    if (feature === "auth") {
-      const provider = await promptAuthProvider(deps.select);
-      await deps.apply([provider]);
-    } else {
-      await deps.apply([EMAIL_ITEM]);
+    const collect = FEATURE_COLLECTORS[feature];
+    plans.push(collect ? await collect(deps) : { label: feature, names: [feature] });
+  }
+  await deps.applyAll(plans);
+};
+
+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", ".env", ".env.*", "!.env.example", ".lunora/", ".lunora-cache", "lunora/_generated"];
+const ENV_EXAMPLE = `# Lunora endpoint for the browser client.
+# Vite statically replaces \`import.meta.env.VITE_LUNORA_URL\` at \`vite dev\` / build.
+# Leave it unset to use the page origin; set it to point at a deployed Worker:
+#
+# VITE_LUNORA_URL=https://my-app.example.workers.dev
+`;
+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);
+  writeFile(target, ".env.example", ENV_EXAMPLE, 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 ADJECTIVES = [
+  "lunar",
+  "silver",
+  "silent",
+  "waning",
+  "waxing",
+  "crescent",
+  "cosmic",
+  "stellar",
+  "orbital",
+  "gibbous",
+  "twilight",
+  "midnight",
+  "shimmering",
+  "drifting",
+  "weightless"
+];
+const NOUNS = [
+  "moon",
+  "tide",
+  "crater",
+  "comet",
+  "eclipse",
+  "halo",
+  "orbit",
+  "nebula",
+  "voyager",
+  "lander",
+  "rover",
+  "beacon",
+  "harbor",
+  "meadow",
+  "fox"
+];
+const pick = (items) => (
+  // eslint-disable-next-line sonarjs/pseudo-random -- cosmetic default project name, not a security decision.
+  items[Math.floor(Math.random() * items.length)]
+);
+const generateProjectName = () => `${pick(ADJECTIVES)}-${pick(NOUNS)}`;
+
+const isOnline = async () => dns.lookup("github.com").then(
+  () => true,
+  () => false
+);
+const GITHUB_SOURCE = /^(?:gh|github):([^/]+)\/([^#/]+)(?:\/[^#]*)?(?:#(.+))?$/;
+const parseGitHubSource = (source) => {
+  const match = GITHUB_SOURCE.exec(source);
+  if (match === null) {
+    return void 0;
+  }
+  const [, owner, repo, ref] = match;
+  if (owner === void 0 || repo === void 0) {
+    return void 0;
+  }
+  return { owner, ref: ref ?? "HEAD", repo };
+};
+const templateRefExists = async (source) => {
+  const parsed = parseGitHubSource(source);
+  if (parsed === void 0) {
+    return void 0;
+  }
+  const url = `https://codeload.github.com/${parsed.owner}/${parsed.repo}/tar.gz/${parsed.ref}`;
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    if (response.status === 404) {
+      return false;
     }
+    return response.ok ? true : void 0;
+  } catch {
+    return void 0;
   }
 };
+const verifyRemoteTemplate = async (params) => {
+  if (params.isLocal) {
+    return true;
+  }
+  const isGitHubBacked = params.source === void 0 || parseGitHubSource(params.source) !== void 0;
+  if (!isGitHubBacked) {
+    return true;
+  }
+  if (!await isOnline()) {
+    params.logger.error("you appear to be offline — connect to the internet and try again, or scaffold from a local template with `--from <dir>`.");
+    return false;
+  }
+  if (params.source !== void 0 && await templateRefExists(params.source) === false) {
+    params.logger.error(`template source not found: ${params.source} — double-check --ref / --source, or browse the templates at https://lunora.sh/docs.`);
+    return false;
+  }
+  return true;
+};
 
+const COPY = {
+  extras: "Let's finish setting up your app.",
+  framework: "Which framework should we launch?",
+  git: "Initialize a new git repository? (optional)",
+  install: "Install dependencies now?",
+  name: "Where should we land your project?",
+  nextHeader: "Liftoff confirmed — explore your project!",
+  packageManager: "Which package manager?"
+};
 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";
@@ -324,32 +782,6 @@ export const send = mutation
     });
 `;
 const DEFAULT_SOURCE_BASE = "gh:anolilab/lunora/templates";
-const DEFAULT_SOURCE_REF_FALLBACK = "alpha";
-const resolveCliVersion = () => {
-  try {
-    let directory = dirname$1(fileURLToPath(import.meta.url));
-    for (let index = 0; index < 5; index += 1) {
-      const candidate = join$1(directory, "package.json");
-      if (existsSync(candidate)) {
-        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-        if (parsed.name === "@lunora/cli" && typeof parsed.version === "string") {
-          return parsed.version;
-        }
-      }
-      const parent = dirname$1(directory);
-      if (parent === directory) {
-        break;
-      }
-      directory = parent;
-    }
-  } catch {
-  }
-  return "0.0.0";
-};
-const resolveDefaultSourceRef = () => {
-  const version = resolveCliVersion();
-  return version === "0.0.0" ? DEFAULT_SOURCE_REF_FALLBACK : `v${version}`;
-};
 const isTextFile = (filePath) => {
   const lastDot = filePath.lastIndexOf(".");
   if (lastDot === -1) {
@@ -358,6 +790,26 @@ const isTextFile = (filePath) => {
   return TEXT_EXTENSIONS.has(filePath.slice(lastDot));
 };
 const substitute = (content, name) => content.replaceAll("{{name}}", name);
+const isLunoraDep = (name) => name === "lunorash" || name.startsWith("@lunora/");
+const stampLunoraDeps = (packageJsonText, distTag) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(packageJsonText);
+  } catch {
+    return packageJsonText;
+  }
+  let text = packageJsonText;
+  for (const section of ["dependencies", "devDependencies"]) {
+    for (const name of Object.keys(parsed[section] ?? {})) {
+      if (!isLunoraDep(name)) {
+        continue;
+      }
+      const edits = modify(text, [section, name], distTag, { formattingOptions: { insertSpaces: true, tabSize: 4 } });
+      text = applyEdits(text, edits);
+    }
+  }
+  return text;
+};
 const collectFiles = (directory) => {
   const out = [];
   for (const entry of walkSync(directory, { includeDirs: false, includeFiles: true })) {
@@ -368,12 +820,16 @@ const collectFiles = (directory) => {
 const copyTemplate = (sourceDirectory, target, name) => {
   const files = collectFiles(sourceDirectory);
   const written = [];
+  const distTag = resolveDistTag();
   for (const source of files) {
     const relativePath = relative(sourceDirectory, source);
     const destination = join$1(target, relativePath);
     mkdirSync(dirname$1(destination), { recursive: true });
     const raw = readFileSync(source);
-    const text = isTextFile(source) ? substitute(raw.toString("utf8"), name) : void 0;
+    let text = isTextFile(source) ? substitute(raw.toString("utf8"), name) : void 0;
+    if (text !== void 0 && basename(source) === "package.json") {
+      text = stampLunoraDeps(text, distTag);
+    }
     if (text === void 0) {
       writeFileSync(destination, raw);
     } else {
@@ -383,11 +839,11 @@ const copyTemplate = (sourceDirectory, target, name) => {
   }
   return written;
 };
-const resolveTemplateSource = (templateType, source) => {
+const resolveTemplateSource = (templateType, source, ref) => {
   if (source !== void 0 && source.length > 0) {
     return source;
   }
-  return `${DEFAULT_SOURCE_BASE}/${templateType}#${resolveDefaultSourceRef()}`;
+  return `${DEFAULT_SOURCE_BASE}/${templateType}#${resolveSourceRef(ref)}`;
 };
 const isSafeSource = (source) => {
   if (source.includes("..")) {
@@ -395,12 +851,143 @@ const isSafeSource = (source) => {
   }
   return source.startsWith("gh:") || source.startsWith("github:") || source.startsWith("https://");
 };
-const logScaffoldSuccess = (logger, written, target, name) => {
+const logWould = (logger, action) => {
+  logger.info(`[dry-run] would ${action}`);
+};
+const logScaffoldSuccess = (logger, written, target) => {
+  if (isInteractive()) {
+    process.stdout.write("\n");
+  }
   logger.success(`scaffolded ${String(written.length)} files into ${target}`);
-  logger.info("next steps:");
-  logger.info(`  cd ${name}`);
-  logger.info("  pnpm install");
-  logger.info("  pnpm dev");
+};
+const runScriptCommand = (manager, script) => {
+  if (manager === "npm") {
+    return `npm run ${script}`;
+  }
+  if (manager === "bun") {
+    return `bun run ${script}`;
+  }
+  return `${manager} ${script}`;
+};
+const isInsideMonorepo = (startDirectory) => {
+  let directory = resolve(startDirectory);
+  for (; ; ) {
+    if (existsSync(join$1(directory, "pnpm-workspace.yaml"))) {
+      return true;
+    }
+    const packagePath = join$1(directory, "package.json");
+    if (existsSync(packagePath)) {
+      try {
+        const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+        if (parsed.workspaces !== void 0) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname$1(directory);
+    if (parent === directory) {
+      return false;
+    }
+    directory = parent;
+  }
+};
+const isInsideGitRepo = (startDirectory) => {
+  let directory = resolve(startDirectory);
+  for (; ; ) {
+    if (existsSync(join$1(directory, ".git"))) {
+      return true;
+    }
+    const parent = dirname$1(directory);
+    if (parent === directory) {
+      return false;
+    }
+    directory = parent;
+  }
+};
+const maybeOfferGit = async (options, target) => {
+  if (options.yes === true || !isInteractive() || isInsideGitRepo(dirname$1(target))) {
+    return;
+  }
+  if (!await tuiConfirm(COPY.git, { badge: BADGES.git, defaultYes: false })) {
+    await tuiInfo("Sounds good! You can always run git init manually.");
+    return;
+  }
+  if (options.dryRun === true) {
+    logWould(options.logger, "initialize a git repository");
+    return;
+  }
+  const spawner = options.spawner ?? defaultSpawner;
+  const result = await withTuiSpinner("Initializing a git repository…", () => spawner({ args: ["init"], command: "git", cwd: target }));
+  if (result.code === 0) {
+    await emitStep("git", "Initialized an empty git repository.");
+  } else {
+    options.logger.warn("`git init` failed — initialize it yourself later with `git init`.");
+  }
+};
+const printNextSteps = async (name, installed, insideMonorepo) => {
+  const manager = installed ?? "pnpm";
+  const steps = [{ code: `cd ./${name}`, lead: "Enter your project directory using" }];
+  if (installed === void 0) {
+    steps.push({ code: `${manager} install`, lead: "Install dependencies with", tail: insideMonorepo ? " from the workspace root" : void 0 });
+  }
+  steps.push(
+    { code: runScriptCommand(manager, "dev"), lead: "Run", tail: " to start the dev server." },
+    { code: "lunora add", lead: "Add features like auth or storage using" }
+  );
+  const help = [
+    { code: "https://lunora.sh/docs", lead: "Read the docs at" },
+    { code: "https://lunora.sh/chat", lead: "Stuck? Join the chat at" }
+  ];
+  if (isInteractive()) {
+    await tuiNextSteps(BADGES.next, COPY.nextHeader, steps, help);
+    return;
+  }
+  const lines = steps.map((step) => `${step.lead} ${step.code}${step.tail ?? ""}`);
+  lines.push("", ...help.map((line) => `${line.lead} ${line.code}${line.tail ?? ""}`));
+  await emitStep("next", COPY.nextHeader, lines.join("\n"));
+};
+const offerInstallIsInteractive = (options) => options.yes !== true && (options.installPrompt !== void 0 || isInteractive());
+const maybeOfferInstall = async (options, target) => {
+  if (!offerInstallIsInteractive(options)) {
+    return void 0;
+  }
+  if (isInsideMonorepo(dirname$1(target))) {
+    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(COPY.install, { badge: BADGES.deps, defaultYes: true }));
+  if (!await confirm()) {
+    await tuiInfo("No problem! Remember to install dependencies after setup.");
+    return void 0;
+  }
+  let manager = defaultManager;
+  if (managers.length > 1) {
+    manager = options.installPrompt ? await options.installPrompt.selectManager(managers) : await tuiSelect(
+      COPY.packageManager,
+      managers.map((candidate) => {
+        return { label: candidate, value: candidate };
+      }),
+      { badge: BADGES.deps, default: defaultManager }
+    ) ?? defaultManager;
+  }
+  if (options.dryRun === true) {
+    logWould(options.logger, `install dependencies with ${manager}`);
+    return void 0;
+  }
+  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;
+  }
+  await emitStep("deps", `Dependencies installed with ${manager}.`);
+  return manager;
 };
 const scaffoldFromLocal = (fromRoot, templateType, target, name, logger) => {
   const templateDirectory = join$1(fromRoot, templateType);
@@ -409,32 +996,54 @@ 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 (source, templateType, target, name, logger) => {
+const scaffoldFromRemote = async (options) => {
+  const { logger, name, ref, source, target, templateType } = options;
   const stagingRoot = mkdtempSync(join$1(tmpdir(), "lunora-init-fetch-"));
   const stagingDirectory = join$1(stagingRoot, "template");
   try {
-    const remote = resolveTemplateSource(templateType, source);
-    logger.info(`fetching template from ${remote}`);
-    const downloaded = await downloadTemplate(remote, {
-      cwd: stagingRoot,
-      dir: stagingDirectory,
-      force: true,
-      install: false,
-      silent: true
-    });
+    const remote = resolveTemplateSource(templateType, source, ref);
+    let downloaded;
+    let written = [];
+    await tuiTasks(
+      [
+        {
+          label: `${templateType} template fetched`,
+          run: async () => {
+            downloaded = await downloadTemplate(remote, {
+              cwd: stagingRoot,
+              dir: stagingDirectory,
+              force: true,
+              install: false,
+              silent: true
+            });
+          }
+        },
+        {
+          label: `files copied into ${name}/`,
+          run: () => {
+            written = copyTemplate(stagingDirectory, target, name);
+            return Promise.resolve();
+          }
+        }
+      ],
+      { end: "Project initialized!", start: "Project initializing…" }
+    );
     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))`);
+    if (isInteractive()) {
+      process.stdout.write("\n");
     }
-    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 ?? remote} (${String(staged.length)} files)`
+    );
+    logScaffoldSuccess(logger, written, target);
     return { code: 0, files: written, target };
   } catch (error) {
+    if (error instanceof PromptCancelledError) {
+      throw error;
+    }
     const message = error instanceof Error ? error.message : String(error);
     logger.error(`failed to download template: ${message}`);
     return { code: 1, files: [], target };
@@ -442,6 +1051,65 @@ const scaffoldFromRemote = async (source, templateType, target, name, logger) =>
     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 {
+    let localBase;
+    if (overlayBaseFrom !== void 0) {
+      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 };
+      }
+    }
+    const copyBase = async () => {
+      if (localBase !== void 0) {
+        cpSync(localBase, target, { recursive: true });
+        return;
+      }
+      const stagingDirectory = join$1(stagingRoot, "base");
+      const remote = `github:vitejs/vite/packages/create-vite/template-${adapter.createViteTemplate}#main`;
+      await downloadTemplate(remote, { cwd: stagingRoot, dir: stagingDirectory, force: true, install: false, silent: true });
+      renameCreateViteDotfiles(stagingDirectory);
+      cpSync(stagingDirectory, target, { recursive: true });
+    };
+    let written = [];
+    await tuiTasks(
+      [
+        { label: `create-vite (${adapter.label}) base ready`, run: copyBase },
+        {
+          label: `Lunora overlay applied (${adapter.label})`,
+          run: () => {
+            written = applyLunoraOverlay({ adapter, distTag: resolveDistTag(), logger, name, target });
+            return Promise.resolve();
+          }
+        }
+      ],
+      { end: "Project initialized!", start: "Project initializing…" }
+    );
+    logScaffoldSuccess(logger, written, target);
+    return { code: 0, files: [...collectFiles(target)], target };
+  } catch (error) {
+    if (error instanceof PromptCancelledError) {
+      throw 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 {
@@ -559,68 +1227,243 @@ const runInPlaceInit = (cwd, logger) => {
 const offerIsInteractive = (options) => options.yes !== true && (options.prompt !== void 0 || (options.interactive ?? isInteractive()));
 const maybeOfferExtras = async (options, projectDirectory) => {
   const interactive = offerIsInteractive(options);
-  const apply = async (names) => {
-    const result = await runAddCommand({
-      allowUnsafeSource: options.allowUnsafeSource,
-      cwd: projectDirectory,
-      from: options.registryFrom,
-      logger: options.logger,
-      names: [...names],
-      source: options.registrySource,
-      yes: true
+  const preselected = options.add === void 0 ? [] : parseFeatureList(options.add, (message) => {
+    options.logger.warn(message);
+  });
+  const applyAll = async (plans) => {
+    if (plans.length === 0) {
+      return true;
+    }
+    if (options.dryRun === true) {
+      logWould(options.logger, `add ${plans.map((plan) => plan.label).join(", ")}`);
+      return true;
+    }
+    const applyLogger = isInteractive() ? {
+      error: (message) => {
+        options.logger.error(message);
+      },
+      info: () => {
+      },
+      success: () => {
+      },
+      warn: (message) => {
+        options.logger.warn(message);
+      }
+    } : options.logger;
+    const steps = plans.map((plan) => {
+      return {
+        running: `adding ${plan.label}…`,
+        task: () => runAddCommand({
+          allowUnsafeSource: options.allowUnsafeSource,
+          cwd: projectDirectory,
+          from: options.registryFrom,
+          logger: applyLogger,
+          names: [...plan.names],
+          ref: options.ref,
+          source: options.registrySource,
+          transformManifest: plan.transformManifest,
+          yes: true
+        })
+      };
     });
-    return result.code === 0;
+    const done = `added ${plans.map((plan) => plan.label).join(", ")}`;
+    const results = await withTuiBadgeProgress(BADGES.add, steps, done);
+    return results.every((result) => result.code === 0);
   };
-  await offerRegistryExtras({
-    apply,
+  const deps = {
+    applyAll,
     interactive,
     logger: options.logger,
-    multiSelect: options.prompt?.multiSelect ?? ((message, choices, settings) => promptMultiSelect(message, choices, settings)),
-    select: options.prompt?.select ?? ((message, choices, settings) => promptSelect(message, choices, settings))
-  });
+    multiSelect: options.prompt?.multiSelect ?? ((message, choices, settings) => tuiMultiSelect(message, choices, { ...settings, badge: BADGES.add })),
+    preselected: preselected.length > 0 ? preselected : void 0,
+    projectName: basename(projectDirectory),
+    select: options.prompt?.select ?? ((message, choices, settings) => tuiSelect(message, choices, { ...settings, badge: BADGES.add })),
+    text: options.prompt?.text ?? ((message, settings) => tuiText(message, { ...settings, badge: BADGES.add }))
+  };
+  if (preselected.length > 0) {
+    await offerRegistryExtras(deps);
+    return;
+  }
+  if (isInteractive()) {
+    await tuiHeadline(COPY.extras);
+  }
+  await offerRegistryExtras(deps);
 };
-const scaffoldNewProject = async (options, cwd) => {
-  const name = options.name ?? "lunora-app";
-  const templateType = options.templateType ?? "vite";
+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(COPY.framework, FRAMEWORK_CHOICES, { badge: BADGES.tmpl, 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 scaffoldOverlayPath = async (options, framework, name, target) => {
+  if (!isOverlayFramework(framework)) {
+    options.logger.error(`init: unknown framework "${framework}". Supported overlays: ${Object.keys(ADAPTERS).join(", ")}.`);
+    return { code: 1, files: [], target };
+  }
+  if (!await verifyRemoteTemplate({ isLocal: options.overlayBaseFrom !== void 0, logger: options.logger })) {
+    return { code: 1, files: [], target };
+  }
+  mkdirSync(target, { recursive: true });
+  return scaffoldViteOverlay({ framework, logger: options.logger, name, overlayBaseFrom: options.overlayBaseFrom, target });
+};
+const scaffoldTemplatePath = async (options, templateType, name, target) => {
   if (templateType === "next") {
-    options.logger.warn('template "next" is not yet available — re-run with `-t vite` or `-t standalone`.');
+    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);
+  }
+  if (options.source !== void 0 && options.source.length > 0 && !options.allowUnsafeSource && !isSafeSource(options.source)) {
+    options.logger.error(
+      `init: refusing --source ${options.source} — only gh:, github:, or https:// sources are allowed (and may not contain ".."). Re-run with --allow-unsafe-source if you really want this.`
+    );
+    return { code: 1, files: [], target };
+  }
+  if (!await verifyRemoteTemplate({ isLocal: false, logger: options.logger, source: resolveTemplateSource(templateType, options.source, options.ref) })) {
+    return { code: 1, files: [], target };
+  }
+  return scaffoldFromRemote({ logger: options.logger, name, ref: options.ref, source: options.source, target, templateType });
+};
+const scaffoldNewProject = async (options, cwd, recordTarget) => {
+  await tuiMoonrise("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 suggestedName = generateProjectName();
+  const name = options.name ?? await tuiText(COPY.name, { badge: BADGES.dir, default: suggestedName, placeholder: suggestedName });
+  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: "" };
   }
   const target = resolve(cwd, name);
-  if (existsSync(target)) {
+  const targetPreExisted = existsSync(target);
+  if (targetPreExisted) {
     const entries = readdirSync(target);
     if (entries.length > 0) {
       options.logger.error(`target directory not empty: ${target}`);
       return { code: 1, files: [], target };
     }
   }
-  if (options.from !== void 0) {
-    return scaffoldFromLocal(options.from, templateType, target, name, options.logger);
+  if (options.dryRun === true) {
+    const what = choice.kind === "overlay" ? `the ${choice.framework} create-vite overlay` : `the ${choice.templateType} template`;
+    logWould(options.logger, `scaffold ${what} into ${target}`);
+    return { code: 0, files: [], target };
   }
-  if (options.source !== void 0 && options.source.length > 0 && !options.allowUnsafeSource && !isSafeSource(options.source)) {
-    options.logger.error(
-      `init: refusing --source ${options.source} — only gh:, github:, or https:// sources are allowed (and may not contain ".."). Re-run with --allow-unsafe-source if you really want this.`
-    );
-    return { code: 1, files: [], target };
+  recordTarget(target, targetPreExisted);
+  return choice.kind === "overlay" ? scaffoldOverlayPath(options, choice.framework, name, target) : scaffoldTemplatePath(options, choice.templateType, name, target);
+};
+const resetScaffoldOnCancel = (cleanup, logger) => {
+  const { target, targetPreExisted } = cleanup;
+  if (target === void 0 || !existsSync(target)) {
+    return;
+  }
+  if (targetPreExisted === true) {
+    for (const entry of readdirSync(target)) {
+      rmSync(join$1(target, entry), { force: true, recursive: true });
+    }
+  } else {
+    rmSync(target, { force: true, recursive: true });
   }
-  return scaffoldFromRemote(options.source, templateType, target, name, options.logger);
+  logger.info(`removed the partially-created project at ${target}`);
+};
+const runScaffoldStep = async (options, cwd, recordTarget) => {
+  if (options.inPlace !== true) {
+    return scaffoldNewProject(options, cwd, recordTarget);
+  }
+  if (options.dryRun === true) {
+    logWould(options.logger, `configure Lunora into ${cwd}`);
+    return { code: 0, files: [], target: cwd };
+  }
+  return runInPlaceInit(cwd, options.logger);
+};
+const runPostScaffold = async (options, result, cwd) => {
+  await maybeOfferExtras(options, result.target);
+  const installedManager = options.inPlace === true ? void 0 : await maybeOfferInstall(options, result.target);
+  if (options.inPlace !== true) {
+    await maybeOfferGit(options, result.target);
+    await printNextSteps(basename(result.target), installedManager, isInsideMonorepo(cwd));
+    await emitMascot(options.logger);
+  }
+};
+const scaffoldCiPipeline = (options, result, cwd) => {
+  if (result.code !== 0 || options.ci === void 0) {
+    return;
+  }
+  if (options.dryRun === true) {
+    logWould(options.logger, `scaffold a ${options.ci} CI deploy pipeline`);
+    return;
+  }
+  scaffoldCiWorkflow(options.inPlace === true ? cwd : result.target, options.ci, options.logger);
 };
 const runInitCommand = async (options) => {
   const cwd = options.cwd ?? process.cwd();
-  const result = options.inPlace === true ? runInPlaceInit(cwd, options.logger) : await scaffoldNewProject(options, cwd);
-  if (result.code === 0 && result.target !== "") {
-    await maybeOfferExtras(options, result.target);
-  }
-  if (result.code === 0 && options.ci !== void 0) {
-    scaffoldCiWorkflow(options.inPlace === true ? cwd : result.target, options.ci, options.logger);
+  const cleanup = {};
+  let result;
+  try {
+    result = await runScaffoldStep(options, cwd, (target, preExisted) => {
+      cleanup.target = target;
+      cleanup.targetPreExisted = preExisted;
+    });
+    if (result.code === 0 && result.target !== "") {
+      cleanup.target = void 0;
+      await runPostScaffold(options, result, cwd);
+    }
+  } catch (error) {
+    if (error instanceof PromptCancelledError) {
+      resetScaffoldOnCancel(cleanup, options.logger);
+      process.stdout.write("\n  ✖  Setup cancelled — run `lunora init` again whenever you're ready. 🌙\n");
+      return { code: 130, files: [], target: "" };
+    }
+    throw error;
   }
+  scaffoldCiPipeline(options, result, cwd);
   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";
+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;
@@ -632,21 +1475,24 @@ const resolveCiProvider = (raw, logger) => {
   return void 0;
 };
 const execute = defineHandler(({ argument, cwd, logger, options }) => {
-  const templateRaw = options.template ?? "vite";
-  const template = isTemplate(templateRaw) ? templateRaw : "vite";
+  const templateType = options.template !== void 0 && isTemplate(options.template) ? options.template : void 0;
   return runInitCommand({
+    add: options.add,
     allowUnsafeSource: options.allowUnsafeSource === true,
     cwd,
     ci: resolveCiProvider(options.ci, logger),
+    dryRun: options.dryRun === true,
     from: options.from,
     inPlace: options.here === true,
     interactive: options.interactive === true ? true : void 0,
     logger,
     name: argument[0],
+    ref: options.ref,
     source: options.source,
-    templateType: template,
+    templateType,
+    vite: options.vite,
     yes: options.yes === true
   });
 });
 
-export { execute, isTemplate, runInitCommand };
+export { execute, isTemplate, resolveTemplateSource, runInitCommand };