create-basalt 1.2.2 → 1.3.0

package/dist/chunk-XUW6ZAPV.js

@@ -1,1342 +0,0 @@
-// src/index.ts
-import { mkdir, readdir, writeFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
-
-// src/templates.ts
-var BASALT_VERSION = "^1.0.0";
-var VERSIONS = {};
-var versionOf = (pkg) => VERSIONS[pkg] ?? BASALT_VERSION;
-function packageJson(options) {
-  const dependencies = {
-    "@basaltkit/config": BASALT_VERSION,
-    "@basaltkit/core": BASALT_VERSION,
-    "@basaltkit/env": BASALT_VERSION,
-    "@basaltkit/events": BASALT_VERSION,
-    "@basaltkit/fastify": BASALT_VERSION,
-    "@basaltkit/logger": BASALT_VERSION,
-    zod: "^4.0.0"
-  };
-  if (options.tenancy) dependencies["@basaltkit/tenancy"] = BASALT_VERSION;
-  if (options.auth) dependencies["@basaltkit/auth"] = BASALT_VERSION;
-  if (options.billing) dependencies["@basaltkit/subscriptions"] = BASALT_VERSION;
-  if (options.cli) {
-    dependencies["@basaltkit/cli"] = BASALT_VERSION;
-    dependencies["@basaltkit/prisma"] = BASALT_VERSION;
-  }
-  for (const pkg of Object.keys(dependencies)) {
-    if (pkg.startsWith("@basaltkit/")) dependencies[pkg] = versionOf(pkg);
-  }
-  const devDependencies = {
-    "@basaltkit/testing": versionOf("@basaltkit/testing"),
-    "@types/node": "^22.15.0",
-    "pino-pretty": "^13.0.0",
-    tsx: "^4.19.0",
-    typescript: "^5.8.0",
-    vitest: "^3.1.0"
-  };
-  if (options.cli) {
-    devDependencies["@basaltkit/generator"] = versionOf("@basaltkit/generator");
-  }
-  return `${JSON.stringify(
-    {
-      name: options.name,
-      version: "0.1.0",
-      private: true,
-      type: "module",
-      scripts: {
-        dev: "tsx watch src/server.ts",
-        start: "tsx src/server.ts",
-        test: "vitest run",
-        typecheck: "tsc --noEmit",
-        ...options.cli ? { basalt: "tsx bin/basalt.ts" } : {}
-      },
-      dependencies: Object.fromEntries(Object.entries(dependencies).sort()),
-      devDependencies: Object.fromEntries(Object.entries(devDependencies).sort())
-    },
-    null,
-    2
-  )}
-`;
-}
-function tsconfigJson() {
-  return `${JSON.stringify(
-    {
-      compilerOptions: {
-        target: "ES2022",
-        module: "NodeNext",
-        moduleResolution: "NodeNext",
-        strict: true,
-        noUncheckedIndexedAccess: true,
-        verbatimModuleSyntax: true,
-        skipLibCheck: true,
-        noEmit: true,
-        types: ["node"]
-      },
-      include: ["src", "tests"]
-    },
-    null,
-    2
-  )}
-`;
-}
-function envTs(options) {
-  return `import { defineEnv${options.auth ? ", secret" : ""} } from '@basaltkit/env'
-import { z } from 'zod'
-
-export const env = defineEnv({
-  PORT: z.coerce.number().default(3000),
-  HOST: z.string().default('0.0.0.0'),
-  LOG_LEVEL: z.string().default('info'),
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),${options.auth ? `
-  // Signs JWTs and sessions. secret() is fail-closed: required in production
-  // (no fallback), rejected if it looks like a placeholder. Dev uses devDefault.
-  APP_SECRET: secret({ minLength: 32, devDefault: 'dev-only-insecure-secret-please-change-me' }),` : ""}
-})
-`;
-}
-function envExample(options) {
-  return `PORT=3000
-HOST=0.0.0.0
-LOG_LEVEL=info
-NODE_ENV=development
-${options.auth ? "# Required in production (the app refuses to boot without it).\n# Generate a strong one:  openssl rand -base64 48\n# APP_SECRET=\n" : ""}`;
-}
-function appTs(options) {
-  const imports = [
-    `import { createApp } from '@basaltkit/core'`,
-    `import { configPlugin } from '@basaltkit/config'`,
-    `import { eventsPlugin } from '@basaltkit/events'`,
-    `import { fastifyPlugin, securityPlugin } from '@basaltkit/fastify'`,
-    `import { loggerPlugin } from '@basaltkit/logger'`
-  ];
-  const plugins = [
-    `configPlugin({ app: { name: '${options.name}' } })`,
-    `loggerPlugin({ level: options.logLevel ?? 'info', ...(options.pretty ? { pretty: true } : {}) })`,
-    `eventsPlugin()`,
-    `securityPlugin({
-      // Secure response headers (HSTS, X-Frame-Options, nosniff, \u2026) are on by
-      // default. Turn on rate limiting and a CORS allow-list for production:
-      // rateLimit: { limit: 120, windowMs: 60_000 },
-      // cors: { origin: ['https://app.example.com'], credentials: true },
-    })`
-  ];
-  let routesExpression = "appRoutes";
-  if (options.tenancy) {
-    imports.push(
-      `import { headerResolver, MemoryTenantSource, subdomainResolver, tenancyPlugin } from '@basaltkit/tenancy'`
-    );
-    plugins.push(`tenancyPlugin({
-      // Replace MemoryTenantSource with your database-backed source.
-      source: new MemoryTenantSource().add({ id: 'demo', name: 'Demo Tenant' }),
-      resolvers: [headerResolver(), subdomainResolver({ base: 'localhost' })],
-    })`);
-  }
-  if (options.auth) {
-    imports.push(`import { authPlugin, authRoutes, mfaRoutes, MemoryUserSource } from '@basaltkit/auth'`);
-    imports.push(`import { env } from './env.js'`);
-    plugins.push(`authPlugin({
-      // Replace MemoryUserSource with your database-backed source (e.g.
-      // @basaltkit/auth-sqlite or @basaltkit/auth-prisma). The default in-memory
-      // MFA store is enough for the ready-made TOTP flow below.
-      users: new MemoryUserSource(),
-      secret: env.APP_SECRET,
-    })`);
-    routesExpression = "[...appRoutes, ...authRoutes(), ...mfaRoutes()]";
-  }
-  if (options.billing) {
-    imports.push(`import { definePlans, subscriptionsPlugin } from '@basaltkit/subscriptions'`);
-    plugins.push(`subscriptionsPlugin({
-      plans: definePlans({
-        free: { price: 0, features: { projects: 3 } },
-        pro: { price: { monthly: 29, yearly: 290 }, trial: '14d', features: { projects: 50 } },
-      }),
-      fallbackPlan: 'free',
-    })`);
-  }
-  if (options.cli) {
-    imports.push(`import { commandsPlugin, type CommandDefinition } from '@basaltkit/cli'`);
-    plugins.push(`...(options.commands && options.commands.length > 0 ? [commandsPlugin(options.commands)] : [])`);
-  }
-  plugins.push(`fastifyPlugin({ routes: ${routesExpression} })`);
-  const commandsField = options.cli ? `
-  /** Dev/CLI commands (make:*, ai:*, prisma:sync) \u2014 passed ONLY by bin/basalt.ts. */
-  commands?: CommandDefinition[]` : "";
-  return `${imports.join("\n")}
-import { appRoutes } from './routes.js'
-
-export interface BuildAppOptions {
-  logLevel?: string
-  pretty?: boolean${commandsField}
-}
-
-export function buildApp(options: BuildAppOptions = {}) {
-  return createApp({
-    plugins: [
-      ${plugins.join(",\n      ")},
-    ],
-  })
-}
-`;
-}
-function routesTs(options) {
-  const endpoints = [
-    "'GET /'",
-    "'GET /health'",
-    ...options.auth ? [
-      "'POST /auth/register'",
-      "'POST /auth/login'",
-      "'POST /auth/refresh'",
-      "'POST /auth/logout'",
-      "'GET /auth/me'"
-    ] : []
-  ];
-  return `import { ctx } from '@basaltkit/core'
-import { route } from '@basaltkit/fastify'
-
-export const appRoutes = [
-  // Friendly index so \`GET /\` is never a bare 404 \u2014 lists what the API exposes.
-  route({
-    method: 'GET',
-    url: '/',
-    async handler() {
-      return {
-        name: '${options.name}',
-        status: 'ok',
-        endpoints: [${endpoints.join(", ")}],
-      }
-    },
-  }),
-  route({
-    method: 'GET',
-    url: '/health',
-    async handler() {
-      return { ok: true, requestId: ctx().requestId${options.tenancy ? ", tenant: ctx().tenant?.id ?? null" : ""} }
-    },
-  }),
-]
-`;
-}
-function serverTs() {
-  return `import { FASTIFY } from '@basaltkit/fastify'
-import { buildApp } from './app.js'
-import { env } from './env.js'
-
-const app = await buildApp({
-  logLevel: env.LOG_LEVEL,
-  pretty: env.NODE_ENV === 'development',
-}).boot()
-
-const server = app.container.get(FASTIFY)
-await server.listen({ port: env.PORT, host: env.HOST })
-console.log('ready at http://' + env.HOST + ':' + env.PORT)
-
-for (const signal of ['SIGINT', 'SIGTERM'] as const) {
-  process.once(signal, async () => {
-    await app.shutdown()
-    process.exit(0)
-  })
-}
-`;
-}
-function basaltBin() {
-  return `#!/usr/bin/env node
-import { runCli } from '@basaltkit/cli'
-import { generatorCommands } from '@basaltkit/generator'
-import { prismaSyncCommand } from '@basaltkit/prisma'
-import { buildApp } from '../src/app.js'
-
-// The 'basalt' CLI: boots the app WITH the dev/CLI commands, runs one, shuts down.
-// The dev tools (@basaltkit/generator; add @basaltkit/ai for ai:*) are imported
-// ONLY here \u2014 the runtime server (src/server.ts) never loads them, so the SaaS
-// runs without the codegen/AI layer.
-//   pnpm basalt dev                     \u2014 dev server: route table + watch (--worker for a queue worker)
-//   pnpm basalt list                    \u2014 show available commands
-//   pnpm basalt routes                  \u2014 list registered HTTP routes
-//   pnpm basalt make:resource Project   \u2014 generate a full resource vertical
-//   pnpm basalt make:service Project    \u2014 generate a single artifact (schema/service/\u2026)
-const app = buildApp({
-  logLevel: 'silent',
-  commands: [...generatorCommands(), prismaSyncCommand()],
-})
-process.exit(await runCli({ app }))
-`;
-}
-function appTest(options) {
-  return `import { describe, expect, it } from 'vitest'
-import { FASTIFY } from '@basaltkit/fastify'
-import { buildApp } from '../src/app.js'
-
-describe('app', () => {
-  it('boots and responds on /health', async () => {
-    const app = await buildApp({ logLevel: 'silent' }).boot()
-    const server = app.container.get(FASTIFY)
-
-    const index = await server.inject({ method: 'GET', url: '/' })
-    expect(index.statusCode).toBe(200)
-    expect(index.json().name).toBe('${options.name}')
-
-    const response = await server.inject({ method: 'GET', url: '/health' })
-    expect(response.statusCode).toBe(200)
-    expect(response.json().ok).toBe(true)${options.tenancy ? `
-
-    const tenant = await server.inject({
-      method: 'GET',
-      url: '/health',
-      headers: { 'x-tenant-id': 'demo' },
-    })
-    expect(tenant.json().tenant).toBe('demo')` : ""}
-    await app.shutdown()
-  })
-})
-`;
-}
-function readme(options) {
-  const features = [
-    "typed routes with Zod validation",
-    "structured logging with request/tenant context",
-    "typed domain events",
-    ...options.tenancy ? ["multi-tenancy (header + subdomain resolvers)"] : [],
-    ...options.auth ? ["authentication (register/login/refresh/me)"] : [],
-    ...options.billing ? ["subscriptions with plans and feature limits"] : [],
-    ...options.ui ? ["web UI (React + shadcn/ui on @basaltkit/admin-shadcn + @basaltkit/sdk)"] : [],
-    ...options.cli ? ["`basalt` CLI with code generators (`make:*`) and built-in commands"] : []
-  ];
-  return `# ${options.name}
-
-A SaaS app scaffolded with [Basalt](https://github.com/basaltkit/basalt).
-
-Included: ${features.join(" \xB7 ")}.
-
-## Getting started
-
-\`\`\`bash
-pnpm install
-pnpm dev        # API on http://localhost:3000
-pnpm test
-\`\`\`
-${options.cli ? `
-## The \`basalt\` CLI
-
-\`\`\`bash
-pnpm basalt list                    # available commands
-pnpm basalt routes                  # registered HTTP routes
-pnpm basalt make:resource Project   # schema \u2192 repository \u2192 service \u2192 plugin \u2192 routes \u2192 test
-pnpm basalt make:service Project    # a single artifact (--force to overwrite)
-\`\`\`
-
-Generated resources land in \`src/modules/<name>/\`. Register the generated
-plugin in \`src/app.ts\` to wire it up.
-` : ""}${options.ui ? `
-## Web UI
-
-\`\`\`bash
-pnpm dev                       # terminal 1 \u2014 API on :3000
-pnpm --filter ${options.name}-web dev   # terminal 2 \u2014 UI on http://localhost:5180
-\`\`\`
-
-Open <http://localhost:5180>. The Vite dev server proxies \`/api\` to the API,
-so there is no CORS to configure${options.auth ? ". Register, then sign in" : ""}.
-` : ""}`;
-}
-function gitignore() {
-  return `node_modules/
-dist/
-.env
-.env.*
-!.env.example
-*.log
-`;
-}
-function pnpmWorkspaceYaml(options) {
-  return `${options.ui ? `packages:
-  - web
-` : ""}allowBuilds:
-  esbuild: true
-  msgpackr-extract: false
-# @basaltkit/* releases in lockstep, often within hours \u2014 exclude the scope from
-# pnpm's minimumReleaseAge policy so \`pnpm up\` is never blocked on a fresh release.
-minimumReleaseAgeExclude:
-  - '@basaltkit/*'
-`;
-}
-
-// src/templates-ui.ts
-var BASALT_VERSION2 = "^1.0.0";
-function uiFiles(options) {
-  return {
-    "web/package.json": webPackageJson(options),
-    "web/vite.config.ts": webViteConfig(),
-    "web/tsconfig.json": webTsconfig(),
-    "web/index.html": webIndexHtml(options),
-    "web/postcss.config.js": webPostcss(),
-    "web/tailwind.config.js": webTailwind(),
-    "web/src/main.tsx": webMain(),
-    "web/src/crypto-shim.ts": webCryptoShim(),
-    "web/src/index.css": webCss(),
-    "web/src/api.ts": webApi(options),
-    "web/src/App.tsx": webApp(options)
-  };
-}
-function webPackageJson(options) {
-  return `${JSON.stringify(
-    {
-      name: `${options.name}-web`,
-      private: true,
-      type: "module",
-      scripts: { dev: "vite", build: "vite build", preview: "vite preview" },
-      dependencies: {
-        "@basaltkit/admin": BASALT_VERSION2,
-        "@basaltkit/admin-shadcn": BASALT_VERSION2,
-        "@basaltkit/sdk": BASALT_VERSION2,
-        react: "^18.3.1",
-        "react-dom": "^18.3.1",
-        zod: "^3.24.0"
-      },
-      devDependencies: {
-        "@types/react": "^18.3.0",
-        "@types/react-dom": "^18.3.0",
-        "@vitejs/plugin-react": "^4.3.0",
-        autoprefixer: "^10.4.0",
-        postcss: "^8.4.0",
-        tailwindcss: "^3.4.0",
-        typescript: "^5.8.0",
-        vite: "^6.0.0"
-      }
-    },
-    null,
-    2
-  )}
-`;
-}
-function webViteConfig() {
-  return `import { fileURLToPath } from 'node:url'
-import react from '@vitejs/plugin-react'
-import { defineConfig } from 'vite'
-
-export default defineConfig({
-  plugins: [react()],
-  resolve: {
-    alias: {
-      // @basaltkit/admin uses randomUUID from crypto; map it to Web Crypto in the browser.
-      crypto: fileURLToPath(new URL('./src/crypto-shim.ts', import.meta.url)),
-    },
-  },
-  server: {
-    port: 5180,
-    // Proxy API calls to the backend so there is no CORS in dev.
-    proxy: {
-      '/api': {
-        target: 'http://localhost:3000',
-        changeOrigin: true,
-        rewrite: (path) => path.replace(/^\\/api/, ''),
-      },
-    },
-  },
-})
-`;
-}
-function webTsconfig() {
-  return `${JSON.stringify(
-    {
-      compilerOptions: {
-        target: "ES2022",
-        lib: ["ES2022", "DOM", "DOM.Iterable"],
-        module: "ESNext",
-        moduleResolution: "Bundler",
-        jsx: "react-jsx",
-        strict: true,
-        noUncheckedIndexedAccess: true,
-        skipLibCheck: true,
-        noEmit: true,
-        allowImportingTsExtensions: true,
-        verbatimModuleSyntax: true,
-        types: ["node"]
-      },
-      include: ["src"]
-    },
-    null,
-    2
-  )}
-`;
-}
-function webIndexHtml(options) {
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${options.name}</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>
-`;
-}
-function webPostcss() {
-  return `export default {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}
-`;
-}
-function webTailwind() {
-  return `export default {
-  darkMode: ['class'],
-  content: ['./index.html', './src/**/*.{ts,tsx}', './node_modules/@basaltkit/admin-shadcn/dist/**/*.js'],
-  theme: {
-    extend: {
-      colors: {
-        border: 'hsl(var(--border))',
-        input: 'hsl(var(--input))',
-        ring: 'hsl(var(--ring))',
-        background: 'hsl(var(--background))',
-        foreground: 'hsl(var(--foreground))',
-        primary: { DEFAULT: 'hsl(var(--primary))', foreground: 'hsl(var(--primary-foreground))' },
-        secondary: { DEFAULT: 'hsl(var(--secondary))', foreground: 'hsl(var(--secondary-foreground))' },
-        destructive: { DEFAULT: 'hsl(var(--destructive))', foreground: 'hsl(var(--destructive-foreground))' },
-        muted: { DEFAULT: 'hsl(var(--muted))', foreground: 'hsl(var(--muted-foreground))' },
-        accent: { DEFAULT: 'hsl(var(--accent))', foreground: 'hsl(var(--accent-foreground))' },
-        card: { DEFAULT: 'hsl(var(--card))', foreground: 'hsl(var(--card-foreground))' },
-      },
-      borderRadius: { lg: 'var(--radius)', md: 'calc(var(--radius) - 2px)', sm: 'calc(var(--radius) - 4px)' },
-    },
-  },
-  plugins: [],
-}
-`;
-}
-function webMain() {
-  return `import { StrictMode } from 'react'
-import { createRoot } from 'react-dom/client'
-import { App } from './App.js'
-import './index.css'
-
-createRoot(document.getElementById('root') as HTMLElement).render(
-  <StrictMode>
-    <App />
-  </StrictMode>,
-)
-`;
-}
-function webCryptoShim() {
-  return `export const randomUUID = (): string => globalThis.crypto.randomUUID()
-`;
-}
-function webCss() {
-  return `@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-@layer base {
-  :root {
-    --background: 240 20% 99%;
-    --foreground: 240 10% 3.9%;
-    --card: 0 0% 100%;
-    --card-foreground: 240 10% 3.9%;
-    --primary: 243 75% 59%;
-    --primary-foreground: 0 0% 100%;
-    --secondary: 240 4.8% 95.9%;
-    --secondary-foreground: 240 5.9% 10%;
-    --muted: 240 4.8% 95.9%;
-    --muted-foreground: 240 3.8% 46.1%;
-    --accent: 243 75% 96%;
-    --accent-foreground: 243 60% 40%;
-    --destructive: 0 72% 51%;
-    --destructive-foreground: 0 0% 100%;
-    --border: 240 5.9% 90%;
-    --input: 240 5.9% 88%;
-    --ring: 243 75% 59%;
-    --radius: 0.6rem;
-  }
-  .dark {
-    --background: 240 10% 6%;
-    --foreground: 0 0% 98%;
-    --card: 240 10% 9%;
-    --card-foreground: 0 0% 98%;
-    --primary: 243 75% 68%;
-    --primary-foreground: 240 10% 6%;
-    --secondary: 240 3.7% 15.9%;
-    --secondary-foreground: 0 0% 98%;
-    --muted: 240 3.7% 15.9%;
-    --muted-foreground: 240 5% 64.9%;
-    --accent: 243 40% 22%;
-    --accent-foreground: 243 75% 85%;
-    --destructive: 0 72% 55%;
-    --destructive-foreground: 0 0% 98%;
-    --border: 240 3.7% 16%;
-    --input: 240 3.7% 18%;
-    --ring: 243 75% 68%;
-  }
-  * {
-    border-color: hsl(var(--border));
-  }
-  body {
-    margin: 0;
-    background-color: hsl(var(--background));
-    color: hsl(var(--foreground));
-    font-family: ui-sans-serif, system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
-    -webkit-font-smoothing: antialiased;
-  }
-}
-`;
-}
-function webApi(options) {
-  const authEndpoints = options.auth ? `
-  register: endpoint({ method: 'POST', path: '/auth/register', body: credentials, result: User }),
-  login: endpoint({
-    method: 'POST',
-    path: '/auth/login',
-    body: credentials.extend({ mfaCode: z.string().optional() }),
-    result: z.object({ accessToken: z.string(), refreshToken: z.string(), user: User }),
-  }),
-  me: endpoint({ method: 'GET', path: '/auth/me', result: User }),
-  // Password recovery
-  forgotPassword: endpoint({
-    method: 'POST',
-    path: '/auth/password/forgot',
-    body: z.object({ email: z.string().email() }),
-    result: z.object({ ok: z.boolean() }),
-  }),
-  resetPassword: endpoint({
-    method: 'POST',
-    path: '/auth/password/reset',
-    body: z.object({ token: z.string(), password: z.string().min(8) }),
-    result: z.object({ ok: z.boolean() }),
-  }),
-  // TOTP / two-factor
-  mfaStatus: endpoint({
-    method: 'GET',
-    path: '/auth/mfa/status',
-    result: z.object({ enabled: z.boolean(), pending: z.boolean() }),
-  }),
-  mfaEnroll: endpoint({
-    method: 'POST',
-    path: '/auth/mfa/enroll',
-    result: z.object({ secret: z.string(), otpauthUri: z.string() }),
-  }),
-  mfaActivate: endpoint({
-    method: 'POST',
-    path: '/auth/mfa/activate',
-    body: z.object({ code: z.string().min(6) }),
-    result: z.object({ recoveryCodes: z.array(z.string()) }),
-  }),
-  mfaDisable: endpoint({
-    method: 'POST',
-    path: '/auth/mfa/disable',
-    body: z.object({ code: z.string().min(6) }),
-    result: z.unknown(),
-  }),` : "";
-  const credentials = options.auth ? `
-const credentials = z.object({ email: z.string().email(), password: z.string().min(8) })` : "";
-  const user = options.auth ? `
-const User = z.object({ id: z.string(), email: z.string() })` : "";
-  return `import { createClient, endpoint, type Client as SdkClient } from '@basaltkit/sdk'
-import { z } from 'zod'
-${user}${credentials}
-
-const Index = z.object({ name: z.string(), status: z.string(), endpoints: z.array(z.string()) })
-const Health = z.object({ ok: z.boolean() })
-
-export const endpoints = {
-  index: endpoint({ method: 'GET', path: '/', result: Index }),
-  health: endpoint({ method: 'GET', path: '/health', result: Health }),${authEndpoints}
-}
-
-export type Api = SdkClient<typeof endpoints>
-
-export function makeApi(getToken: () => string | undefined = () => undefined): Api {
-  return createClient(endpoints, { baseUrl: '/api', getToken })
-}
-`;
-}
-function webApp(options) {
-  return options.auth ? webAppWithAuth(options) : webAppStatusOnly(options);
-}
-function webAppStatusOnly(options) {
-  return `import { useEffect, useState } from 'react'
-import { Badge, Button, Card, CardContent, CardHeader, CardTitle } from '@basaltkit/admin-shadcn'
-import { makeApi } from './api.js'
-
-const api = makeApi()
-
-export function App() {
-  const [name, setName] = useState('${options.name}')
-  const [endpoints, setEndpoints] = useState<string[]>([])
-  const [healthy, setHealthy] = useState<boolean | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [dark, setDark] = useState(false)
-
-  const refresh = async () => {
-    setError(null)
-    try {
-      const [index, health] = await Promise.all([api.index(), api.health()])
-      setName(index.name)
-      setEndpoints(index.endpoints)
-      setHealthy(health.ok)
-    } catch (err) {
-      setError(String((err as Error)?.message ?? err))
-    }
-  }
-  useEffect(() => {
-    void refresh()
-  }, [])
-
-  const toggleTheme = () => {
-    const next = !dark
-    document.documentElement.classList.toggle('dark', next)
-    setDark(next)
-  }
-
-  return (
-    <div className="grid min-h-screen place-items-center px-4">
-      <Card className="w-full max-w-lg">
-        <CardHeader className="flex-row items-center justify-between space-y-0">
-          <CardTitle>{name}</CardTitle>
-          <div className="flex items-center gap-2">
-            {healthy !== null && (
-              <Badge variant={healthy ? 'secondary' : 'destructive'}>
-                {healthy ? 'healthy' : 'down'}
-              </Badge>
-            )}
-            <Button variant="ghost" size="sm" onClick={toggleTheme}>
-              {dark ? 'Light' : 'Dark'}
-            </Button>
-          </div>
-        </CardHeader>
-        <CardContent>
-          {error && <p className="mb-3 text-sm font-medium text-destructive">{error}</p>}
-          <p className="mb-2 text-sm text-muted-foreground">Endpoints</p>
-          <ul className="space-y-1">
-            {endpoints.map((path) => (
-              <li key={path} className="rounded-md bg-muted px-3 py-1.5 font-mono text-sm">
-                {path}
-              </li>
-            ))}
-          </ul>
-          <Button className="mt-4" variant="outline" size="sm" onClick={() => void refresh()}>
-            Refresh
-          </Button>
-        </CardContent>
-      </Card>
-    </div>
-  )
-}
-`;
-}
-function webAppWithAuth(options) {
-  return `import { useEffect, useState, type FormEvent, type ReactNode } from 'react'
-import { Badge, Button, Card, CardContent, CardHeader, CardTitle, Input, Label } from '@basaltkit/admin-shadcn'
-import { makeApi } from './api.js'
-
-const STORAGE_KEY = '${options.name}.token'
-const errorMessage = (err: unknown): string => String((err as Error)?.message ?? err)
-const errorCode = (err: unknown): string => String((err as { code?: string })?.code ?? '')
-// Password-reset emails link back here with ?token=\u2026 \u2014 that switches to the reset screen.
-const resetToken = new URLSearchParams(window.location.search).get('token')
-
-export function App() {
-  const [token, setToken] = useState<string | null>(() => localStorage.getItem(STORAGE_KEY))
-
-  const store = (next: string | null) => {
-    if (next) localStorage.setItem(STORAGE_KEY, next)
-    else localStorage.removeItem(STORAGE_KEY)
-    setToken(next)
-  }
-
-  if (resetToken) return <ResetPassword token={resetToken} />
-  if (!token) return <AuthScreen onToken={store} />
-  return <Dashboard token={token} onLogout={() => store(null)} />
-}
-
-// Centered card shell reused by every auth screen.
-function Shell({ subtitle, children }: { subtitle?: string; children: ReactNode }) {
-  return (
-    <div className="grid min-h-screen place-items-center px-4">
-      <Card className="w-full max-w-md">
-        <CardHeader>
-          <CardTitle>${options.name}</CardTitle>
-          {subtitle && <p className="text-sm text-muted-foreground">{subtitle}</p>}
-        </CardHeader>
-        <CardContent>{children}</CardContent>
-      </Card>
-    </div>
-  )
-}
-
-type Mode = 'login' | 'register' | 'forgot'
-
-function AuthScreen({ onToken }: { onToken: (token: string) => void }) {
-  const [mode, setMode] = useState<Mode>('login')
-  const [error, setError] = useState<string | null>(null)
-  const [notice, setNotice] = useState<string | null>(null)
-  const [busy, setBusy] = useState(false)
-  // When the account has 2FA on, login throws AUTH_MFA_REQUIRED; we keep the
-  // credentials and ask for the 6-digit code, then retry.
-  const [challenge, setChallenge] = useState<{ email: string; password: string } | null>(null)
-  const api = makeApi()
-
-  const submit = async (event: FormEvent<HTMLFormElement>) => {
-    event.preventDefault()
-    setError(null)
-    setNotice(null)
-    setBusy(true)
-    const form = new FormData(event.currentTarget)
-    try {
-      if (challenge) {
-        const res = await api.login({ body: { ...challenge, mfaCode: String(form.get('mfaCode')) } })
-        onToken(res.accessToken)
-        return
-      }
-      const email = String(form.get('email'))
-      const password = String(form.get('password'))
-      if (mode === 'forgot') {
-        await api.forgotPassword({ body: { email } })
-        setNotice('If that email exists, a reset link is on its way.')
-        return
-      }
-      if (mode === 'register') await api.register({ body: { email, password } })
-      const res = await api.login({ body: { email, password } })
-      onToken(res.accessToken)
-    } catch (err) {
-      if (errorCode(err) === 'AUTH_MFA_REQUIRED') {
-        setChallenge({
-          email: String(new FormData(event.currentTarget).get('email')),
-          password: String(new FormData(event.currentTarget).get('password')),
-        })
-      } else {
-        setError(errorMessage(err))
-      }
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  if (challenge) {
-    return (
-      <Shell subtitle="Two-factor authentication">
-        <form onSubmit={submit} className="space-y-4">
-          <div className="space-y-2">
-            <Label htmlFor="mfaCode">Authenticator code</Label>
-            <Input id="mfaCode" name="mfaCode" inputMode="numeric" autoComplete="one-time-code" placeholder="123456" required />
-          </div>
-          {error && <p className="text-sm font-medium text-destructive">{error}</p>}
-          <Button type="submit" className="w-full" disabled={busy}>{busy ? '\u2026' : 'Verify'}</Button>
-        </form>
-        <button className="mt-4 w-full text-center text-sm text-muted-foreground hover:text-foreground" onClick={() => { setChallenge(null); setError(null) }}>
-          Back to sign in
-        </button>
-      </Shell>
-    )
-  }
-
-  const subtitle = mode === 'register' ? 'Create an account' : mode === 'forgot' ? 'Reset your password' : 'Sign in'
-  return (
-    <Shell subtitle={subtitle}>
-      <form onSubmit={submit} className="space-y-4">
-        <div className="space-y-2">
-          <Label htmlFor="email">Email</Label>
-          <Input id="email" name="email" type="email" placeholder="you@example.com" required />
-        </div>
-        {mode !== 'forgot' && (
-          <div className="space-y-2">
-            <Label htmlFor="password">Password</Label>
-            <Input id="password" name="password" type="password" placeholder="\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" required />
-          </div>
-        )}
-        {error && <p className="text-sm font-medium text-destructive">{error}</p>}
-        {notice && <p className="text-sm font-medium text-foreground">{notice}</p>}
-        <Button type="submit" className="w-full" disabled={busy}>
-          {busy ? '\u2026' : mode === 'register' ? 'Create account' : mode === 'forgot' ? 'Send reset link' : 'Sign in'}
-        </Button>
-      </form>
-      <div className="mt-4 space-y-1 text-center text-sm text-muted-foreground">
-        {mode === 'login' && (
-          <button className="block w-full hover:text-foreground" onClick={() => { setMode('forgot'); setError(null); setNotice(null) }}>
-            Forgot your password?
-          </button>
-        )}
-        <button className="block w-full hover:text-foreground" onClick={() => { setMode(mode === 'register' ? 'login' : 'register'); setError(null); setNotice(null) }}>
-          {mode === 'register' ? 'Already have an account? Sign in' : mode === 'forgot' ? 'Back to sign in' : 'New here? Create an account'}
-        </button>
-      </div>
-    </Shell>
-  )
-}
-
-function ResetPassword({ token }: { token: string }) {
-  const [done, setDone] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const [busy, setBusy] = useState(false)
-
-  const backToLogin = () => {
-    window.history.replaceState({}, '', window.location.pathname)
-    window.location.reload()
-  }
-
-  const submit = async (event: FormEvent<HTMLFormElement>) => {
-    event.preventDefault()
-    setError(null)
-    setBusy(true)
-    const password = String(new FormData(event.currentTarget).get('password'))
-    try {
-      await makeApi().resetPassword({ body: { token, password } })
-      setDone(true)
-    } catch (err) {
-      setError(errorMessage(err))
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  if (done) {
-    return (
-      <Shell subtitle="Password updated">
-        <Button className="w-full" onClick={backToLogin}>Sign in</Button>
-      </Shell>
-    )
-  }
-  return (
-    <Shell subtitle="Choose a new password">
-      <form onSubmit={submit} className="space-y-4">
-        <div className="space-y-2">
-          <Label htmlFor="password">New password</Label>
-          <Input id="password" name="password" type="password" placeholder="\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" required minLength={8} />
-        </div>
-        {error && <p className="text-sm font-medium text-destructive">{error}</p>}
-        <Button type="submit" className="w-full" disabled={busy}>{busy ? '\u2026' : 'Reset password'}</Button>
-      </form>
-    </Shell>
-  )
-}
-
-function Dashboard({ token, onLogout }: { token: string; onLogout: () => void }) {
-  const api = makeApi(() => token)
-  const [email, setEmail] = useState<string | null>(null)
-  const [healthy, setHealthy] = useState<boolean | null>(null)
-  const [mfa, setMfa] = useState<{ enabled: boolean; pending: boolean } | null>(null)
-  const [error, setError] = useState<string | null>(null)
-
-  const load = async () => {
-    try {
-      const [me, health, status] = await Promise.all([api.me(), api.health(), api.mfaStatus()])
-      setEmail(me.email)
-      setHealthy(health.ok)
-      setMfa(status)
-    } catch (err) {
-      setError(errorMessage(err))
-    }
-  }
-  useEffect(() => {
-    void load()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [token])
-
-  return (
-    <div className="grid min-h-screen place-items-center px-4 py-10">
-      <Card className="w-full max-w-lg">
-        <CardHeader className="flex-row items-center justify-between space-y-0">
-          <CardTitle>${options.name}</CardTitle>
-          {healthy !== null && (
-            <Badge variant={healthy ? 'secondary' : 'destructive'}>{healthy ? 'healthy' : 'down'}</Badge>
-          )}
-        </CardHeader>
-        <CardContent className="space-y-4">
-          {error && <p className="text-sm font-medium text-destructive">{error}</p>}
-          <p className="text-sm text-muted-foreground">
-            Signed in as <span className="font-medium text-foreground">{email ?? '\u2026'}</span>
-          </p>
-          <MfaCard status={mfa} api={api} onChange={() => void load()} />
-          <Button variant="outline" size="sm" onClick={onLogout}>Sign out</Button>
-        </CardContent>
-      </Card>
-    </div>
-  )
-}
-
-type ApiClient = ReturnType<typeof makeApi>
-
-function MfaCard({ status, api, onChange }: { status: { enabled: boolean; pending: boolean } | null; api: ApiClient; onChange: () => void }) {
-  const [enroll, setEnroll] = useState<{ secret: string; otpauthUri: string } | null>(null)
-  const [recovery, setRecovery] = useState<string[] | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [busy, setBusy] = useState(false)
-
-  const run = async (fn: () => Promise<void>) => {
-    setError(null)
-    setBusy(true)
-    try {
-      await fn()
-    } catch (err) {
-      setError(errorMessage(err))
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  const start = () => run(async () => setEnroll(await api.mfaEnroll()))
-  const activate = (event: FormEvent<HTMLFormElement>) => {
-    event.preventDefault()
-    const code = String(new FormData(event.currentTarget).get('code'))
-    return run(async () => {
-      const res = await api.mfaActivate({ body: { code } })
-      setRecovery(res.recoveryCodes)
-      setEnroll(null)
-      onChange()
-    })
-  }
-  const disable = (event: FormEvent<HTMLFormElement>) => {
-    event.preventDefault()
-    const code = String(new FormData(event.currentTarget).get('code'))
-    return run(async () => {
-      await api.mfaDisable({ body: { code } })
-      onChange()
-    })
-  }
-
-  return (
-    <div className="rounded-lg border p-3">
-      <div className="mb-2 flex items-center justify-between">
-        <span className="text-sm font-medium">Two-factor authentication</span>
-        <Badge variant={status?.enabled ? 'secondary' : 'outline'}>{status?.enabled ? 'on' : 'off'}</Badge>
-      </div>
-      {error && <p className="mb-2 text-sm font-medium text-destructive">{error}</p>}
-
-      {recovery && (
-        <div className="space-y-2">
-          <p className="text-sm text-muted-foreground">Save these recovery codes \u2014 each works once:</p>
-          <ul className="grid grid-cols-2 gap-1">
-            {recovery.map((c) => (
-              <li key={c} className="rounded bg-muted px-2 py-1 font-mono text-xs">{c}</li>
-            ))}
-          </ul>
-          <Button size="sm" variant="outline" onClick={() => setRecovery(null)}>Done</Button>
-        </div>
-      )}
-
-      {!recovery && enroll && (
-        <form onSubmit={activate} className="space-y-2">
-          <p className="text-sm text-muted-foreground">Add this secret to your authenticator app, then enter a code:</p>
-          <code className="block break-all rounded bg-muted px-2 py-1 font-mono text-xs">{enroll.secret}</code>
-          <a className="block truncate text-xs text-primary underline" href={enroll.otpauthUri}>{enroll.otpauthUri}</a>
-          <Input name="code" inputMode="numeric" placeholder="123456" required />
-          <Button size="sm" type="submit" disabled={busy}>Activate</Button>
-        </form>
-      )}
-
-      {!recovery && !enroll && status?.enabled && (
-        <form onSubmit={disable} className="flex items-end gap-2">
-          <div className="flex-1">
-            <Label htmlFor="mfa-off" className="text-xs">Enter a code to turn off</Label>
-            <Input id="mfa-off" name="code" inputMode="numeric" placeholder="123456" required />
-          </div>
-          <Button size="sm" variant="destructive" type="submit" disabled={busy}>Disable</Button>
-        </form>
-      )}
-
-      {!recovery && !enroll && !status?.enabled && (
-        <Button size="sm" onClick={start} disabled={busy}>{busy ? '\u2026' : 'Enable 2FA'}</Button>
-      )}
-    </div>
-  )
-}
-`;
-}
-
-// src/prompt.ts
-import { emitKeypressEvents } from "readline";
-import { createInterface } from "readline/promises";
-import { stdin, stdout } from "process";
-var WizardCancelledError = class extends Error {
-  constructor() {
-    super("Cancelled.");
-    this.name = "WizardCancelledError";
-  }
-};
-var c = {
-  dim: (s) => `\x1B[2m${s}\x1B[0m`,
-  cyan: (s) => `\x1B[36m${s}\x1B[0m`,
-  green: (s) => `\x1B[32m${s}\x1B[0m`,
-  bold: (s) => `\x1B[1m${s}\x1B[0m`
-};
-function ttyPrompter() {
-  return {
-    intro: (message) => stdout.write(`
-${c.bold(c.cyan("\u25C6 " + message))}
-
-`),
-    note: (message) => stdout.write(`${message}
-`),
-    outro: (message) => stdout.write(`
-${c.green("\u2713 " + message)}
-`),
-    async text({ message, placeholder, initial, validate }) {
-      const rl = createInterface({ input: stdin, output: stdout });
-      rl.on("SIGINT", () => {
-        rl.close();
-        throw new WizardCancelledError();
-      });
-      try {
-        for (; ; ) {
-          const hint = placeholder ? c.dim(` (${placeholder})`) : "";
-          const answer = (await rl.question(`${c.cyan("?")} ${message}${hint}: `)).trim() || initial || "";
-          const error = validate?.(answer);
-          if (!error) return answer;
-          stdout.write(`  ${c.dim(error)}
-`);
-        }
-      } catch (error) {
-        if (error.code === "ABORT_ERR") throw new WizardCancelledError();
-        throw error;
-      } finally {
-        rl.close();
-      }
-    },
-    select({ message, choices, initial = 0 }) {
-      return keyboardSelect(message, choices, initial, false).then((v) => v[0]);
-    },
-    multiselect({ message, choices, initial = [] }) {
-      const preselected = choices.map((choice) => initial.includes(choice.value));
-      return keyboardSelect(message, choices, 0, true, preselected);
-    },
-    async confirm({ message, initial = false }) {
-      const rl = createInterface({ input: stdin, output: stdout });
-      try {
-        const answer = (await rl.question(`${c.cyan("?")} ${message} ${c.dim(initial ? "(Y/n)" : "(y/N)")} `)).trim().toLowerCase();
-        return answer ? answer.startsWith("y") : initial;
-      } finally {
-        rl.close();
-      }
-    }
-  };
-}
-function keyboardSelect(message, choices, initialIndex, multi, selected = choices.map(() => false)) {
-  return new Promise((resolve2, reject) => {
-    let index = initialIndex;
-    let rendered = 0;
-    emitKeypressEvents(stdin);
-    const wasRaw = stdin.isTTY ? stdin.isRaw : false;
-    if (stdin.isTTY) stdin.setRawMode(true);
-    const render = () => {
-      if (rendered > 0) stdout.write(`\x1B[${rendered}A\x1B[0J`);
-      const lines = [`${c.cyan("?")} ${message}${multi ? c.dim(" (space to toggle, enter to confirm)") : ""}`];
-      choices.forEach((choice, i) => {
-        const pointer = i === index ? c.cyan("\u276F") : " ";
-        const box = multi ? (selected[i] ? c.green("\u25C9") : "\u25EF") + " " : "";
-        const label = i === index ? c.cyan(choice.label) : choice.label;
-        const hint = choice.hint ? c.dim(` \u2014 ${choice.hint}`) : "";
-        lines.push(`${pointer} ${box}${label}${hint}`);
-      });
-      stdout.write(lines.join("\n") + "\n");
-      rendered = lines.length;
-    };
-    const cleanup = () => {
-      stdin.off("keypress", onKey);
-      if (stdin.isTTY) stdin.setRawMode(wasRaw);
-      stdin.pause();
-    };
-    const onKey = (_str, key) => {
-      if (key.ctrl && key.name === "c") {
-        cleanup();
-        reject(new WizardCancelledError());
-      } else if (key.name === "up" || key.name === "k") {
-        index = (index - 1 + choices.length) % choices.length;
-        render();
-      } else if (key.name === "down" || key.name === "j") {
-        index = (index + 1) % choices.length;
-        render();
-      } else if (multi && key.name === "space") {
-        selected[index] = !selected[index];
-        render();
-      } else if (key.name === "return") {
-        cleanup();
-        resolve2(
-          multi ? choices.filter((_, i) => selected[i]).map((choice) => choice.value) : [choices[index].value]
-        );
-      }
-    };
-    stdin.resume();
-    stdin.on("keypress", onKey);
-    render();
-  });
-}
-function scriptedPrompter(script) {
-  const text = [...script.text ?? []];
-  const select = [...script.select ?? []];
-  const multiselect = [...script.multiselect ?? []];
-  const confirm = [...script.confirm ?? []];
-  const log = [];
-  const next = (queue, kind) => {
-    if (queue.length === 0) throw new Error(`scriptedPrompter: no more ${kind} answers`);
-    return queue.shift();
-  };
-  return {
-    log,
-    intro: (m) => log.push(m),
-    note: (m) => log.push(m),
-    outro: (m) => log.push(m),
-    async text() {
-      return next(text, "text");
-    },
-    async select() {
-      return next(select, "select");
-    },
-    async multiselect() {
-      return next(multiselect, "multiselect");
-    },
-    async confirm() {
-      return next(confirm, "confirm");
-    }
-  };
-}
-
-// src/wizard.ts
-var FEATURES = [
-  { value: "tenancy", label: "Multi-tenancy", hint: "per-tenant data isolation" },
-  { value: "auth", label: "Authentication", hint: "JWT, sessions, MFA, OAuth" },
-  { value: "billing", label: "Subscriptions / billing", hint: "Stripe, Paddle, Lemon Squeezy" },
-  { value: "ui", label: "Web UI", hint: "React + shadcn + SDK (pnpm workspace)" },
-  { value: "cli", label: "basalt CLI", hint: "code generators + commands" }
-];
-var PRESETS = [
-  { value: "saas", label: "SaaS starter", hint: "tenancy + auth + billing + CLI", features: ["tenancy", "auth", "billing", "cli"] },
-  { value: "api", label: "API only", hint: "auth, no tenancy or UI", features: ["auth"] },
-  { value: "full", label: "Full stack", hint: "everything + web UI", features: ["tenancy", "auth", "billing", "ui", "cli"] },
-  { value: "minimal", label: "Minimal", hint: "no batteries, add them later", features: [] },
-  { value: "custom", label: "Custom", hint: "pick features yourself", features: null }
-];
-var PACKAGE_MANAGERS = [
-  { value: "pnpm", label: "pnpm", hint: "recommended" },
-  { value: "npm", label: "npm" },
-  { value: "yarn", label: "yarn" },
-  { value: "bun", label: "bun" }
-];
-function validateProjectName(name) {
-  const trimmed = name.trim();
-  if (!trimmed) return "Please enter a project name.";
-  if (trimmed.length > 214) return "Name is too long (max 214 characters).";
-  if (!/^(?:@[a-z0-9-~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(trimmed)) {
-    return "Use a valid npm package name (lowercase, no spaces).";
-  }
-  return void 0;
-}
-async function runWizard(prompter, options = {}) {
-  prompter.intro("create-basalt \u2014 scaffold a Basalt application");
-  const name = options.name && !validateProjectName(options.name) ? options.name : await prompter.text({
-    message: "Project name",
-    placeholder: "my-saas",
-    initial: "my-saas",
-    validate: validateProjectName
-  });
-  const presetValue = await prompter.select({
-    message: "Choose a starting point",
-    choices: PRESETS.map((p) => ({ value: p.value, label: p.label, hint: p.hint })),
-    initial: 0
-  });
-  const preset = PRESETS.find((p) => p.value === presetValue) ?? PRESETS[0];
-  const featureSet = new Set(
-    preset.features ?? await prompter.multiselect({
-      message: "Select features",
-      choices: FEATURES,
-      initial: ["tenancy", "auth"]
-    })
-  );
-  let pm = await prompter.select({
-    message: "Package manager",
-    choices: PACKAGE_MANAGERS,
-    initial: Math.max(0, PACKAGE_MANAGERS.findIndex((m) => m.value === (options.defaultPm ?? "pnpm")))
-  });
-  if (featureSet.has("ui") && pm !== "pnpm") {
-    prompter.note(`  Note: the Web UI is a pnpm workspace \u2014 using pnpm instead of ${pm}.`);
-    pm = "pnpm";
-  }
-  const install = await prompter.confirm({ message: "Install dependencies now?", initial: false });
-  const git = await prompter.confirm({ message: "Initialize a git repository?", initial: false });
-  const enabled = FEATURES.filter((f) => featureSet.has(f.value)).map((f) => f.label);
-  prompter.note(
-    `
-  Summary
-    name      ${name}
-    features  ${enabled.length ? enabled.join(", ") : "(none)"}
-    pm        ${pm}
-    install   ${install ? "yes" : "no"}
-    git       ${git ? "yes" : "no"}
-`
-  );
-  const ok = await prompter.confirm({ message: "Create project?", initial: true });
-  if (!ok) throw new WizardCancelledError();
-  return {
-    name,
-    tenancy: featureSet.has("tenancy"),
-    auth: featureSet.has("auth"),
-    billing: featureSet.has("billing"),
-    ui: featureSet.has("ui"),
-    cli: featureSet.has("cli"),
-    pm,
-    install,
-    git
-  };
-}
-
-// src/index.ts
-var TargetNotEmptyError = class extends Error {
-  constructor(dir) {
-    super(`Target directory "${dir}" already exists and is not empty.`);
-    this.name = "TargetNotEmptyError";
-  }
-};
-function detectPackageManager(userAgent = process.env["npm_config_user_agent"]) {
-  const name = userAgent?.split(" ")[0]?.split("/")[0];
-  if (name === "pnpm" || name === "yarn" || name === "bun") return name;
-  return "npm";
-}
-async function createProject(input) {
-  const options = {
-    name: input.name,
-    tenancy: input.tenancy ?? true,
-    auth: input.auth ?? true,
-    billing: input.billing ?? false,
-    ui: input.ui ?? false,
-    cli: input.cli ?? false
-  };
-  const dir = resolve(input.dir ?? input.name);
-  const existing = await readdir(dir).catch(() => null);
-  if (existing && existing.length > 0) throw new TargetNotEmptyError(dir);
-  const files = {
-    "package.json": packageJson(options),
-    "tsconfig.json": tsconfigJson(),
-    ".env.example": envExample(options),
-    ".gitignore": gitignore(),
-    "README.md": readme(options),
-    "pnpm-workspace.yaml": pnpmWorkspaceYaml(options),
-    "src/env.ts": envTs(options),
-    "src/app.ts": appTs(options),
-    "src/routes.ts": routesTs(options),
-    "src/server.ts": serverTs(),
-    "tests/app.test.ts": appTest(options),
-    ...options.cli ? { "bin/basalt.ts": basaltBin() } : {},
-    ...options.ui ? uiFiles(options) : {}
-  };
-  for (const [path, content] of Object.entries(files)) {
-    const target = join(dir, path);
-    await mkdir(dirname(target), { recursive: true });
-    await writeFile(target, content);
-  }
-  return { dir, files: Object.keys(files).sort(), options };
-}
-
-export {
-  WizardCancelledError,
-  ttyPrompter,
-  scriptedPrompter,
-  FEATURES,
-  PRESETS,
-  validateProjectName,
-  runWizard,
-  TargetNotEmptyError,
-  detectPackageManager,
-  createProject
-};