anhedral 0.1.3 → 0.1.4

package/dist/templates/backend.d.ts

@@ -1,2 +1,2 @@
 import type { ProjectOptions } from '../scaffold.js';
-export declare function scaffoldBackend(root: string, { projectName, displayName, frontendUrl }: ProjectOptions): Promise<void>;
+export declare function scaffoldBackend(root: string, { projectName, displayName, frontendUrl, skipInstall }: ProjectOptions): Promise<void>;

package/dist/templates/backend.js

@@ -1,8 +1,9 @@
 import path from 'node:path';
-import { writeFile, exec } from '../util.js';
+import { writeFile, execCommand } from '../util.js';
 import { anhedralPrint } from '../print.js';
 import { getBackendInstallCommands } from '../commands.js';
-export async function scaffoldBackend(root, { projectName, displayName, frontendUrl }) {
+import { BACKEND_DEPENDENCIES } from '../dependencies.js';
+export async function scaffoldBackend(root, { projectName, displayName, frontendUrl, skipInstall }) {
     const dir = path.join(root, 'apps/api');
     anhedralPrint.section('Backend (Fastify)');
     anhedralPrint.step('Writing backend source files');
@@ -24,15 +25,17 @@ export async function scaffoldBackend(root, { projectName, displayName, frontend
     writeRoutes(dir, displayName);
     writeAppAndIndex(dir, displayName);
     writeVercelEntry(dir);
+    writeVercelConfig(dir);
     writeTestFiles(dir);
     anhedralPrint.done('Backend source files written');
-    if (process.env.ANHEDRAL_SKIP_INSTALL === '1') {
-        anhedralPrint.info('Skipping backend dependency install (ANHEDRAL_SKIP_INSTALL=1)');
+    if (skipInstall) {
+        anhedralPrint.info('Skipping backend dependency install (--skip-install)');
+        anhedralPrint.info('Run after init: pnpm install');
         return;
     }
     anhedralPrint.step('Installing backend dependencies');
     for (const command of getBackendInstallCommands()) {
-        exec(command.cmd, dir);
+        execCommand(command.command, command.args, dir);
     }
     anhedralPrint.done('Backend dependencies installed');
 }
@@ -59,9 +62,8 @@ function writePackageJson(dir, projectName) {
         },
         keywords: [],
         license: 'MIT',
-        dependencies: {
-            '@anhedral/db': 'workspace:*',
-        },
+        dependencies: BACKEND_DEPENDENCIES.dependencies,
+        devDependencies: BACKEND_DEPENDENCIES.devDependencies,
     }, null, 2) + '\n');
 }
 function writeTsConfig(dir) {
@@ -1143,8 +1145,8 @@ const configPlugin: FastifyPluginAsync = async (fastify: FastifyInstance) => {
       R2_ACCESS_KEY_ID: { type: 'string', nullable: true },
       R2_SECRET_ACCESS_KEY: { type: 'string', nullable: true },
       R2_BUCKET: { type: 'string', nullable: true },
-      RC_SECRET_API_KEY: { type: 'string', default: '' },
-      RC_WEBHOOK_SECRET: { type: 'string', default: '' },
+      RC_SECRET_API_KEY: { type: 'string', nullable: true, default: '' },
+      RC_WEBHOOK_SECRET: { type: 'string', nullable: true, default: '' },
       RC_ENTITLEMENT_ID: { type: 'string', default: 'pro' },
       RC_OFFERING_ID: { type: 'string', default: 'default' },
     },
@@ -1155,6 +1157,23 @@ const configPlugin: FastifyPluginAsync = async (fastify: FastifyInstance) => {
     dotenv: !process.env.VERCEL,
     confKey: 'env',
   } as unknown as Record<string, unknown>);
+
+  if (fastify.env.NODE_ENV === 'production') {
+    if (fastify.env.ANHEDRAL_DEMO === 'true') {
+      throw new Error('ANHEDRAL_DEMO must be false in production');
+    }
+
+    const required = [
+      'CLERK_PUBLISHABLE_KEY',
+      'CLERK_SECRET_KEY',
+      'RC_SECRET_API_KEY',
+      'RC_WEBHOOK_SECRET',
+    ] as const;
+    const missing = required.filter((key) => !fastify.env[key]);
+    if (missing.length > 0) {
+      throw new Error(\`Missing production environment variables: \${missing.join(', ')}\`);
+    }
+  }
 };
 
 export default fp(configPlugin, { name: 'env-config', fastify: '5.x' });
@@ -2189,6 +2208,23 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
 }
 `);
 }
+function writeVercelConfig(dir) {
+    writeFile(path.join(dir, 'vercel.json'), JSON.stringify({
+        version: 2,
+        builds: [
+            {
+                src: 'api/index.ts',
+                use: '@vercel/node',
+            },
+        ],
+        routes: [
+            {
+                src: '/(.*)',
+                dest: 'api/index.ts',
+            },
+        ],
+    }, null, 2) + '\n');
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════

package/dist/templates/extension.d.ts

@@ -1,2 +1,2 @@
 import type { ProjectOptions } from '../scaffold.js';
-export declare function scaffoldExtension(root: string, { projectName, displayName }: ProjectOptions): Promise<void>;
+export declare function scaffoldExtension(root: string, { projectName, displayName, skipInstall }: ProjectOptions): Promise<void>;

package/dist/templates/extension.js

@@ -2,8 +2,9 @@ import { rmSync } from 'node:fs';
 import path from 'node:path';
 import { writeFile, exec } from '../util.js';
 import { anhedralPrint } from '../print.js';
+import { EXTENSION_DEPENDENCIES } from '../dependencies.js';
 import { resolveToolchainChannel, resolveToolchain, toolPackageRef } from '../toolchain.js';
-export async function scaffoldExtension(root, { projectName, displayName }) {
+export async function scaffoldExtension(root, { projectName, displayName, skipInstall }) {
     const appsRoot = path.join(root, 'apps');
     const dir = path.join(appsRoot, 'extension');
     const toolchain = resolveToolchain(resolveToolchainChannel(process.env.ANHEDRAL_TOOLCHAIN));
@@ -14,9 +15,14 @@ export async function scaffoldExtension(root, { projectName, displayName }) {
     writePackageJson(dir, projectName);
     anhedralPrint.done('WXT extension scaffolded');
     anhedralPrint.step('Installing Clerk + React + Tailwind dependencies');
-    exec(`pnpm add -D @types/chrome @types/react @types/react-dom @wxt-dev/module-react autoprefixer postcss tailwindcss@3.4.19 typescript@5.9.3 ${toolPackageRef('wxt', toolchain.wxt)}`, dir);
-    exec('pnpm add @clerk/chrome-extension react react-dom clsx tailwind-merge class-variance-authority lucide-react@0.468.0', dir);
-    anhedralPrint.done('Extension dependencies installed');
+    if (skipInstall) {
+        anhedralPrint.info('Skipping extension dependency install (--skip-install)');
+        anhedralPrint.info('Run after init: pnpm install');
+    }
+    else {
+        exec('pnpm install --no-frozen-lockfile', dir);
+    }
+    anhedralPrint.done(skipInstall ? 'Extension dependency manifests written' : 'Extension dependencies installed');
     cleanWxtStarterFiles(dir);
     writeWxtConfig(dir, displayName);
     writeTsConfig(dir);
@@ -27,6 +33,7 @@ export async function scaffoldExtension(root, { projectName, displayName }) {
     writeShadcnConfig(dir);
     writeReadme(dir, displayName);
     writeCnUtil(dir);
+    writeButtonComponent(dir);
     writeAuthContext(dir);
     writeApiClient(dir);
     writeBackground(dir);
@@ -35,10 +42,7 @@ export async function scaffoldExtension(root, { projectName, displayName }) {
     writeSidepanelHtml(dir, displayName);
     writeSidepanelApp(dir);
     writeStyles(dir);
-    anhedralPrint.step('Adding shadcn button component');
-    exec(`pnpm dlx ${toolPackageRef('shadcn', toolchain.shadcn)} add button`, dir);
-    writeStyles(dir);
-    anhedralPrint.done('shadcn button installed');
+    anhedralPrint.done('Extension source files written');
 }
 function cleanWxtStarterFiles(dir) {
     for (const relativePath of [
@@ -65,6 +69,8 @@ function writePackageJson(dir, projectName) {
             'zip:firefox': 'wxt zip -b firefox',
             typecheck: 'tsc --noEmit',
         },
+        dependencies: EXTENSION_DEPENDENCIES.dependencies,
+        devDependencies: EXTENSION_DEPENDENCIES.devDependencies,
     }, null, 2) + '\n');
 }
 function writeWxtConfig(dir, displayName) {
@@ -80,11 +86,15 @@ export default defineConfig({
       description: '${displayName} Chrome Extension',
       version: '0.1.0',
       ...(crxPublicKey ? { key: crxPublicKey } : {}),
-      permissions: ['activeTab', 'cookies', 'storage'],
+      minimum_chrome_version: '114',
+      permissions: ['activeTab', 'cookies', 'storage', 'sidePanel'],
       host_permissions: [],
       action: {
         default_title: 'Open ${displayName}',
       },
+      side_panel: {
+        default_path: 'sidepanel.html',
+      },
     };
   },
   modules: ['@wxt-dev/module-react'],
@@ -108,7 +118,6 @@ function writeTsConfig(dir) {
             jsx: 'react-jsx',
             lib: ['DOM', 'DOM.Iterable', 'ESNext'],
             types: ['wxt/browser', '@wxt-dev/module-react', 'chrome'],
-            baseUrl: '.',
             paths: { '@/*': ['./src/*'] },
         },
         include: ['**/*.ts', '**/*.tsx', '.wxt/wxt.d.ts'],
@@ -190,6 +199,41 @@ export function cn(...inputs: ClassValue[]) {
 }
 `);
 }
+function writeButtonComponent(dir) {
+    writeFile(path.join(dir, 'src/components/ui/button.tsx'), `import * as React from 'react';
+import { cn } from '@/lib/utils';
+
+type ButtonVariant = 'default' | 'outline';
+
+export type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+  variant?: ButtonVariant;
+};
+
+const variantClasses: Record<ButtonVariant, string> = {
+  default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+  outline: 'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+};
+
+export const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant = 'default', type = 'button', ...props }, ref) => {
+    return (
+      <button
+        ref={ref}
+        type={type}
+        className={cn(
+          'inline-flex h-9 items-center justify-center whitespace-nowrap rounded-md px-4 py-2 text-sm font-medium transition-colors disabled:pointer-events-none disabled:opacity-50',
+          variantClasses[variant],
+          className,
+        )}
+        {...props}
+      />
+    );
+  },
+);
+
+Button.displayName = 'Button';
+`);
+}
 function writeTailwindConfig(dir) {
     writeFile(path.join(dir, 'tailwind.config.cjs'), `/** @type {import('tailwindcss').Config} */
 module.exports = {
@@ -261,7 +305,7 @@ Set \`VITE_CLERK_PUBLISHABLE_KEY\` and \`VITE_API_URL\` in \`.env\` before using
 
 Run \`pnpm build\`, then load \`.output/chrome-mv3\` as an unpacked extension from \`chrome://extensions\`.
 
-The browser action opens the side panel. The background script initializes Clerk, the side panel handles sign-in/subscription state, and the content script is ready for page-to-extension messages.
+The extension uses Chrome's Side Panel API. The browser action opens \`sidepanel.html\`, \`wxt.config.ts\` declares the \`sidePanel\` permission and Chrome 114+ minimum version, the background script initializes Clerk, and the content script is ready for page-to-extension messages.
 `);
 }
 function writeAuthContext(dir) {
@@ -405,58 +449,25 @@ export { WEBSITE_URL };
 `);
 }
 function writeApiClient(dir) {
-    writeFile(path.join(dir, 'src/lib/api.ts'), `const API_BASE_URL = import.meta.env.VITE_API_URL || 'http://localhost:8787';
-
-export type SubscriptionEntitlements = {
-  pro: boolean;
-  inTrial: boolean;
-  trialEndsAt?: string;
-  expiresAt?: string;
-  periodStart?: string;
-  periodEnd?: string;
-  method?: 'trialing' | 'redeemed' | 'paid' | null;
-  managementUrl?: string;
-  cancelAtPeriodEnd?: boolean;
-};
+    writeFile(path.join(dir, 'src/lib/api.ts'), `import { ApiClient } from '@anhedral/api-client';
 
 export class APIClient {
   constructor(private getToken: () => Promise<string | null>) {}
 
-  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
-    const token = await this.getToken();
-    if (!token) throw new Error('Not authenticated');
-
-    const headers: Record<string, string> = {
-      Authorization: \`Bearer \${token}\`,
-      'Content-Type': 'application/json',
-      'X-Client-Type': 'chrome-extension',
-      'X-Platform': 'chrome',
-      ...(options.headers as Record<string, string>),
-    };
-
-    const response = await fetch(\`\${API_BASE_URL}\${endpoint}\`, { ...options, headers });
-
-    if (!response.ok) {
-      let error: { message?: string } = {};
-      try { error = await response.json(); } catch {}
-      throw new Error(error.message || \`Request failed (\${response.status})\`);
-    }
-
-    if (response.status === 204) return {} as T;
-    return response.json();
+  private client() {
+    return new ApiClient({
+      baseUrl: import.meta.env.VITE_API_URL || 'http://localhost:8787',
+      getToken: this.getToken,
+      platform: 'extension',
+    });
   }
 
-  async getMe() {
-    return this.request<{
-      user: { id: string; email: string; subscriptionTier: string; subscriptionStatus: string };
-    }>('/auth/me');
+  getMe() {
+    return this.client().getMe();
   }
 
-  async getSubscriptionEntitlements(options?: { refresh?: boolean }): Promise<SubscriptionEntitlements> {
-    const path = options?.refresh
-      ? '/subscriptions/entitlements/me?refresh=true'
-      : '/subscriptions/entitlements/me';
-    return this.request<SubscriptionEntitlements>(path);
+  getSubscriptionEntitlements(options?: { refresh?: boolean }) {
+    return this.client().getSubscriptionEntitlements(options);
   }
 }
 `);
@@ -464,15 +475,20 @@ export class APIClient {
 function writeBackground(dir) {
     writeFile(path.join(dir, 'src/entrypoints/background.ts'), `import { createClerkClient } from '@clerk/chrome-extension/background';
 
+type ChromeWithSidePanel = typeof chrome & {
+  sidePanel: {
+    setPanelBehavior: (behavior: { openPanelOnActionClick: boolean }) => Promise<void>;
+  };
+};
+
 export default defineBackground(() => {
   // Initialize Clerk in the background script for cookie-based auth
   void createClerkClient({
     publishableKey: import.meta.env.VITE_CLERK_PUBLISHABLE_KEY || '',
   }).catch(() => {});
 
-  // Open the side panel when the extension icon is clicked
-  // The sidePanel permission is auto-added by WXT when the sidepanel entrypoint exists
-  chrome.sidePanel
+  // Open the side panel when the extension icon is clicked.
+  (chrome as ChromeWithSidePanel).sidePanel
     .setPanelBehavior({ openPanelOnActionClick: true })
     .catch(() => {});
 });

package/dist/templates/frontend.d.ts

@@ -1,2 +1,2 @@
 import type { ProjectOptions } from '../scaffold.js';
-export declare function scaffoldFrontend(root: string, { projectName, displayName }: ProjectOptions): Promise<void>;
+export declare function scaffoldFrontend(root: string, { projectName, displayName, skipInstall }: ProjectOptions): Promise<void>;

package/dist/templates/frontend.js

@@ -3,11 +3,12 @@ import path from 'node:path';
 import { writeAnhedralLogo } from '../branding.js';
 import { anhedralPrint } from '../print.js';
 import { appendGitignore, writeFile, exec, execExpect, liftNestedProject } from '../util.js';
+import { FRONTEND_ADDON_DEPENDENCIES, withVersions } from '../dependencies.js';
 import { resolveToolchainChannel, resolveToolchain, toolPackageRef } from '../toolchain.js';
-export async function scaffoldFrontend(root, { projectName, displayName }) {
-    const dir = path.join(root, 'apps/mobile');
+export async function scaffoldFrontend(root, { projectName, displayName, skipInstall }) {
+    const dir = path.join(root, 'apps/frontend');
     const toolchain = resolveToolchain(resolveToolchainChannel(process.env.ANHEDRAL_TOOLCHAIN));
-    anhedralPrint.section('Mobile (Expo)');
+    anhedralPrint.section('Frontend (Expo)');
     anhedralPrint.step('Scaffolding Expo app with react-native-reusables');
     fs.mkdirSync(dir, { recursive: true });
     await execExpect(`pnpm dlx ${toolPackageRef('@react-native-reusables/cli', toolchain.reactNativeReusables)} init -t clerk-auth`, dir, [
@@ -17,11 +18,15 @@ export async function scaffoldFrontend(root, { projectName, displayName }) {
     ]);
     liftNestedProject(dir, projectName);
     anhedralPrint.done('Expo app scaffolded');
-    anhedralPrint.step('Installing mobile dependencies');
-    exec('pnpm install --no-frozen-lockfile', dir);
+    anhedralPrint.step('Installing frontend dependencies');
     patchFrontendPackageJson(dir);
+    patchExpoAppConfig(dir);
+    if (!skipInstall) {
+        exec('pnpm install --no-frozen-lockfile', dir);
+        exec('pnpm exec expo install --fix --pnpm', dir);
+    }
     appendGitignore(dir, ['.env', '.env.*', '!.env.example']);
-    anhedralPrint.done('Mobile dependencies installed');
+    anhedralPrint.done(skipInstall ? 'Frontend dependency manifests written' : 'Frontend dependencies installed');
     writeApiClient(dir);
     writeConfigFile(dir);
     writeApiHook(dir);
@@ -30,190 +35,81 @@ export async function scaffoldFrontend(root, { projectName, displayName }) {
     writeAppShellFiles(dir, displayName);
     writeEnvExample(dir);
     writeEnvFile(dir);
+    writeVercelConfig(dir);
     writeAnhedralLogo(dir);
     writeSubscriptionProvider(dir);
     writeUseSubscription(dir);
-    anhedralPrint.step('Installing image picker + RevenueCat SDKs');
-    exec('pnpm exec expo install expo-image-picker', dir);
-    exec('pnpm add react-native-purchases react-native-purchases-ui @revenuecat/purchases-js', dir);
-    anhedralPrint.done('Additional mobile SDKs installed');
+    anhedralPrint.step('Installing Expo native packages');
+    if (skipInstall) {
+        anhedralPrint.info('Skipping Expo native package install (--skip-install)');
+        anhedralPrint.info('Run after init: pnpm --filter ./apps/frontend exec expo install --pnpm expo-image-picker');
+    }
+    else {
+        exec('pnpm exec expo install --pnpm expo-image-picker', dir);
+        exec('pnpm exec expo install --fix --pnpm', dir);
+    }
+    anhedralPrint.done(skipInstall ? 'Expo native package install skipped' : 'Expo native packages installed');
+    anhedralPrint.step('Installing RevenueCat SDKs');
+    const revenueCatDependencies = withVersions({
+        'react-native-purchases': FRONTEND_ADDON_DEPENDENCIES['react-native-purchases'],
+        'react-native-purchases-ui': FRONTEND_ADDON_DEPENDENCIES['react-native-purchases-ui'],
+        '@revenuecat/purchases-js': FRONTEND_ADDON_DEPENDENCIES['@revenuecat/purchases-js'],
+    });
+    if (skipInstall) {
+        anhedralPrint.info(`Skipping RevenueCat SDK install (--skip-install). Run after init: pnpm --filter ./apps/frontend add ${revenueCatDependencies.join(' ')}`);
+    }
+    else {
+        exec(`pnpm add ${revenueCatDependencies.join(' ')}`, dir);
+    }
+    anhedralPrint.done(skipInstall ? 'RevenueCat SDK install skipped' : 'Additional Expo SDKs installed');
 }
 function patchFrontendPackageJson(dir) {
     const filePath = path.join(dir, 'package.json');
     const packageJson = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    packageJson.dependencies = {
+        ...(packageJson.dependencies ?? {}),
+        '@anhedral/api-client': FRONTEND_ADDON_DEPENDENCIES['@anhedral/api-client'],
+        '@clerk/clerk-expo': FRONTEND_ADDON_DEPENDENCIES['@clerk/clerk-expo'],
+        'react-native-purchases': FRONTEND_ADDON_DEPENDENCIES['react-native-purchases'],
+        'react-native-purchases-ui': FRONTEND_ADDON_DEPENDENCIES['react-native-purchases-ui'],
+        '@revenuecat/purchases-js': FRONTEND_ADDON_DEPENDENCIES['@revenuecat/purchases-js'],
+    };
     packageJson.scripts = {
         ...(packageJson.scripts ?? {}),
-        build: 'pnpm typecheck',
+        build: 'pnpm typecheck && pnpm build:web',
+        'build:web': 'expo export --platform web',
         typecheck: 'tsc --noEmit',
     };
     writeFile(filePath, JSON.stringify(packageJson, null, 2) + '\n');
 }
-function writeApiClient(dir) {
-    writeFile(path.join(dir, 'api/client.ts'), `/**
- * API Client with SWR caching
- */
-
-const SWR_MAX_SIZE = 200;
-const SWR_DEFAULT_STALE_MS = 15_000;
-const SWR_DEFAULT_MAX_AGE_MS = 300_000;
-
-type SWREntry<T> = { data: T; fetchedAt: number; staleMs: number; maxAgeMs: number };
-const SWR_CACHE = new Map<string, SWREntry<unknown>>();
-const SWR_INFLIGHT = new Map<string, Promise<unknown>>();
-
-function swrEvict() {
-  if (SWR_CACHE.size <= SWR_MAX_SIZE) return;
-  const entries = [...SWR_CACHE.entries()].sort((a, b) => a[1].fetchedAt - b[1].fetchedAt);
-  const toRemove = entries.slice(0, entries.length - SWR_MAX_SIZE);
-  for (const [key] of toRemove) SWR_CACHE.delete(key);
-}
-
-export class APIRequestError extends Error {
-  constructor(
-    public statusCode: number,
-    message: string,
-    public errorCode?: string,
-  ) {
-    super(message);
-    this.name = 'APIRequestError';
-  }
-}
-
-export class APIClient {
-  constructor(
-    private baseUrl: string,
-    private getToken: () => Promise<string | null>,
-  ) {}
-
-  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
-    const token = await this.getToken();
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'X-Platform': 'web',
-    };
-    if (token) headers['Authorization'] = \`Bearer \${token}\`;
-
-    const res = await fetch(\`\${this.baseUrl}\${path}\`, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-    });
-
-    if (!res.ok) {
-      let err: { error?: string; message?: string } = {};
-      try { err = await res.json(); } catch {}
-      throw new APIRequestError(res.status, err.message || \`Request failed (\${res.status})\`, err.error);
-    }
-
-    if (res.status === 204) return {} as T;
-    return res.json();
-  }
-
-  async get<T>(path: string): Promise<T> { return this.request<T>('GET', path); }
-  async post<T>(path: string, body?: unknown): Promise<T> { return this.request<T>('POST', path, body); }
-  async delete<T>(path: string): Promise<T> { return this.request<T>('DELETE', path); }
-
-  async getCached<T>(
-    path: string,
-    opts?: { staleMs?: number; maxAgeMs?: number },
-  ): Promise<T> {
-    const staleMs = opts?.staleMs ?? SWR_DEFAULT_STALE_MS;
-    const maxAgeMs = opts?.maxAgeMs ?? SWR_DEFAULT_MAX_AGE_MS;
-    const now = Date.now();
-    const cached = SWR_CACHE.get(path) as SWREntry<T> | undefined;
-
-    if (cached) {
-      const age = now - cached.fetchedAt;
-      if (age < staleMs) return cached.data;
-      if (age < maxAgeMs) {
-        if (!SWR_INFLIGHT.has(path)) {
-          const p = this.get<T>(path).then((data) => {
-            SWR_CACHE.set(path, { data, fetchedAt: Date.now(), staleMs, maxAgeMs });
-            return data;
-          }).finally(() => SWR_INFLIGHT.delete(path));
-          SWR_INFLIGHT.set(path, p);
-        }
-        return cached.data;
-      }
-    }
-
-    const inflight = SWR_INFLIGHT.get(path) as Promise<T> | undefined;
-    if (inflight) return inflight;
-
-    const p = this.get<T>(path).then((data) => {
-      SWR_CACHE.set(path, { data, fetchedAt: Date.now(), staleMs, maxAgeMs });
-      swrEvict();
-      return data;
-    }).finally(() => SWR_INFLIGHT.delete(path));
-    SWR_INFLIGHT.set(path, p);
-    return p;
-  }
-
-  invalidateCache(path: string): void { SWR_CACHE.delete(path); }
-  invalidateCachePrefix(prefix: string): void {
-    for (const key of SWR_CACHE.keys()) {
-      if (key.startsWith(prefix)) SWR_CACHE.delete(key);
+function patchExpoAppConfig(dir) {
+    const filePath = path.join(dir, 'app.json');
+    if (!fs.existsSync(filePath)) {
+        return;
     }
-  }
-
-  clearAllCaches(): void {
-    SWR_CACHE.clear();
-    SWR_INFLIGHT.clear();
-  }
-
-  // ── Auth endpoints ──────────────────────────────────────────────────
-  async getMe() {
-    return this.get<{
-      user: {
-        id: string;
-        email: string;
-        firstName?: string | null;
-        lastName?: string | null;
-        displayName: string;
-        imageUrl?: string | null;
-        avatarUrl?: string | null;
-        creditsBalance: number;
-        subscriptionTier: string;
-        subscriptionStatus: string;
-      };
-    }>('/auth/me');
-  }
-
-  async signOut() {
-    return this.post<{ success: boolean }>('/auth/signout');
-  }
-
-  async uploadAvatar(input: { base64: string; mimeType: string; fileName?: string }) {
-    return this.post<{ ok: boolean; avatarUrl: string }>('/auth/avatar', input);
-  }
-
-  async deleteAccount() {
-    return this.delete<void>('/auth/account');
-  }
-
-  // ── Subscription endpoints ───────────────────────────────────────────
-  async getSubscriptionPricing() {
-    return this.getCached<{
-      tiers: { tier: string; displayName: string; description: string; priceMonthly: number | null; priceYearly: number | null; currency: string; limits: { dailyLimit: number | null }; paymentInfo?: { revenueCatEntitlementId: string; revenueCatOfferingId: string } }[];
-    }>('/subscriptions/pricing', { staleMs: 300_000, maxAgeMs: 3_600_000 });
-  }
+    const appJson = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    appJson.expo ??= {};
+    appJson.expo.web = {
+        ...(appJson.expo.web ?? {}),
+        bundler: 'metro',
+        output: 'static',
+    };
+    writeFile(filePath, JSON.stringify(appJson, null, 2) + '\n');
+}
+function writeApiClient(dir) {
+    writeFile(path.join(dir, 'api/client.ts'), `import { ApiClient, APIRequestError } from '@anhedral/api-client';
 
-  async getSubscriptionEntitlements(options?: { refresh?: boolean }) {
-    const path = options?.refresh ? '/subscriptions/entitlements/me?refresh=true' : '/subscriptions/entitlements/me';
-    return this.get<{
-      pro: boolean; inTrial: boolean; trialEndsAt?: string; expiresAt?: string;
-      periodStart?: string; periodEnd?: string;
-      method?: 'trialing' | 'redeemed' | 'paid' | null;
-      managementUrl?: string; cancelAtPeriodEnd?: boolean;
-    }>(path);
+export class APIClient extends ApiClient {
+  constructor(baseUrl: string, getToken: () => Promise<string | null>) {
+    super({ baseUrl, getToken, platform: 'frontend' });
   }
 
-  async redeemPromoCode(code: string) {
-    return this.post<{ ok: boolean; expiresAt: string }>('/subscriptions/redeem', { code });
+  redeemPromoCode(code: string) {
+    return this.redeemCode(code);
   }
 }
 
-export { SWR_CACHE };
+export { APIRequestError };
 `);
     writeFile(path.join(dir, 'api/index.ts'), `export { APIClient, APIRequestError } from './client';
 `);
@@ -284,6 +180,22 @@ export function useAPI() {
 }
 `);
 }
+function writeVercelConfig(dir) {
+    writeFile(path.join(dir, 'vercel.json'), JSON.stringify({
+        $schema: 'https://openapi.vercel.sh/vercel.json',
+        buildCommand: 'pnpm build:web',
+        outputDirectory: 'dist',
+        devCommand: 'pnpm dev',
+        cleanUrls: true,
+        framework: null,
+        rewrites: [
+            {
+                source: '/:path*',
+                destination: '/index.html',
+            },
+        ],
+    }, null, 2) + '\n');
+}
 function writeAccountHook(dir) {
     writeFile(path.join(dir, 'hooks/useAccount.ts'), `import { useAuth } from '@clerk/clerk-expo';
 import * as React from 'react';
@@ -859,7 +771,7 @@ import { ScrollView, View } from 'react-native';
 const FEATURES = [
   {
     title: 'Landing page here',
-    description: 'Replace this placeholder copy with the actual acquisition story for your mobile and web app.',
+    description: 'Replace this placeholder copy with the actual acquisition story for your Expo app.',
     icon: CloudIcon,
   },
   {