@lunora/cli 0.0.0 → 1.0.0-alpha.10

package/dist/packem_chunks/runInitCommand.mjs

@@ -0,0 +1,1498 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, mkdtempSync, cpSync, renameSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { detectFramework as detectFramework$1, isInteractive, LUNA_ART, LUNA_NAME, LUNA_SIGNOFF, paintAnswer, BADGES } from '@lunora/config';
+import { walkSync } from '@visulima/fs';
+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-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 { 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
+
+on:
+  push:
+    branches: [main]
+  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
+env:
+  CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+  CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+jobs:
+  # Production deploy on push to the default branch.
+  deploy:
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      # Codegen + wrangler validation gate (no deploy) — fails fast on drift.
+      - run: pnpm exec lunora prepare
+      - run: pnpm exec lunora deploy
+
+  # Preview version on every pull request — uploads a versioned preview URL;
+  # production traffic is untouched.
+  preview:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm exec lunora deploy --preview
+`;
+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
+.lunora_base:
+  image: node:22
+  stage: deploy
+  before_script:
+    - corepack enable
+    - pnpm install --frozen-lockfile
+
+# Production deploy on the default branch.
+deploy:
+  extends: .lunora_base
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  script:
+    # Codegen + wrangler validation gate (no deploy) — fails fast on drift.
+    - pnpm exec lunora prepare
+    - pnpm exec lunora deploy
+
+# Preview version on every merge request (versioned preview URL; production
+# traffic is untouched).
+preview:
+  extends: .lunora_base
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+  script:
+    - pnpm exec lunora deploy --preview
+`;
+const WORKFLOWS = {
+  github: {
+    content: GITHUB_CONTENT,
+    file: join(".github", "workflows", "deploy.yml"),
+    secretsHint: "repository secrets (Settings → Secrets and variables → Actions)"
+  },
+  gitlab: {
+    content: GITLAB_CONTENT,
+    file: ".gitlab-ci.yml",
+    secretsHint: "masked CI/CD variables (Settings → CI/CD → Variables)"
+  }
+};
+const isCiProvider = (value) => value === "github" || value === "gitlab";
+const writeCiWorkflow = (projectRoot, provider, options = {}) => {
+  const spec = WORKFLOWS[provider];
+  const path = join(projectRoot, spec.file);
+  if (existsSync(path) && options.overwrite !== true) {
+    return { path, skipped: true, written: false };
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, spec.content, "utf8");
+  return { path, skipped: false, written: true };
+};
+const scaffoldCiWorkflow = (projectRoot, provider, logger, options = {}) => {
+  const spec = WORKFLOWS[provider];
+  try {
+    const result = writeCiWorkflow(projectRoot, provider, options);
+    if (result.skipped) {
+      logger.info(`--ci ${provider}: ${spec.file} already exists — left unchanged (re-run with overwrite to replace).`);
+    } 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) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`--ci ${provider}: could not write ${spec.file} (${message})`);
+    return { path: join(projectRoot, spec.file), skipped: false, written: false };
+  }
+};
+
+const ADAPTER_BY_FRAMEWORK = {
+  astro: "@lunora/react",
+  none: "@lunora/react",
+  nuxt: "@lunora/vue",
+  "react-router": "@lunora/react",
+  "solid-start": "@lunora/solid",
+  sveltekit: "@lunora/svelte",
+  "tanstack-start": "@lunora/react",
+  "tanstack-start-solid": "@lunora/solid"
+};
+const detectFramework = (root) => {
+  const base = detectFramework$1(root);
+  return { ...base, adapter: ADAPTER_BY_FRAMEWORK[base.framework] };
+};
+
+const LUNORA_CALL = "lunora()";
+const LUNORA_IMPORT = 'import { lunora } from "@lunora/vite";';
+const LUNORA_CALL_RE = /\blunora\s*\(/u;
+const LUNORA_VITE_DOUBLE = '"@lunora/vite"';
+const LUNORA_VITE_SINGLE = "'@lunora/vite'";
+const findDefineConfigObject = (sf) => {
+  for (const statement of sf.getStatements()) {
+    if (statement.getKind() !== SyntaxKind.ExportAssignment) {
+      continue;
+    }
+    const expr = statement.asKindOrThrow(SyntaxKind.ExportAssignment).getExpression();
+    if (expr.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const call = expr.asKindOrThrow(SyntaxKind.CallExpression);
+    if (call.getExpression().getText() !== "defineConfig") {
+      continue;
+    }
+    const argument = call.getArguments()[0];
+    if (argument?.getKind() === SyntaxKind.ObjectLiteralExpression) {
+      return argument.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    }
+  }
+  return void 0;
+};
+const findPlainExportObject = (sf) => {
+  for (const statement of sf.getStatements()) {
+    if (statement.getKind() !== SyntaxKind.ExportAssignment) {
+      continue;
+    }
+    const expr = statement.asKindOrThrow(SyntaxKind.ExportAssignment).getExpression();
+    if (expr.getKind() === SyntaxKind.ObjectLiteralExpression) {
+      return expr.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    }
+  }
+  return void 0;
+};
+const findConfigObject = (sourceText) => {
+  const project = new Project({
+    compilerOptions: { allowJs: true },
+    useInMemoryFileSystem: true
+  });
+  const sf = project.createSourceFile("vite.config.ts", sourceText, { overwrite: true });
+  return findDefineConfigObject(sf) ?? findPlainExportObject(sf);
+};
+const importInsertPosition = (sourceText) => {
+  const project = new Project({
+    compilerOptions: { allowJs: true },
+    useInMemoryFileSystem: true
+  });
+  const sf = project.createSourceFile("vite.config.ts", sourceText, { overwrite: true });
+  const imports = sf.getImportDeclarations();
+  if (imports.length === 0) {
+    return 0;
+  }
+  const last = imports[imports.length - 1];
+  if (last === void 0) {
+    return 0;
+  }
+  return last.getEnd();
+};
+const addImport = (ms, source) => {
+  const insertAt = importInsertPosition(source);
+  if (insertAt === 0) {
+    ms.prepend(`${LUNORA_IMPORT}
+`);
+  } else {
+    ms.appendLeft(insertAt, `
+${LUNORA_IMPORT}`);
+  }
+};
+const patchPluginsArray = (ms, configObject) => {
+  const pluginsProp = configObject.getProperty("plugins");
+  if (pluginsProp === void 0) {
+    const properties = configObject.getProperties();
+    const openBrace = configObject.getStart() + 1;
+    if (properties.length === 0) {
+      ms.appendLeft(openBrace, ` plugins: [${LUNORA_CALL}] `);
+    } else {
+      const firstProp = properties[0];
+      if (firstProp !== void 0) {
+        ms.appendLeft(firstProp.getStart(), `plugins: [${LUNORA_CALL}],
+    `);
+      }
+    }
+    return;
+  }
+  const arrayLit = pluginsProp.getDescendantsOfKind(SyntaxKind.ArrayLiteralExpression)[0];
+  if (arrayLit === void 0) {
+    return;
+  }
+  const elements = arrayLit.getElements();
+  if (elements.length === 0) {
+    ms.appendLeft(arrayLit.getStart() + 1, LUNORA_CALL);
+  } else {
+    const firstElement = elements[0];
+    if (firstElement !== void 0) {
+      ms.appendLeft(firstElement.getStart(), `${LUNORA_CALL}, `);
+    }
+  }
+};
+const patchViteConfig = (source) => {
+  if (LUNORA_CALL_RE.test(source)) {
+    return { changed: false, code: source, reason: "lunora plugin already present" };
+  }
+  const configObject = findConfigObject(source);
+  if (configObject === void 0) {
+    return { changed: false, code: source, reason: "could not locate a Vite config plugins array to patch" };
+  }
+  const ms = new MagicString(source);
+  const alreadyImported = source.includes(LUNORA_VITE_DOUBLE) || source.includes(LUNORA_VITE_SINGLE);
+  if (alreadyImported) {
+    patchPluginsArray(ms, configObject);
+  } else {
+    addImport(ms, source);
+    patchPluginsArray(ms, configObject);
+  }
+  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: "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 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) {
+    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";
+import { lunora } from "@lunora/vite";
+
+export default defineConfig({ plugins: [lunora()] });
+`;
+const SAMPLE_SCHEMA = `import { defineSchema, defineTable, v } from "@lunora/server";
+
+export default defineSchema({
+    messages: defineTable({
+        channelId: v.id("channels"),
+        text: v.string(),
+    })
+        .shardBy("channelId")
+        .index("by_channel", ["channelId"]),
+});
+`;
+const SAMPLE_FUNCTION = `import { mutation, query, v } from "./_generated/server";
+
+export const list = query
+    .input({ channelId: v.id("channels"), limit: v.optional(v.number()) })
+    .query(async ({ args }) => {
+        return { channelId: args.channelId, limit: args.limit ?? 50, messages: [] };
+    });
+
+export const send = mutation
+    .input({ channelId: v.id("channels"), text: v.string() })
+    .mutation(async ({ args }) => {
+        return { channelId: args.channelId, text: args.text };
+    });
+`;
+const DEFAULT_SOURCE_BASE = "gh:anolilab/lunora/templates";
+const isTextFile = (filePath) => {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) {
+    return false;
+  }
+  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 })) {
+    out.push(entry.path);
+  }
+  return out;
+};
+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);
+    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 {
+      writeFileSync(destination, text, "utf8");
+    }
+    written.push(destination);
+  }
+  return written;
+};
+const resolveTemplateSource = (templateType, source, ref) => {
+  if (source !== void 0 && source.length > 0) {
+    return source;
+  }
+  return `${DEFAULT_SOURCE_BASE}/${templateType}#${resolveSourceRef(ref)}`;
+};
+const isSafeSource = (source) => {
+  if (source.includes("..")) {
+    return false;
+  }
+  return source.startsWith("gh:") || source.startsWith("github:") || source.startsWith("https://");
+};
+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}`);
+};
+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);
+  if (!existsSync(templateDirectory)) {
+    logger.error(`template not found in local source: ${templateDirectory}`);
+    return { code: 1, files: [], target };
+  }
+  const written = copyTemplate(templateDirectory, target, name);
+  logScaffoldSuccess(logger, written, target);
+  return { code: 0, files: written, target };
+};
+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, 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 (isInteractive()) {
+      process.stdout.write("\n");
+    }
+    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 };
+  } finally {
+    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 {
+    writeFileSync(target, MINIMAL_VITE_CONFIG, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --in-place: could not write ${target}: ${message}`);
+    return { code: 1, files: [], target: cwd };
+  }
+  logger.success(`created ${target} with lunora() plugin`);
+  return { code: 0, files: [target], target: cwd };
+};
+const patchExistingViteConfig = (viteConfigPath, cwd, logger) => {
+  let source;
+  try {
+    source = readFileSync(viteConfigPath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --in-place: could not read ${viteConfigPath}: ${message}`);
+    return { code: 1, files: [], target: cwd };
+  }
+  const result = patchViteConfig(source);
+  if (!result.changed) {
+    logger.info(`${viteConfigPath}: ${result.reason ?? "no changes needed"}`);
+    return { code: 0, files: [], target: cwd };
+  }
+  try {
+    writeFileSync(viteConfigPath, result.code, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --in-place: could not write ${viteConfigPath}: ${message}`);
+    return { code: 1, files: [], target: cwd };
+  }
+  logger.success(`patched ${viteConfigPath} — added lunora() plugin`);
+  return { code: 0, files: [viteConfigPath], target: cwd };
+};
+const scaffoldLunoraDirectory = (cwd, logger) => {
+  const lunoraDirectory = join$1(cwd, "lunora");
+  const schemaPath = join$1(lunoraDirectory, "schema.ts");
+  if (existsSync(schemaPath)) {
+    logger.info(`lunora/ already present — left ${schemaPath} untouched`);
+    return [];
+  }
+  const written = [];
+  try {
+    mkdirSync(lunoraDirectory, { recursive: true });
+    writeFileSync(schemaPath, SAMPLE_SCHEMA, "utf8");
+    written.push(schemaPath);
+    const functionPath = join$1(lunoraDirectory, "messages.ts");
+    if (!existsSync(functionPath)) {
+      writeFileSync(functionPath, SAMPLE_FUNCTION, "utf8");
+      written.push(functionPath);
+    }
+    logger.success(`scaffolded lunora/ (${String(written.length)} file(s))`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --here: could not scaffold lunora/: ${message}`);
+  }
+  return written;
+};
+const printFrameworkNextSteps = (detection, logger) => {
+  const { adapter, class: frameworkClass, framework } = detection;
+  logger.info("");
+  logger.info(`detected framework: ${framework} (class ${frameworkClass})`);
+  logger.info("next steps:");
+  logger.info(`  1. install the adapter:  pnpm add ${adapter} @lunora/client @lunora/runtime @lunora/server`);
+  logger.info("  2. run codegen:          lunora codegen");
+  if (frameworkClass === "A") {
+    logger.info("  3. compose one worker:   wrap your worker entry with");
+    logger.info("       createWorker({ httpRouter: <your framework SSR handler>, shardDO: ShardDO, ... })");
+    logger.info(`  4. add the provider:     mount the ${adapter} provider in your root layout/route`);
+    logger.info("  5. make a loader live:   preloadQuery() in a loader, usePreloadedQuery() in the component");
+    logger.info("     see https://lunora.sh/docs/frameworks/reactive-loaders");
+  } else if (frameworkClass === "B") {
+    logger.info("  3. inject Lunora:        mount Lunora realtime under /_lunora/* in your server hook");
+    logger.info(`       (${framework} owns its Cloudflare adapter — Lunora composes into its server entry)`);
+    logger.info(`  4. add the provider:     mount the ${adapter} provider in your root layout`);
+    logger.info("  5. read the guide:       https://lunora.sh/docs/frameworks/deploy");
+  } else {
+    logger.info("  3. add the provider:     wrap your app with the LunoraProvider from @lunora/react");
+    logger.info("  4. read the guide:       https://lunora.sh/docs/frameworks/bring-your-framework");
+  }
+  logger.info("");
+};
+const findExistingViteConfig = (cwd) => {
+  for (const candidate of VITE_CONFIG_CANDIDATES) {
+    const full = join$1(cwd, candidate);
+    if (existsSync(full)) {
+      return full;
+    }
+  }
+  return void 0;
+};
+const patchOrCreateViteConfig = (cwd, framework, logger) => {
+  const viteConfigPath = findExistingViteConfig(cwd);
+  if (viteConfigPath === void 0) {
+    if (framework === "sveltekit" || framework === "nuxt" || framework === "astro") {
+      logger.info(`no Vite config found — ${framework} wires Lunora through its server entry (see next steps)`);
+      return { code: 0, files: [], target: cwd };
+    }
+    return createMinimalViteConfig(cwd, logger);
+  }
+  return patchExistingViteConfig(viteConfigPath, cwd, logger);
+};
+const runInPlaceInit = (cwd, logger) => {
+  const detection = detectFramework(cwd);
+  const viteResult = patchOrCreateViteConfig(cwd, detection.framework, logger);
+  if (viteResult.code !== 0) {
+    return viteResult;
+  }
+  const scaffolded = scaffoldLunoraDirectory(cwd, logger);
+  printFrameworkNextSteps(detection, logger);
+  return { code: 0, files: [...viteResult.files, ...scaffolded], target: cwd };
+};
+const offerIsInteractive = (options) => options.yes !== true && (options.prompt !== void 0 || (options.interactive ?? isInteractive()));
+const maybeOfferExtras = async (options, projectDirectory) => {
+  const interactive = offerIsInteractive(options);
+  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
+        })
+      };
+    });
+    const done = `added ${plans.map((plan) => plan.label).join(", ")}`;
+    const results = await withTuiBadgeProgress(BADGES.add, steps, done);
+    return results.every((result) => result.code === 0);
+  };
+  const deps = {
+    applyAll,
+    interactive,
+    logger: options.logger,
+    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 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 `--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);
+  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.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 };
+  }
+  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 });
+  }
+  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 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 === "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;
+  }
+  if (isCiProvider(raw)) {
+    return raw;
+  }
+  logger.warn(`init: unknown --ci "${raw}" — expected github | gitlab; skipping CI scaffold.`);
+  return void 0;
+};
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  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,
+    vite: options.vite,
+    yes: options.yes === true
+  });
+});
+
+export { execute, isTemplate, resolveTemplateSource, runInitCommand };