@macedon-technologies/batman 1.26.1 → 1.28.0

package/lib/ViteReactProject.js

@@ -295,23 +295,82 @@ ${baseConfigType}
 
 ${configTypeDefinition}
 
-export function useConfig() {
-  const [loadedConfig, setLoadedConfig] = useState<Config|undefined>();
-  const [isLoading, setIsLoading] = useState(false);
+let shared: Promise<Config> | undefined;
+let loaded: Config | undefined;
 
-  useEffect(() => {
-    if (!loadedConfig) {
-      fetch('/config.json', { cache: 'no-store' }).then(response=>{
-        response.json().then((config) => {
-          setIsLoading(false)
-          setLoadedConfig(config)
-        });
+/** How long the shared load of /config.json may take before it is abandoned and fails. */
+export const CONFIG_LOAD_TIMEOUT_MS = 15 * 1000;
+
+/**
+ * The runtime config, loaded once and shared by every useConfig(); a failed load, including one
+ * abandoned after CONFIG_LOAD_TIMEOUT_MS, is tried again by the next caller.
+ */
+export function loadConfig(): Promise<Config> {
+  if (!shared) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CONFIG_LOAD_TIMEOUT_MS);
+    const load: Promise<Config> = fetch('/config.json', { cache: 'no-store', signal: controller.signal })
+      .then((response) => {
+        if (!response.ok) {
+          throw new Error(\`Loading /config.json failed with status \${response.status}\`);
+        }
+        return response.json() as Promise<Config>;
+      })
+      .finally(() => clearTimeout(timer))
+      .then((config) => {
+        if (shared === load) {
+          loaded = config;
+        }
+        return config;
       });
+    load.catch(() => {
+      if (shared === load) {
+        shared = undefined;
+      }
+    });
+    shared = load;
+  }
+  return shared;
+}
+
+/** Forgets the shared config, so each test loads its own. */
+export function resetConfigForTests(): void {
+  shared = undefined;
+  loaded = undefined;
+}
+
+export function useConfig() {
+  const [loadedConfig, setLoadedConfig] = useState<Config | undefined>(loaded);
+  const [isLoading, setIsLoading] = useState(!loaded);
+  const [error, setError] = useState<unknown>();
 
+  useEffect(() => {
+    if (loadedConfig) {
+      return undefined;
     }
+    let live = true;
+    setIsLoading(true);
+    setError(undefined);
+    loadConfig().then(
+      (config) => {
+        if (live) {
+          setLoadedConfig(config);
+          setIsLoading(false);
+        }
+      },
+      (err) => {
+        if (live) {
+          setError(err);
+          setIsLoading(false);
+        }
+      },
+    );
+    return () => {
+      live = false;
+    };
   }, [loadedConfig]);
 
-  return { config: loadedConfig, isLoading };
+  return { config: loadedConfig, isLoading, error };
 }
 `;
     }
@@ -437,11 +496,11 @@ class ViteSampleCode extends projen_1.Component {
         new projen_1.SampleFile(project, `${options.srcdir}/App.tsx`, {
             contents: `import './App.css'
 import { SignedIn, UserButton } from '@clerk/clerk-react';
-import { useBaseQuery } from "./services/BaseService.ts";
+import { useApiQuery } from "./services/ApiService.ts";
 
 
 function App() {
-  const {data, isLoading} = useBaseQuery('/', {retryOnMount: true});
+  const {data, isLoading} = useApiQuery('/', {retryOnMount: true});
 
 
   return (
@@ -462,65 +521,7 @@ function App() {
 export default App
 `,
         });
-        // Create BaseService.ts
-        new projen_1.TextFile(project, `${options.srcdir}/services/BaseService.ts`, {
-            marker: true,
-            readonly: true,
-            lines: [
-                'import { useQuery, UseQueryOptions } from \'@tanstack/react-query\';',
-                'import { useAuth } from \'@clerk/clerk-react\';',
-                'import { useConfig } from \'../config\';',
-                '',
-                'export function useBaseQuery<TData = unknown>(',
-                '  path: string,',
-                '  options?: Omit<UseQueryOptions<TData>, \'queryKey\' | \'queryFn\'>',
-                ') {',
-                '  const { config } = useConfig();',
-                '  const { getToken } = useAuth();',
-                '',
-                '  return useQuery<TData>({',
-                '    queryKey: [\'base\'],',
-                '    queryFn: async () => {',
-                '      if (!config?.apiBaseUrl) {',
-                '        throw new Error(\'API base URL not configured\');',
-                '      }',
-                '',
-                '      const token = await getToken();',
-                '',
-                '      // Normalize URL by removing trailing slash from baseUrl and ensuring path starts with slash',
-                '      const baseUrl = config.apiBaseUrl.replace(/\\/+$/, \'\');',
-                '      const normalizedPath = path.startsWith(\'/\') ? path : `/${path}`;',
-                '      ',
-                '      const response = await fetch(`${baseUrl}${normalizedPath}`, {',
-                '        headers: {',
-                '          \'Authorization\': `Bearer ${token}`,',
-                '        },',
-                '      });',
-                '',
-                '      if (!response.ok) {',
-                '        throw new Error(`HTTP error! status: ${response.status}`);',
-                '      }',
-                '',
-                '      return response.json();',
-                '    },',
-                '    enabled: !!config?.apiBaseUrl,',
-                '    ...options,',
-                '  });',
-                '}',
-            ],
-        });
-        // Create RootService.ts
-        new projen_1.SampleFile(project, `${options.srcdir}/services/RootService.ts`, {
-            contents: `import { UseQueryOptions } from '@tanstack/react-query';
-import { useBaseQuery } from './BaseService';
-
-export function useRootQuery<TData = unknown>(
-  options?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>
-) {
-  return useBaseQuery<TData>('/', options);
-}
-`,
-        });
+        new ApiServiceFiles(project, { srcdir: options.srcdir });
         // Create App.css
         new projen_1.SampleFile(project, `${options.srcdir}/App.css`, {
             contents: `#root {
@@ -576,8 +577,15 @@ import { useConfig } from './config'
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 
 function AppWrapper() {
-  const { config, isLoading } = useConfig();
+  const { config, isLoading, error } = useConfig();
   const queryClient = new QueryClient()
+  if (error) {
+    return (
+      <div className="loading-screen">
+        Could not load the app configuration.
+      </div>
+    );
+  }
   if (isLoading || !config) {
     return (
       <div className="loading-screen">
@@ -673,6 +681,395 @@ html, body, #root {
         });
     }
 }
+/**
+ * Bootstraps the web client's API layer: `services/ApiService.ts` (query and mutation hooks
+ * keyed per path) and the `helpers/` it is built on. Written once, then owned by the consumer.
+ */
+class ApiServiceFiles extends projen_1.Component {
+    constructor(project, options) {
+        super(project);
+        new projen_1.SampleFile(project, `${options.srcdir}/services/ApiService.ts`, {
+            contents: `import { useAuth } from '@clerk/clerk-react';
+import { QueryClient, useMutation, UseMutationOptions, useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { useEffect, useMemo, useRef } from 'react';
+import { loadConfig, useConfig } from '../config';
+import { RequestCancelledError } from '../helpers/HttpError';
+import { get, post, put, RequestOptions, TokenGetter } from '../helpers/requests';
+
+/** The React Query key for an API path: its segments, so a prefix's key covers every path under it. */
+export function apiQueryKey(path: string): string[] {
+  return path.split('/').filter(Boolean);
+}
+
+export function invalidateApiQueries(queryClient: QueryClient, prefix: string): Promise<void> {
+  return queryClient.invalidateQueries({ queryKey: apiQueryKey(prefix), exact: false });
+}
+
+export function useApiQuery<TData = unknown>(
+  path: string,
+  options?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>,
+) {
+  const { config } = useConfig();
+  const { getToken } = useAuth();
+  const { enabled, ...restOptions } = options ?? {};
+
+  return useQuery<TData>({
+    queryKey: apiQueryKey(path),
+    queryFn: ({ signal }) => get<TData>(config!.apiBaseUrl, path, getToken as TokenGetter, { signal }),
+    ...restOptions,
+    // A caller's \`enabled\` narrows the config gate rather than replacing it: \`queryFn\` needs the config.
+    enabled: (enabled ?? true) && !!config?.apiBaseUrl,
+  });
+}
+
+export interface ApiClient {
+  get<TData = unknown>(path: string, options?: RequestOptions): Promise<TData>;
+  post<TData = unknown>(path: string, body: unknown, options?: RequestOptions): Promise<TData>;
+  put<TData = unknown>(path: string, body: unknown, options?: RequestOptions): Promise<TData>;
+}
+
+/**
+ * Calls the API imperatively, reading the runtime config and the token getter at the moment of
+ * each call. A call made before the config has arrived waits for the shared load, and fails
+ * when that load fails.
+ */
+export function useApiClient(): ApiClient {
+  const { config } = useConfig();
+  const { getToken } = useAuth();
+  const latest = useRef({ config, getToken });
+  useEffect(() => {
+    latest.current = { config, getToken };
+  }, [config, getToken]);
+
+  return useMemo(() => {
+    const untilCancelled = (signal: AbortSignal | undefined) => new Promise<never>((_, reject) => {
+      if (signal?.aborted) {
+        reject(new RequestCancelledError());
+      }
+      signal?.addEventListener('abort', () => reject(new RequestCancelledError()), { once: true });
+    });
+    const apiBaseUrl = async (signal: AbortSignal | undefined): Promise<string> => {
+      const config = latest.current.config
+        ?? await Promise.race([loadConfig().catch(() => undefined), untilCancelled(signal)]);
+      if (!config?.apiBaseUrl) {
+        throw new Error('API base URL not configured');
+      }
+      return config.apiBaseUrl;
+    };
+    const token: TokenGetter = () => (latest.current.getToken as TokenGetter)();
+    return {
+      get: async <TData>(path: string, options?: RequestOptions) =>
+        get<TData>(await apiBaseUrl(options?.signal), path, token, options),
+      post: async <TData>(path: string, body: unknown, options?: RequestOptions) =>
+        post<TData>(await apiBaseUrl(options?.signal), path, body, token, options),
+      put: async <TData>(path: string, body: unknown, options?: RequestOptions) =>
+        put<TData>(await apiBaseUrl(options?.signal), path, body, token, options),
+    };
+  }, []);
+}
+
+type ApiMutationVariables = { path: string; body: unknown; signal?: AbortSignal };
+
+export function useApiMutation<TData = unknown>(
+  method: 'POST' | 'PUT',
+  options?: Omit<UseMutationOptions<TData, unknown, ApiMutationVariables>, 'mutationFn'>,
+) {
+  const client = useApiClient();
+
+  return useMutation<TData, unknown, ApiMutationVariables>({
+    mutationFn: ({ path, body, signal }) =>
+      method === 'POST' ? client.post<TData>(path, body, { signal }) : client.put<TData>(path, body, { signal }),
+    ...options,
+  });
+}
+`,
+        });
+        new projen_1.SampleFile(project, `${options.srcdir}/helpers/requests.ts`, {
+            contents: `import { HttpError, RequestCancelledError, RequestTimeoutError, type HttpErrorDetails } from './HttpError';
+
+export type TokenGetter = () => Promise<string | null | undefined>;
+
+/**
+ * How long a request may go unanswered before it fails. It stays above the longest CloudFront
+ * can take to give any answer: three 10 s connection attempts to the API origin plus its 30 s
+ * response timeout. The local dev server has no limit of its own, so there this is the only one.
+ */
+export const API_REQUEST_TIMEOUT_MS = 65 * 1000;
+
+export interface RequestOptions {
+  readonly signal?: AbortSignal;
+  /** Called when the API rejects the caller's session (a 401), before the error is thrown. */
+  readonly onSessionRejected?: () => void;
+}
+
+interface Deadline {
+  readonly signal: AbortSignal;
+  /** Settles with \`promise\`, or rejects as soon as the request is abandoned. */
+  race<T>(promise: Promise<T>): Promise<T>;
+  /** Why the request was abandoned, or \`undefined\` while it is still live. */
+  readonly abandonment: HttpError | undefined;
+}
+
+async function withDeadline<T>(callerSignal: AbortSignal | undefined, run: (deadline: Deadline) => Promise<T>): Promise<T> {
+  const controller = new AbortController();
+  let abandonment: HttpError | undefined;
+  const abandoned = new Promise<never>((_, reject) => {
+    controller.signal.addEventListener('abort', () => reject(abandonment), { once: true });
+  });
+  abandoned.catch(() => undefined);
+
+  const abandon = (error: HttpError) => {
+    if (!abandonment) {
+      abandonment = error;
+      controller.abort();
+    }
+  };
+  const timer = setTimeout(() => abandon(new RequestTimeoutError()), API_REQUEST_TIMEOUT_MS);
+  const cancel = () => abandon(new RequestCancelledError());
+  if (callerSignal?.aborted) {
+    cancel();
+  } else {
+    callerSignal?.addEventListener('abort', cancel, { once: true });
+  }
+
+  try {
+    return await run({
+      signal: controller.signal,
+      race: (promise) => Promise.race([promise, abandoned]),
+      get abandonment() {
+        return abandonment;
+      },
+    });
+  } finally {
+    clearTimeout(timer);
+    callerSignal?.removeEventListener('abort', cancel);
+  }
+}
+
+function buildUrl(apiBaseUrl: string, path: string): string {
+  const baseUrl = apiBaseUrl.replace(/\\/+$/, '');
+  const normalizedPath = path.startsWith('/') ? path : \`/\${path}\`;
+  return \`\${baseUrl}\${normalizedPath}\`;
+}
+
+async function request(
+  method: 'GET' | 'POST' | 'PUT',
+  apiBaseUrl: string,
+  path: string,
+  getToken: TokenGetter,
+  deadline: Deadline,
+  body: unknown,
+  onSessionRejected: (() => void) | undefined,
+): Promise<Response> {
+  let response: Response;
+  try {
+    const token = await deadline.race(getToken());
+    response = await fetch(buildUrl(apiBaseUrl, path), {
+      method,
+      headers: {
+        Authorization: \`Bearer \${token ?? ''}\`,
+        ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+      },
+      ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+      signal: deadline.signal,
+    });
+  } catch (error) {
+    throw incomplete(method, path, deadline, error);
+  }
+
+  if (!response.ok) {
+    const parsed = await deadline.race(parseErrorBody(response)).catch(() => undefined);
+    if (!parsed) {
+      throw incomplete(method, path, deadline, undefined);
+    }
+    const { error, message, details } = parsed;
+    console.error(\`[api] \${method} \${path} responded \${response.status}: \${message}\`);
+    if (response.status === 401) {
+      onSessionRejected?.();
+    }
+    throw new HttpError(response.status, error, message, details);
+  }
+
+  return response;
+}
+
+/**
+ * The error for a request that got no usable answer, logged before it is thrown so a caller
+ * that swallows it still leaves a trace. A caller's own cancellation is not logged.
+ */
+function incomplete(method: string, path: string, deadline: Deadline, cause: unknown): HttpError {
+  const abandonment = deadline.abandonment;
+  if (abandonment instanceof RequestCancelledError) {
+    return abandonment;
+  }
+  if (abandonment) {
+    console.error(\`[api] \${method} \${path} timed out after \${API_REQUEST_TIMEOUT_MS} ms\`);
+    return abandonment;
+  }
+  const message = cause instanceof Error ? cause.message : 'Failed to reach the API';
+  console.error(\`[api] \${method} \${path} failed to reach the API: \${message}\`);
+  return new HttpError(0, 'Network Error', message);
+}
+
+function send<TData = unknown>(
+  method: 'GET' | 'POST' | 'PUT',
+  apiBaseUrl: string,
+  path: string,
+  getToken: TokenGetter,
+  body: unknown,
+  { signal, onSessionRejected }: RequestOptions = {},
+): Promise<TData> {
+  return withDeadline(signal, async (deadline) => {
+    const response = await request(method, apiBaseUrl, path, getToken, deadline, body, onSessionRejected);
+    try {
+      return await deadline.race(response.json());
+    } catch (error) {
+      if (deadline.abandonment) {
+        throw incomplete(method, path, deadline, error);
+      }
+      throw error;
+    }
+  });
+}
+
+/** Every field of an error body other than \`error\` and \`message\`. */
+function detailsOf(body: Record<string, unknown>): HttpErrorDetails {
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'error' && key !== 'message'));
+}
+
+async function parseErrorBody(response: Response): Promise<{ error: string; message: string; details: HttpErrorDetails }> {
+  try {
+    const body = await response.json();
+    if (body && typeof body.message === 'string') {
+      return {
+        error: typeof body.error === 'string' ? body.error : response.statusText,
+        message: body.message,
+        details: detailsOf(body),
+      };
+    }
+  } catch {
+    // Not JSON (e.g. a proxy's error page): fall through to the generic error below.
+  }
+  return { error: response.statusText || 'Error', message: \`HTTP error! status: \${response.status}\`, details: {} };
+}
+
+export function get<TData = unknown>(
+  apiBaseUrl: string,
+  path: string,
+  getToken: TokenGetter,
+  options?: RequestOptions,
+): Promise<TData> {
+  return send<TData>('GET', apiBaseUrl, path, getToken, undefined, options);
+}
+
+export function post<TData = unknown>(
+  apiBaseUrl: string,
+  path: string,
+  body: unknown,
+  getToken: TokenGetter,
+  options?: RequestOptions,
+): Promise<TData> {
+  return send<TData>('POST', apiBaseUrl, path, getToken, body, options);
+}
+
+export function put<TData = unknown>(
+  apiBaseUrl: string,
+  path: string,
+  body: unknown,
+  getToken: TokenGetter,
+  options?: RequestOptions,
+): Promise<TData> {
+  return send<TData>('PUT', apiBaseUrl, path, getToken, body, options);
+}
+`,
+        });
+        new projen_1.SampleFile(project, `${options.srcdir}/helpers/HttpError.ts`, {
+            contents: `/** The fields an error body carries beyond \`error\` and \`message\`. */
+export type HttpErrorDetails = Readonly<Record<string, unknown>>;
+
+/**
+ * A failed API request: the HTTP status (0 when the API gave no answer) and the error body's
+ * \`error\` and \`message\`, with any other fields it carries as \`details\`.
+ */
+export class HttpError extends Error {
+  status: number;
+  error: string;
+  details: HttpErrorDetails;
+
+  constructor(status: number, error: string, message: string, details: HttpErrorDetails = {}) {
+    super(message);
+    this.name = 'HttpError';
+    this.status = status;
+    this.error = error;
+    this.details = details;
+  }
+}
+
+/** The API did not answer within the client's bound. */
+export class RequestTimeoutError extends HttpError {
+  constructor() {
+    super(0, 'Timeout', 'The server took too long to respond. Please try again.');
+    this.name = 'RequestTimeoutError';
+  }
+}
+
+/** The caller cancelled the request before the API answered. */
+export class RequestCancelledError extends HttpError {
+  constructor() {
+    super(0, 'Aborted', 'The request was cancelled.');
+    this.name = 'RequestCancelledError';
+  }
+}
+
+/** Whether \`error\`'s message was written for the person using the app: a refusal (4xx) or a timeout. */
+export function isUserFacing(error: unknown): error is HttpError {
+  return error instanceof RequestTimeoutError || (error instanceof HttpError && error.status >= 400 && error.status < 500);
+}
+`,
+        });
+        new projen_1.SampleFile(project, `${options.srcdir}/helpers/errors.ts`, {
+            contents: `import { HttpError } from './HttpError';
+
+/** A 5xx's message is the server's, not written for the person using the app, so it gets the default. */
+export function getErrorMessage(error: unknown, defaultMessage: string): string {
+  if (error instanceof HttpError && error.status >= 500) {
+    return defaultMessage;
+  }
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return defaultMessage;
+}
+`,
+        });
+        new projen_1.SampleFile(project, `${options.srcdir}/helpers/retry.ts`, {
+            contents: `import { HttpError, RequestCancelledError } from './HttpError';
+
+/** React Query's own default: three retries after the first failure. */
+const MAX_RETRIES = 3;
+
+/**
+ * A query \`retry\` that never retries a 401, because the API will reject the same token again.
+ * Everything else gets React Query's default.
+ */
+export function retryUnlessRejected(failureCount: number, error: unknown): boolean {
+  if (error instanceof HttpError && error.status === 401) {
+    return false;
+  }
+  return failureCount < MAX_RETRIES;
+}
+
+/**
+ * A failure worth trying again unchanged: the API answered 5xx, or was not reached or did not
+ * answer in time (status 0). A cancellation is not one: whoever cancelled wants it stopped.
+ */
+export function isTransientFailure(error: unknown): boolean {
+  return error instanceof HttpError && !(error instanceof RequestCancelledError) && (error.status === 0 || error.status >= 500);
+}
+`,
+        });
+    }
+}
 /**
  * Adds Playwright e2e testing support: devDeps, a `test:e2e` task, e2e-related
  * .gitignore entries, and a scaffolded (one-time, not regenerated on synth)
@@ -959,4 +1356,4 @@ gh secret set E2E_CLERK_USER_ID
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViteReactProject.js","sourceRoot":"","sources":["../src/ViteReactProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative, basename } from 'path';\nimport { Component, FileBase, JsonFile, Project, SampleFile, TextFile } from 'projen';\nimport { TypeScriptAppProject, TypeScriptProjectOptions } from 'projen/lib/typescript';\nimport { BatmanProject } from './BatmanProject';\nimport { runScriptCommand } from './utils';\n\nexport interface ViteReactProjectOptions extends TypeScriptProjectOptions {\n  /**\n   * Whether to generate sample code\n   * @default true\n   */\n  readonly sampleCode?: boolean;\n\n  /**\n   * Source directory\n   * @default \"src\"\n   */\n  readonly srcdir?: string;\n\n  /**\n   * Public directory for static assets\n   * @default \"public\"\n   */\n  readonly publicDir?: string;\n\n  /**\n   * Title for the HTML page\n   * @default project name\n   */\n  readonly title?: string;\n\n  /**\n   * Whether to add Playwright e2e testing support (devDeps, a `test:e2e` task,\n   * and a scaffolded `playwright.config.ts` + `e2e/` starter suite).\n   * @default true\n   */\n  readonly e2eTesting?: boolean;\n}\n\n/**\n * Vite + React TypeScript project\n */\nexport class ViteReactProject extends TypeScriptAppProject {\n  public readonly srcdir: string;\n  public readonly publicDir: string;\n  public readonly devCommand: string;\n  private readonly configFields: Map<string, string>;\n\n  constructor(options: ViteReactProjectOptions) {\n    const {\n      sampleCode = true,\n      srcdir = 'src',\n      publicDir = 'public',\n      title,\n      e2eTesting = true,\n      ...restOptions\n    } = options;\n    super({\n      ...restOptions,\n      sampleCode: false, // We'll handle sample code ourselves\n      eslint: false, // We'll configure eslint ourselves\n      jest: false, // Vite uses vitest typically\n      package: true,\n      disableTsconfig: true, // We'll manage tsconfig ourselves\n      packageManager: (restOptions.parent as BatmanProject).package.packageManager,\n      pnpmOptions: {\n        workspaceYamlOptions: {\n          // This subproject has its own separate lockfile/store from its parent,\n          // so it needs its own approval for the native postinstall scripts its\n          // fixed dependency set always needs (esbuild's binary download, and\n          // @clerk/clerk-react's transitive @clerk/shared setup script).\n          allowBuilds: {\n            'esbuild': true,\n            '@clerk/shared': true,\n          },\n          ...restOptions.pnpmOptions?.workspaceYamlOptions,\n        },\n      },\n      deps: [\n        '@clerk/clerk-react',\n        '@tanstack/react-query',\n        '@tailwindcss/postcss',\n        'autoprefixer',\n        'postcss',\n        'tailwindcss',\n        'rollup',\n        ...(options.deps ? options.deps : []),\n      ],\n    });\n\n    // Initialize config fields storage\n    this.configFields = new Map<string, string>();\n\n    this.srcdir = srcdir;\n    this.publicDir = publicDir;\n\n    // Add Vite component\n    new ViteComponent(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add ESLint configuration\n    new ViteEslintConfig(this);\n\n    // Add index.html\n    new IndexHtml(this, {\n      title: title ?? this.name,\n      srcdir: this.srcdir,\n    });\n\n    // Add TypeScript configs\n    new ViteTsConfigs(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add .gitignore entries\n    this.gitignore?.addPatterns('dist', 'dist-ssr', '*.local');\n\n    // Add vite-env.d.ts for type declarations\n    new ViteEnvDts(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add PostCSS config for Tailwind\n    new PostCSSConfigFile(this);\n\n    // Add config.ts for runtime configuration\n    new ConfigFile(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add sample config.json\n    new ConfigJsonFile(this, { });\n\n\n    // Add sample code if requested\n    if (sampleCode) {\n      new ViteSampleCode(this, {\n        srcdir: this.srcdir,\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Add Playwright e2e testing support\n    if (e2eTesting) {\n      new PlaywrightE2EComponent(this, {\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Use relative path for devCommand\n    const relativeOutdir = this.parent\n      ? relative(this.parent.outdir, this.outdir)\n      : basename(this.outdir);\n    this.devCommand = `cd ${relativeOutdir} && ${runScriptCommand(this.package.packageManager, 'dev')}`;\n  }\n\n  /**\n   * Add a custom field to the Config type\n   * @param fieldName The name of the field\n   * @param fieldType The TypeScript type of the field (e.g., 'string', 'number', 'boolean', 'string[]')\n   * @returns this project instance for chaining\n   */\n  addConfigField(fieldName: string, fieldType: string): this {\n    this.configFields.set(fieldName, fieldType);\n    return this;\n  }\n\n  /**\n   * Get the config fields map (for internal use by ConfigFile)\n   * @internal\n   */\n  getConfigFields(): Map<string, string> {\n    return this.configFields;\n  }\n}\n\ninterface ViteComponentOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Configures Vite dependencies and scripts\n */\nclass ViteComponent extends Component {\n  constructor(project: TypeScriptAppProject, _options: ViteComponentOptions) {\n    super(project);\n\n    const tsProject = project as TypeScriptAppProject;\n\n    // Set package type to module for ESM support\n    tsProject.package.addField('type', 'module');\n\n    // Add React dependencies\n    tsProject.addDeps('react@^19.2.0', 'react-dom@^19.2.0');\n\n    // Add dev dependencies\n    tsProject.addDevDeps(\n      '@types/react@^19.2.2',\n      '@types/react-dom@^19.2.2',\n      '@vitejs/plugin-react@^5.1.0',\n      'vite@^5.4.0',\n      'typescript@~5.9.3',\n      '@eslint/js@^9.39.1',\n      'eslint@^9.39.1',\n      'eslint-plugin-react-hooks@^5.2.0',\n      'eslint-plugin-react-refresh@^0.4.24',\n      'globals@^16.5.0',\n      'typescript-eslint@^8.46.3',\n    );\n\n    // Create vite.config.ts as a managed file\n    new ViteConfigFile(project);\n\n    // Add scripts\n    tsProject.addTask('dev', {\n      description: 'Start development server',\n      exec: 'vite',\n    });\n\n    // Remove and recreate build task to customize it for Vite\n    tsProject.removeTask('build');\n    tsProject.addTask('build', {\n      description: 'Build for production',\n      exec: 'tsc -b && vite build',\n    });\n\n    tsProject.addTask('preview', {\n      description: 'Preview production build',\n      exec: 'vite preview',\n    });\n\n    tsProject.addTask('lint', {\n      description: 'Lint code',\n      exec: 'eslint .',\n    });\n  }\n}\n\n/**\n * Creates the ESLint configuration for Vite + React\n */\nclass ViteEslintConfig extends FileBase {\n  constructor(project: Project) {\n    super(project, 'eslint.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import js from '@eslint/js'\nimport globals from 'globals'\nimport reactHooks from 'eslint-plugin-react-hooks'\nimport reactRefresh from 'eslint-plugin-react-refresh'\nimport tseslint from 'typescript-eslint'\n\nexport default [\n  { ignores: ['dist'] },\n  {\n    files: ['**/*.{ts,tsx}'],\n    languageOptions: {\n      ecmaVersion: 2020,\n      globals: globals.browser,\n    },\n    plugins: {\n      'react-hooks': reactHooks,\n      'react-refresh': reactRefresh,\n    },\n    rules: {\n      ...reactHooks.configs.recommended.rules,\n      'react-refresh/only-export-components': [\n        'warn',\n        { allowConstantExport: true },\n      ],\n    },\n  },\n  js.configs.recommended,\n  ...tseslint.configs.recommended,\n]\n`;\n  }\n}\n\n/**\n * Creates the vite.config.ts file\n */\nclass ViteConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'vite.config.ts', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import { defineConfig } from 'vite'\nimport react from '@vitejs/plugin-react'\n\n// https://vite.dev/config/\nexport default defineConfig({\n  plugins: [react()],\n})\n`;\n  }\n}\n\n/**\n * Creates the postcss.config.js file for Tailwind CSS v4\n */\nclass PostCSSConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'postcss.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `export default {\n  plugins: {\n    \"@tailwindcss/postcss\": {},\n    autoprefixer: {},\n  },\n}\n`;\n  }\n}\n\ninterface ViteEnvDtsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the vite-env.d.ts file for type declarations\n */\nclass ViteEnvDts extends FileBase {\n  constructor(project: Project, options: ViteEnvDtsOptions) {\n    super(project, `${options.srcdir}/vite-env.d.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `/// <reference types=\"vite/client\" />\n`;\n  }\n}\n\ninterface ConfigFileOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the config.ts file for runtime configuration\n */\nclass ConfigFile extends FileBase {\n  constructor(project: Project, options: ConfigFileOptions) {\n    super(project, `${options.srcdir}/config.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    // Get custom config fields from parent project\n    const viteProject = this.project as ViteReactProject;\n    const customFields = viteProject.getConfigFields();\n\n    // Generate base config type\n    const baseConfigType = `type BaseConfig = {\n  clerkPublishableKey: string;\n  apiBaseUrl: string;\n  timeout: number;\n}`;\n\n    // Generate custom fields type if any exist\n    let configTypeDefinition: string;\n    if (customFields.size > 0) {\n      const fieldDefinitions = Array.from(customFields.entries())\n        .map(([name, type]) => `  ${name}: ${type};`)\n        .join('\\n');\n\n      const customFieldsType = `type CustomConfig = {\n${fieldDefinitions}\n}`;\n\n      configTypeDefinition = `${customFieldsType}\n\nexport type Config = BaseConfig & CustomConfig;`;\n    } else {\n      configTypeDefinition = 'export type Config = BaseConfig;';\n    }\n\n    return `import { useEffect, useState } from 'react';\n\n${baseConfigType}\n\n${configTypeDefinition}\n\nexport function useConfig() {\n  const [loadedConfig, setLoadedConfig] = useState<Config|undefined>();\n  const [isLoading, setIsLoading] = useState(false);\n\n  useEffect(() => {\n    if (!loadedConfig) {\n      fetch('/config.json', { cache: 'no-store' }).then(response=>{\n        response.json().then((config) => {\n          setIsLoading(false)\n          setLoadedConfig(config)\n        });\n      });\n\n    }\n  }, [loadedConfig]);\n\n  return { config: loadedConfig, isLoading };\n}\n`;\n  }\n}\n\ninterface ConfigJsonFileOptions {}\n\n/**\n * Creates the config.json sample file for runtime configuration\n */\nclass ConfigJsonFile extends SampleFile {\n  path: string;\n  constructor(project: ViteReactProject, _options: ConfigJsonFileOptions) {\n    super(project, `${project.publicDir}/config.json`, {\n      contents: JSON.stringify({\n        apiBaseUrl: 'http://localhost:3000/api',\n        clerkPublishableKey: 'tbd',\n      }, null, 2),\n    });\n    this.path = `${project.publicDir}/config.json`;\n  }\n}\n\ninterface IndexHtmlOptions {\n  readonly title: string;\n  readonly srcdir: string;\n}\n\n/**\n * Creates the index.html file\n */\nclass IndexHtml extends SampleFile {\n  constructor(project: Project, options: IndexHtmlOptions) {\n    super(project, 'index.html', {\n      contents: `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/vite.svg\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>${options.title}</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/${options.srcdir}/main.tsx\"></script>\n  </body>\n</html>\n`,\n    });\n  }\n}\n\ninterface ViteTsConfigsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the TypeScript configuration files for Vite\n */\nclass ViteTsConfigs extends Component {\n  constructor(project: Project, options: ViteTsConfigsOptions) {\n    super(project);\n\n    // Main tsconfig.json (project references)\n    new JsonFile(project, 'tsconfig.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        files: [],\n        references: [\n          { path: './tsconfig.app.json' },\n          { path: './tsconfig.node.json' },\n        ],\n      },\n    });\n\n    // tsconfig.app.json (for application code)\n    new JsonFile(project, 'tsconfig.app.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2020',\n          useDefineForClassFields: true,\n          lib: ['ES2020', 'DOM', 'DOM.Iterable'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n          jsx: 'react-jsx',\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n          noUncheckedSideEffectImports: true,\n        },\n        include: [options.srcdir],\n      },\n    });\n\n    // tsconfig.node.json (for Vite config)\n    new JsonFile(project, 'tsconfig.node.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2022',\n          lib: ['ES2023'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n        },\n        include: ['vite.config.ts'],\n      },\n    });\n  }\n}\n\ninterface ViteSampleCodeOptions {\n  readonly srcdir: string;\n  readonly publicDir: string;\n}\n\n/**\n * Generates sample code for a Vite + React project\n */\nclass ViteSampleCode extends Component {\n  constructor(project: Project, options: ViteSampleCodeOptions) {\n    super(project);\n\n    // Create App.tsx\n    new SampleFile(project, `${options.srcdir}/App.tsx`, {\n      contents: `import './App.css'\nimport { SignedIn, UserButton } from '@clerk/clerk-react';\nimport { useBaseQuery } from \"./services/BaseService.ts\";\n\n\nfunction App() {\n  const {data, isLoading} = useBaseQuery('/', {retryOnMount: true});\n\n\n  return (\n    <>\n        <header>\n\n          <SignedIn>\n            <UserButton/>\n          </SignedIn>\n        </header>\n        <div className=\"card\">\n          { isLoading ? 'Loading...' : JSON.stringify(data, null ,)}\n        </div>\n    </>\n  )\n}\n\nexport default App\n`,\n    });\n\n    // Create BaseService.ts\n    new TextFile(project, `${options.srcdir}/services/BaseService.ts`, {\n      marker: true,\n      readonly: true,\n      lines: [\n        'import { useQuery, UseQueryOptions } from \\'@tanstack/react-query\\';',\n        'import { useAuth } from \\'@clerk/clerk-react\\';',\n        'import { useConfig } from \\'../config\\';',\n        '',\n        'export function useBaseQuery<TData = unknown>(',\n        '  path: string,',\n        '  options?: Omit<UseQueryOptions<TData>, \\'queryKey\\' | \\'queryFn\\'>',\n        ') {',\n        '  const { config } = useConfig();',\n        '  const { getToken } = useAuth();',\n        '',\n        '  return useQuery<TData>({',\n        '    queryKey: [\\'base\\'],',\n        '    queryFn: async () => {',\n        '      if (!config?.apiBaseUrl) {',\n        '        throw new Error(\\'API base URL not configured\\');',\n        '      }',\n        '',\n        '      const token = await getToken();',\n        '',\n        '      // Normalize URL by removing trailing slash from baseUrl and ensuring path starts with slash',\n        '      const baseUrl = config.apiBaseUrl.replace(/\\\\/+$/, \\'\\');',\n        '      const normalizedPath = path.startsWith(\\'/\\') ? path : `/${path}`;',\n        '      ',\n        '      const response = await fetch(`${baseUrl}${normalizedPath}`, {',\n        '        headers: {',\n        '          \\'Authorization\\': `Bearer ${token}`,',\n        '        },',\n        '      });',\n        '',\n        '      if (!response.ok) {',\n        '        throw new Error(`HTTP error! status: ${response.status}`);',\n        '      }',\n        '',\n        '      return response.json();',\n        '    },',\n        '    enabled: !!config?.apiBaseUrl,',\n        '    ...options,',\n        '  });',\n        '}',\n      ],\n    });\n\n    // Create RootService.ts\n    new SampleFile(project, `${options.srcdir}/services/RootService.ts`, {\n      contents: `import { UseQueryOptions } from '@tanstack/react-query';\nimport { useBaseQuery } from './BaseService';\n\nexport function useRootQuery<TData = unknown>(\n  options?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>\n) {\n  return useBaseQuery<TData>('/', options);\n}\n`,\n    });\n\n    // Create App.css\n    new SampleFile(project, `${options.srcdir}/App.css`, {\n      contents: `#root {\n  width: 100%;\n  height: 100%;\n}\n\n.logo {\n  height: 6em;\n  padding: 1.5em;\n  will-change: filter;\n  transition: filter 300ms;\n}\n.logo:hover {\n  filter: drop-shadow(0 0 2em #646cffaa);\n}\n.logo.react:hover {\n  filter: drop-shadow(0 0 2em #61dafbaa);\n}\n\n@keyframes logo-spin {\n  from {\n    transform: rotate(0deg);\n  }\n  to {\n    transform: rotate(360deg);\n  }\n}\n\n@media (prefers-reduced-motion: no-preference) {\n  a:nth-of-type(2) .logo {\n    animation: logo-spin infinite 20s linear;\n  }\n}\n\n.card {\n  padding: 2em;\n}\n\n.read-the-docs {\n  color: #888;\n}\n`,\n    });\n\n    // Create main.tsx\n    new SampleFile(project, `${options.srcdir}/main.tsx`, {\n      contents: `import { StrictMode } from 'react'\nimport { createRoot } from 'react-dom/client'\nimport './index.css'\nimport App from './App.tsx'\nimport { ClerkProvider, SignedIn, SignedOut, SignInButton } from '@clerk/clerk-react'\nimport { useConfig } from './config'\nimport { QueryClient, QueryClientProvider } from \"@tanstack/react-query\"\n\nfunction AppWrapper() {\n  const { config, isLoading } = useConfig();\n  const queryClient = new QueryClient()\n  if (isLoading || !config) {\n    return (\n      <div className=\"loading-screen\">\n        Loading...\n      </div>\n    );\n  }\n\n  return (\n    <ClerkProvider publishableKey={config.clerkPublishableKey}>\n      <QueryClientProvider client={queryClient}>\n        <div className=\"w-full h-full\">\n          <SignedOut>\n            <div className=\"flex items-center justify-center min-h-screen\">\n              <SignInButton/>\n            </div>\n          </SignedOut>\n          <SignedIn>\n            <App/>\n          </SignedIn>\n        </div>\n      </QueryClientProvider>\n    </ClerkProvider>\n  );\n}\n\ncreateRoot(document.getElementById('root')!).render(\n  <StrictMode>\n    <AppWrapper/>\n  </StrictMode>\n)\n`,\n    });\n\n    // Create index.css\n    new SampleFile(project, `${options.srcdir}/index.css`, {\n      contents: `@import \"tailwindcss\";\n\n@theme {\n  --color-scheme: light dark;\n}\n\n:root {\n  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;\n  line-height: 1.5;\n  font-weight: 400;\n\n  color-scheme: light dark;\n\n  font-synthesis: none;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\na {\n  font-weight: 500;\n  color: #646cff;\n  text-decoration: inherit;\n}\na:hover {\n  color: #535bf2;\n}\n\nbody {\n  margin: 0;\n  min-width: 320px;\n  min-height: 100vh;\n}\n\nh1 {\n  font-size: 3.2em;\n  line-height: 1.1;\n}\n\nbutton {\n  font-family: inherit;\n  cursor: pointer;\n}\n\n.loading-screen {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100vh;\n  font-size: 1.5rem;\n}\n\nhtml, body, #root {\n  width: 100%;\n  height: 100%;\n}\n`,\n    });\n\n  }\n}\n\ninterface PlaywrightE2EComponentOptions {\n  readonly publicDir: string;\n}\n\n/**\n * Adds Playwright e2e testing support: devDeps, a `test:e2e` task, e2e-related\n * .gitignore entries, and a scaffolded (one-time, not regenerated on synth)\n * `playwright.config.ts` + `e2e/` starter suite. Generalizes the hand-authored\n * suite added in macedon-technologies/exman#112 so every ViteReactProject\n * consumer gets it for free (macedon-technologies/platform-common#98).\n */\nclass PlaywrightE2EComponent extends Component {\n  constructor(project: ViteReactProject, options: PlaywrightE2EComponentOptions) {\n    super(project);\n\n    project.addDevDeps(\n      '@playwright/test@^1.63.0',\n      '@clerk/testing@^2.2.34',\n      '@clerk/backend@^3.17.2',\n      'dotenv@^17.4.2',\n    );\n\n    project.addTask('test:e2e', {\n      description: 'Run the Playwright e2e suite (needs CLERK_SECRET_KEY and E2E_CLERK_USER_ID -- see e2e/README.md)',\n      exec: 'playwright test',\n    });\n\n    project.addGitIgnore('playwright-report/');\n    project.addGitIgnore('test-results/');\n    project.addGitIgnore('blob-report/');\n    // `*.local` (added elsewhere) already covers `.env.local`, but not a plain `.env` --\n    // exactly where CLERK_SECRET_KEY (a real secret) is documented to go (e2e/README.md).\n    project.addGitIgnore('.env');\n\n    new PlaywrightConfigFile(project);\n    new E2EGlobalSetupFile(project, options);\n    new E2EClerkSignInFile(project);\n    new E2ELiveHelperFile(project);\n    new E2ESmokeSpecFile(project);\n    new E2EReadmeFile(project);\n  }\n}\n\n/**\n * Creates the playwright.config.ts file. A `SampleFile`, not a managed `FileBase` --\n * consumers need to customize this (e.g. exman's own config needed a live/stub\n * branch), the same reason ViteReactProject's App.tsx/main.tsx are SampleFiles too.\n */\nclass PlaywrightConfigFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'playwright.config.ts', {\n      contents: `import { config as loadDotenv } from 'dotenv'\nimport { defineConfig, devices } from '@playwright/test'\nimport { isLiveRun } from './e2e/support/live'\n\n// Loaded here, first, rather than left to @clerk/testing's own internal dotenv call\n// inside global-setup.ts: that call runs inside globalSetup, which executes AFTER\n// Playwright has already collected every spec file and run their module-level code --\n// so anything reading process.env before then would only ever see a .env file's values\n// as unset. Loading it here, at the top of the config file Playwright reads before\n// anything else, means it's populated for collection, globalSetup, and every test.\nloadDotenv()\n\n// Set E2E_BASE_URL to run against a real deployment (e.g. a PR's pr-deploy WebsiteUrl)\n// instead of a local dev server -- see e2e/support/live.ts and e2e/README.md.\n// \\`|| undefined\\`, not \\`??\\`: an empty string (e.g. an unset GitHub Actions output) is\n// not null/undefined, so ?? would leave baseURL as '' while isLiveRun()'s plain !!\n// check still read the run as non-live -- an invalid, silently-mismatched config.\nconst liveBaseUrl = process.env.E2E_BASE_URL || undefined\n\nexport default defineConfig({\n  testDir: './e2e',\n  fullyParallel: false,\n  forbidOnly: !!process.env.CI,\n  retries: process.env.CI ? 1 : 0,\n  reporter: process.env.CI ? [['html', { open: 'never' }]] : 'list',\n  globalSetup: './e2e/support/global-setup.ts',\n  use: {\n    baseURL: liveBaseUrl ?? 'http://localhost:5173',\n    trace: 'on-first-retry',\n  },\n  projects: [\n    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },\n  ],\n  // No local server to manage when pointed at a live deployment.\n  webServer: isLiveRun() ? undefined : {\n    command: '${runScriptCommand(project.package.packageManager, 'dev')}',\n    url: 'http://localhost:5173',\n    reuseExistingServer: !process.env.CI,\n    timeout: 60_000,\n  },\n})\n`,\n    });\n  }\n}\n\ninterface E2EGlobalSetupFileOptions {\n  readonly publicDir: string;\n}\n\n/**\n * Creates e2e/support/global-setup.ts, which primes @clerk/testing for the sign-in\n * flow in clerk-sign-in.ts. Reads the Clerk publishable key from the scaffolded\n * public/config.json (ConfigJsonFile) rather than hardcoding one -- ViteReactProject's\n * own app fetches that key at runtime the same way (see config.ts), so there's no\n * build-time constant this construct could embed instead.\n */\nclass E2EGlobalSetupFile extends SampleFile {\n  constructor(project: ViteReactProject, options: E2EGlobalSetupFileOptions) {\n    super(project, 'e2e/support/global-setup.ts', {\n      contents: `import { readFileSync } from 'fs'\nimport { clerkSetup } from '@clerk/testing/playwright'\n\n// A no-op (not a throw) when CLERK_SECRET_KEY is missing: every spec that needs a\n// signed-in user already skips itself in that case (see ../smoke.spec.ts), so running\n// the suite without secrets configured yet reports \"skipped\", not a crashed global\n// setup. See e2e/README.md for how to get a secret key.\nexport default async function globalSetup() {\n  if (!process.env.CLERK_SECRET_KEY) {\n    return\n  }\n\n  // import.meta.url, not __dirname: the web package sets \"type\": \"module\" (ViteComponent),\n  // so this file runs as ESM, where __dirname isn't defined. fs.readFileSync accepts a URL\n  // directly, so no need to convert it to a path first.\n  const configPath = new URL('../../${options.publicDir}/config.json', import.meta.url)\n  const { clerkPublishableKey } = JSON.parse(readFileSync(configPath, 'utf-8'))\n\n  await clerkSetup({ publishableKey: clerkPublishableKey })\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/support/clerk-sign-in.ts. Signs in as a specific Clerk user by id via a\n * backend-issued sign-in token (ticket strategy), bypassing the app's actual sign-in\n * UI -- which typically only exposes an OAuth provider button that can't be driven\n * reliably from a test. @clerk/testing/playwright's own `clerk.signIn({ emailAddress })`\n * does the same ticket exchange internally after an extra email->user lookup; going\n * from a user id directly (E2E_CLERK_USER_ID) skips that lookup and its failure mode\n * (an existing user without a verified email attached).\n */\nclass E2EClerkSignInFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/support/clerk-sign-in.ts', {\n      contents: `import { createClerkClient } from '@clerk/backend'\nimport { clerk } from '@clerk/testing/playwright'\nimport type { Page } from '@playwright/test'\n\n/**\n * Signs in as a specific Clerk user by id. Requires CLERK_SECRET_KEY (also used by\n * global-setup.ts) and a prior page.goto() to a page that loads Clerk.\n */\nexport async function signInAsUser(page: Page, userId: string): Promise<void> {\n  const clerkClient = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY })\n  const { token } = await clerkClient.signInTokens.createSignInToken({\n    userId,\n    expiresInSeconds: 300,\n  })\n  await clerk.signIn({ page, signInParams: { strategy: 'ticket', ticket: token } })\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/support/live.ts.\n */\nclass E2ELiveHelperFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/support/live.ts', {\n      contents: `/**\n * True when this run targets a real deployment (E2E_BASE_URL set -- see\n * playwright.config.ts) rather than a local dev server. Specs read this to decide\n * whether to stub the backend: a live run must hit the real API to prove anything,\n * and stubbing it would just be testing the stub.\n */\nexport function isLiveRun(): boolean {\n  return !!process.env.E2E_BASE_URL\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/smoke.spec.ts -- a generic starter test that only relies on markup\n * ViteReactProject's own scaffolded main.tsx/App.tsx always render (SignedIn/\n * UserButton), so it works before a consumer has written any real pages. Consumers\n * are expected to extend/replace this with real flows, the same way they already\n * customize App.tsx.\n */\nclass E2ESmokeSpecFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/smoke.spec.ts', {\n      contents: `import { test, expect } from '@playwright/test'\nimport { signInAsUser } from './support/clerk-sign-in'\n\ntest('signs in and shows the authenticated UserButton', async ({ page }) => {\n  // Read from inside the test body, not module scope: Playwright collects (requires)\n  // this file before running globalSetup, so a module-level check would always see a\n  // .env-sourced value as unset. Exporting the var in the shell works either way.\n  const testUserId = process.env.E2E_CLERK_USER_ID\n  test.skip(\n    !testUserId || !process.env.CLERK_SECRET_KEY,\n    'E2E_CLERK_USER_ID and CLERK_SECRET_KEY must both be set -- see e2e/README.md',\n  )\n\n  // signInAsUser requires a prior page.goto() to a page that loads Clerk.\n  await page.goto('/')\n  await signInAsUser(page, testUserId!)\n  await page.goto('/')\n\n  // '.cl-userButtonTrigger' is one of Clerk's own documented, stable \\`cl-\\`-prefixed\n  // class hooks (part of its theming/appearance API), not an incidental DOM detail --\n  // safer to depend on across Clerk versions than app-specific markup this construct\n  // doesn't control.\n  await expect(page.locator('.cl-userButtonTrigger')).toBeVisible()\n})\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/README.md documenting the one-time setup and env var convention every\n * consumer needs, so it doesn't have to be re-derived by hand per repo.\n */\nclass E2EReadmeFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    const testE2eCommand = runScriptCommand(project.package.packageManager, 'test:e2e');\n    super(project, 'e2e/README.md', {\n      contents: `# Playwright e2e suite\n\nRuns against a real dev server (or a live deployment, via \\`E2E_BASE_URL\\`) and real\nClerk authentication.\n\n## One-time setup\n\n1. Install Playwright's browser binary (not covered by a plain dependency install):\n\n   \\`\\`\\`bash\n   npx playwright install chromium\n   \\`\\`\\`\n\n2. Get two values from your Clerk dashboard's dev instance:\n\n   - \\`CLERK_SECRET_KEY\\` -- the **secret** key (API Keys). Never commit this; export it\n     in your shell or put it in a local, gitignored \\`.env\\`.\n   - \\`E2E_CLERK_USER_ID\\` -- the id (\\`user_...\\`) of an existing test user (Users -> click\n     a user, the id is shown at the top). The user needs a verified email address, not\n     just an OAuth connection -- a sign-in token has to bind to a verified\n     identification. Creating a dedicated test user with an email set explicitly is the\n     safer default.\n\n   A run with either variable unset **skips** rather than failing, so \\`${testE2eCommand}\\`\n   is always safe to run without them.\n\n3. This construct doesn't manage \\`vitest.config.ts\\` (it's a hand-authored,\n   per-consumer file). Add an \\`exclude\\` entry so vitest's default test glob doesn't\n   also try to pick up these Playwright spec files:\n\n   \\`\\`\\`ts\n   import { defineConfig, configDefaults } from 'vitest/config'\n\n   export default defineConfig({\n     test: {\n       exclude: [...configDefaults.exclude, 'e2e/**'],\n       // ...your existing config\n     },\n   })\n   \\`\\`\\`\n\n## Running\n\n\\`\\`\\`bash\nCLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... ${testE2eCommand}\n\\`\\`\\`\n\n## Running against a live environment\n\nSet \\`E2E_BASE_URL\\` to point the suite at a real deployment (a personal dev stack, or a\nPR's pr-deploy \\`WebsiteUrl\\`, posted as a PR comment) instead of a local dev server:\n\n\\`\\`\\`bash\nE2E_BASE_URL=https://<your-stack>.example.com \\\\\nCLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... \\\\\n${testE2eCommand}\n\\`\\`\\`\n\n## CI\n\nThe generated \\`pr-deploy.yml\\` workflow (see \\`PrDeployWorkflow\\`) already runs this\nsuite against each PR's deployed \\`WebsiteUrl\\` and uploads the HTML report as a build\nartifact on failure. It self-skips exactly like a local run until both secrets exist\nin the repo:\n\n\\`\\`\\`bash\ngh secret set CLERK_SECRET_KEY\ngh secret set E2E_CLERK_USER_ID\n\\`\\`\\`\n`,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViteReactProject.js","sourceRoot":"","sources":["../src/ViteReactProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative, basename } from 'path';\nimport { Component, FileBase, JsonFile, Project, SampleFile } from 'projen';\nimport { TypeScriptAppProject, TypeScriptProjectOptions } from 'projen/lib/typescript';\nimport { BatmanProject } from './BatmanProject';\nimport { runScriptCommand } from './utils';\n\nexport interface ViteReactProjectOptions extends TypeScriptProjectOptions {\n  /**\n   * Whether to generate sample code\n   * @default true\n   */\n  readonly sampleCode?: boolean;\n\n  /**\n   * Source directory\n   * @default \"src\"\n   */\n  readonly srcdir?: string;\n\n  /**\n   * Public directory for static assets\n   * @default \"public\"\n   */\n  readonly publicDir?: string;\n\n  /**\n   * Title for the HTML page\n   * @default project name\n   */\n  readonly title?: string;\n\n  /**\n   * Whether to add Playwright e2e testing support (devDeps, a `test:e2e` task,\n   * and a scaffolded `playwright.config.ts` + `e2e/` starter suite).\n   * @default true\n   */\n  readonly e2eTesting?: boolean;\n}\n\n/**\n * Vite + React TypeScript project\n */\nexport class ViteReactProject extends TypeScriptAppProject {\n  public readonly srcdir: string;\n  public readonly publicDir: string;\n  public readonly devCommand: string;\n  private readonly configFields: Map<string, string>;\n\n  constructor(options: ViteReactProjectOptions) {\n    const {\n      sampleCode = true,\n      srcdir = 'src',\n      publicDir = 'public',\n      title,\n      e2eTesting = true,\n      ...restOptions\n    } = options;\n    super({\n      ...restOptions,\n      sampleCode: false, // We'll handle sample code ourselves\n      eslint: false, // We'll configure eslint ourselves\n      jest: false, // Vite uses vitest typically\n      package: true,\n      disableTsconfig: true, // We'll manage tsconfig ourselves\n      packageManager: (restOptions.parent as BatmanProject).package.packageManager,\n      pnpmOptions: {\n        workspaceYamlOptions: {\n          // This subproject has its own separate lockfile/store from its parent,\n          // so it needs its own approval for the native postinstall scripts its\n          // fixed dependency set always needs (esbuild's binary download, and\n          // @clerk/clerk-react's transitive @clerk/shared setup script).\n          allowBuilds: {\n            'esbuild': true,\n            '@clerk/shared': true,\n          },\n          ...restOptions.pnpmOptions?.workspaceYamlOptions,\n        },\n      },\n      deps: [\n        '@clerk/clerk-react',\n        '@tanstack/react-query',\n        '@tailwindcss/postcss',\n        'autoprefixer',\n        'postcss',\n        'tailwindcss',\n        'rollup',\n        ...(options.deps ? options.deps : []),\n      ],\n    });\n\n    // Initialize config fields storage\n    this.configFields = new Map<string, string>();\n\n    this.srcdir = srcdir;\n    this.publicDir = publicDir;\n\n    // Add Vite component\n    new ViteComponent(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add ESLint configuration\n    new ViteEslintConfig(this);\n\n    // Add index.html\n    new IndexHtml(this, {\n      title: title ?? this.name,\n      srcdir: this.srcdir,\n    });\n\n    // Add TypeScript configs\n    new ViteTsConfigs(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add .gitignore entries\n    this.gitignore?.addPatterns('dist', 'dist-ssr', '*.local');\n\n    // Add vite-env.d.ts for type declarations\n    new ViteEnvDts(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add PostCSS config for Tailwind\n    new PostCSSConfigFile(this);\n\n    // Add config.ts for runtime configuration\n    new ConfigFile(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add sample config.json\n    new ConfigJsonFile(this, { });\n\n\n    // Add sample code if requested\n    if (sampleCode) {\n      new ViteSampleCode(this, {\n        srcdir: this.srcdir,\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Add Playwright e2e testing support\n    if (e2eTesting) {\n      new PlaywrightE2EComponent(this, {\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Use relative path for devCommand\n    const relativeOutdir = this.parent\n      ? relative(this.parent.outdir, this.outdir)\n      : basename(this.outdir);\n    this.devCommand = `cd ${relativeOutdir} && ${runScriptCommand(this.package.packageManager, 'dev')}`;\n  }\n\n  /**\n   * Add a custom field to the Config type\n   * @param fieldName The name of the field\n   * @param fieldType The TypeScript type of the field (e.g., 'string', 'number', 'boolean', 'string[]')\n   * @returns this project instance for chaining\n   */\n  addConfigField(fieldName: string, fieldType: string): this {\n    this.configFields.set(fieldName, fieldType);\n    return this;\n  }\n\n  /**\n   * Get the config fields map (for internal use by ConfigFile)\n   * @internal\n   */\n  getConfigFields(): Map<string, string> {\n    return this.configFields;\n  }\n}\n\ninterface ViteComponentOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Configures Vite dependencies and scripts\n */\nclass ViteComponent extends Component {\n  constructor(project: TypeScriptAppProject, _options: ViteComponentOptions) {\n    super(project);\n\n    const tsProject = project as TypeScriptAppProject;\n\n    // Set package type to module for ESM support\n    tsProject.package.addField('type', 'module');\n\n    // Add React dependencies\n    tsProject.addDeps('react@^19.2.0', 'react-dom@^19.2.0');\n\n    // Add dev dependencies\n    tsProject.addDevDeps(\n      '@types/react@^19.2.2',\n      '@types/react-dom@^19.2.2',\n      '@vitejs/plugin-react@^5.1.0',\n      'vite@^5.4.0',\n      'typescript@~5.9.3',\n      '@eslint/js@^9.39.1',\n      'eslint@^9.39.1',\n      'eslint-plugin-react-hooks@^5.2.0',\n      'eslint-plugin-react-refresh@^0.4.24',\n      'globals@^16.5.0',\n      'typescript-eslint@^8.46.3',\n    );\n\n    // Create vite.config.ts as a managed file\n    new ViteConfigFile(project);\n\n    // Add scripts\n    tsProject.addTask('dev', {\n      description: 'Start development server',\n      exec: 'vite',\n    });\n\n    // Remove and recreate build task to customize it for Vite\n    tsProject.removeTask('build');\n    tsProject.addTask('build', {\n      description: 'Build for production',\n      exec: 'tsc -b && vite build',\n    });\n\n    tsProject.addTask('preview', {\n      description: 'Preview production build',\n      exec: 'vite preview',\n    });\n\n    tsProject.addTask('lint', {\n      description: 'Lint code',\n      exec: 'eslint .',\n    });\n  }\n}\n\n/**\n * Creates the ESLint configuration for Vite + React\n */\nclass ViteEslintConfig extends FileBase {\n  constructor(project: Project) {\n    super(project, 'eslint.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import js from '@eslint/js'\nimport globals from 'globals'\nimport reactHooks from 'eslint-plugin-react-hooks'\nimport reactRefresh from 'eslint-plugin-react-refresh'\nimport tseslint from 'typescript-eslint'\n\nexport default [\n  { ignores: ['dist'] },\n  {\n    files: ['**/*.{ts,tsx}'],\n    languageOptions: {\n      ecmaVersion: 2020,\n      globals: globals.browser,\n    },\n    plugins: {\n      'react-hooks': reactHooks,\n      'react-refresh': reactRefresh,\n    },\n    rules: {\n      ...reactHooks.configs.recommended.rules,\n      'react-refresh/only-export-components': [\n        'warn',\n        { allowConstantExport: true },\n      ],\n    },\n  },\n  js.configs.recommended,\n  ...tseslint.configs.recommended,\n]\n`;\n  }\n}\n\n/**\n * Creates the vite.config.ts file\n */\nclass ViteConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'vite.config.ts', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import { defineConfig } from 'vite'\nimport react from '@vitejs/plugin-react'\n\n// https://vite.dev/config/\nexport default defineConfig({\n  plugins: [react()],\n})\n`;\n  }\n}\n\n/**\n * Creates the postcss.config.js file for Tailwind CSS v4\n */\nclass PostCSSConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'postcss.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `export default {\n  plugins: {\n    \"@tailwindcss/postcss\": {},\n    autoprefixer: {},\n  },\n}\n`;\n  }\n}\n\ninterface ViteEnvDtsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the vite-env.d.ts file for type declarations\n */\nclass ViteEnvDts extends FileBase {\n  constructor(project: Project, options: ViteEnvDtsOptions) {\n    super(project, `${options.srcdir}/vite-env.d.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `/// <reference types=\"vite/client\" />\n`;\n  }\n}\n\ninterface ConfigFileOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the config.ts file for runtime configuration\n */\nclass ConfigFile extends FileBase {\n  constructor(project: Project, options: ConfigFileOptions) {\n    super(project, `${options.srcdir}/config.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    // Get custom config fields from parent project\n    const viteProject = this.project as ViteReactProject;\n    const customFields = viteProject.getConfigFields();\n\n    // Generate base config type\n    const baseConfigType = `type BaseConfig = {\n  clerkPublishableKey: string;\n  apiBaseUrl: string;\n  timeout: number;\n}`;\n\n    // Generate custom fields type if any exist\n    let configTypeDefinition: string;\n    if (customFields.size > 0) {\n      const fieldDefinitions = Array.from(customFields.entries())\n        .map(([name, type]) => `  ${name}: ${type};`)\n        .join('\\n');\n\n      const customFieldsType = `type CustomConfig = {\n${fieldDefinitions}\n}`;\n\n      configTypeDefinition = `${customFieldsType}\n\nexport type Config = BaseConfig & CustomConfig;`;\n    } else {\n      configTypeDefinition = 'export type Config = BaseConfig;';\n    }\n\n    return `import { useEffect, useState } from 'react';\n\n${baseConfigType}\n\n${configTypeDefinition}\n\nlet shared: Promise<Config> | undefined;\nlet loaded: Config | undefined;\n\n/** How long the shared load of /config.json may take before it is abandoned and fails. */\nexport const CONFIG_LOAD_TIMEOUT_MS = 15 * 1000;\n\n/**\n * The runtime config, loaded once and shared by every useConfig(); a failed load, including one\n * abandoned after CONFIG_LOAD_TIMEOUT_MS, is tried again by the next caller.\n */\nexport function loadConfig(): Promise<Config> {\n  if (!shared) {\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), CONFIG_LOAD_TIMEOUT_MS);\n    const load: Promise<Config> = fetch('/config.json', { cache: 'no-store', signal: controller.signal })\n      .then((response) => {\n        if (!response.ok) {\n          throw new Error(\\`Loading /config.json failed with status \\${response.status}\\`);\n        }\n        return response.json() as Promise<Config>;\n      })\n      .finally(() => clearTimeout(timer))\n      .then((config) => {\n        if (shared === load) {\n          loaded = config;\n        }\n        return config;\n      });\n    load.catch(() => {\n      if (shared === load) {\n        shared = undefined;\n      }\n    });\n    shared = load;\n  }\n  return shared;\n}\n\n/** Forgets the shared config, so each test loads its own. */\nexport function resetConfigForTests(): void {\n  shared = undefined;\n  loaded = undefined;\n}\n\nexport function useConfig() {\n  const [loadedConfig, setLoadedConfig] = useState<Config | undefined>(loaded);\n  const [isLoading, setIsLoading] = useState(!loaded);\n  const [error, setError] = useState<unknown>();\n\n  useEffect(() => {\n    if (loadedConfig) {\n      return undefined;\n    }\n    let live = true;\n    setIsLoading(true);\n    setError(undefined);\n    loadConfig().then(\n      (config) => {\n        if (live) {\n          setLoadedConfig(config);\n          setIsLoading(false);\n        }\n      },\n      (err) => {\n        if (live) {\n          setError(err);\n          setIsLoading(false);\n        }\n      },\n    );\n    return () => {\n      live = false;\n    };\n  }, [loadedConfig]);\n\n  return { config: loadedConfig, isLoading, error };\n}\n`;\n  }\n}\n\ninterface ConfigJsonFileOptions {}\n\n/**\n * Creates the config.json sample file for runtime configuration\n */\nclass ConfigJsonFile extends SampleFile {\n  path: string;\n  constructor(project: ViteReactProject, _options: ConfigJsonFileOptions) {\n    super(project, `${project.publicDir}/config.json`, {\n      contents: JSON.stringify({\n        apiBaseUrl: 'http://localhost:3000/api',\n        clerkPublishableKey: 'tbd',\n      }, null, 2),\n    });\n    this.path = `${project.publicDir}/config.json`;\n  }\n}\n\ninterface IndexHtmlOptions {\n  readonly title: string;\n  readonly srcdir: string;\n}\n\n/**\n * Creates the index.html file\n */\nclass IndexHtml extends SampleFile {\n  constructor(project: Project, options: IndexHtmlOptions) {\n    super(project, 'index.html', {\n      contents: `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/vite.svg\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>${options.title}</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/${options.srcdir}/main.tsx\"></script>\n  </body>\n</html>\n`,\n    });\n  }\n}\n\ninterface ViteTsConfigsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the TypeScript configuration files for Vite\n */\nclass ViteTsConfigs extends Component {\n  constructor(project: Project, options: ViteTsConfigsOptions) {\n    super(project);\n\n    // Main tsconfig.json (project references)\n    new JsonFile(project, 'tsconfig.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        files: [],\n        references: [\n          { path: './tsconfig.app.json' },\n          { path: './tsconfig.node.json' },\n        ],\n      },\n    });\n\n    // tsconfig.app.json (for application code)\n    new JsonFile(project, 'tsconfig.app.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2020',\n          useDefineForClassFields: true,\n          lib: ['ES2020', 'DOM', 'DOM.Iterable'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n          jsx: 'react-jsx',\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n          noUncheckedSideEffectImports: true,\n        },\n        include: [options.srcdir],\n      },\n    });\n\n    // tsconfig.node.json (for Vite config)\n    new JsonFile(project, 'tsconfig.node.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2022',\n          lib: ['ES2023'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n        },\n        include: ['vite.config.ts'],\n      },\n    });\n  }\n}\n\ninterface ViteSampleCodeOptions {\n  readonly srcdir: string;\n  readonly publicDir: string;\n}\n\n/**\n * Generates sample code for a Vite + React project\n */\nclass ViteSampleCode extends Component {\n  constructor(project: Project, options: ViteSampleCodeOptions) {\n    super(project);\n\n    // Create App.tsx\n    new SampleFile(project, `${options.srcdir}/App.tsx`, {\n      contents: `import './App.css'\nimport { SignedIn, UserButton } from '@clerk/clerk-react';\nimport { useApiQuery } from \"./services/ApiService.ts\";\n\n\nfunction App() {\n  const {data, isLoading} = useApiQuery('/', {retryOnMount: true});\n\n\n  return (\n    <>\n        <header>\n\n          <SignedIn>\n            <UserButton/>\n          </SignedIn>\n        </header>\n        <div className=\"card\">\n          { isLoading ? 'Loading...' : JSON.stringify(data, null ,)}\n        </div>\n    </>\n  )\n}\n\nexport default App\n`,\n    });\n\n    new ApiServiceFiles(project, { srcdir: options.srcdir });\n\n    // Create App.css\n    new SampleFile(project, `${options.srcdir}/App.css`, {\n      contents: `#root {\n  width: 100%;\n  height: 100%;\n}\n\n.logo {\n  height: 6em;\n  padding: 1.5em;\n  will-change: filter;\n  transition: filter 300ms;\n}\n.logo:hover {\n  filter: drop-shadow(0 0 2em #646cffaa);\n}\n.logo.react:hover {\n  filter: drop-shadow(0 0 2em #61dafbaa);\n}\n\n@keyframes logo-spin {\n  from {\n    transform: rotate(0deg);\n  }\n  to {\n    transform: rotate(360deg);\n  }\n}\n\n@media (prefers-reduced-motion: no-preference) {\n  a:nth-of-type(2) .logo {\n    animation: logo-spin infinite 20s linear;\n  }\n}\n\n.card {\n  padding: 2em;\n}\n\n.read-the-docs {\n  color: #888;\n}\n`,\n    });\n\n    // Create main.tsx\n    new SampleFile(project, `${options.srcdir}/main.tsx`, {\n      contents: `import { StrictMode } from 'react'\nimport { createRoot } from 'react-dom/client'\nimport './index.css'\nimport App from './App.tsx'\nimport { ClerkProvider, SignedIn, SignedOut, SignInButton } from '@clerk/clerk-react'\nimport { useConfig } from './config'\nimport { QueryClient, QueryClientProvider } from \"@tanstack/react-query\"\n\nfunction AppWrapper() {\n  const { config, isLoading, error } = useConfig();\n  const queryClient = new QueryClient()\n  if (error) {\n    return (\n      <div className=\"loading-screen\">\n        Could not load the app configuration.\n      </div>\n    );\n  }\n  if (isLoading || !config) {\n    return (\n      <div className=\"loading-screen\">\n        Loading...\n      </div>\n    );\n  }\n\n  return (\n    <ClerkProvider publishableKey={config.clerkPublishableKey}>\n      <QueryClientProvider client={queryClient}>\n        <div className=\"w-full h-full\">\n          <SignedOut>\n            <div className=\"flex items-center justify-center min-h-screen\">\n              <SignInButton/>\n            </div>\n          </SignedOut>\n          <SignedIn>\n            <App/>\n          </SignedIn>\n        </div>\n      </QueryClientProvider>\n    </ClerkProvider>\n  );\n}\n\ncreateRoot(document.getElementById('root')!).render(\n  <StrictMode>\n    <AppWrapper/>\n  </StrictMode>\n)\n`,\n    });\n\n    // Create index.css\n    new SampleFile(project, `${options.srcdir}/index.css`, {\n      contents: `@import \"tailwindcss\";\n\n@theme {\n  --color-scheme: light dark;\n}\n\n:root {\n  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;\n  line-height: 1.5;\n  font-weight: 400;\n\n  color-scheme: light dark;\n\n  font-synthesis: none;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\na {\n  font-weight: 500;\n  color: #646cff;\n  text-decoration: inherit;\n}\na:hover {\n  color: #535bf2;\n}\n\nbody {\n  margin: 0;\n  min-width: 320px;\n  min-height: 100vh;\n}\n\nh1 {\n  font-size: 3.2em;\n  line-height: 1.1;\n}\n\nbutton {\n  font-family: inherit;\n  cursor: pointer;\n}\n\n.loading-screen {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100vh;\n  font-size: 1.5rem;\n}\n\nhtml, body, #root {\n  width: 100%;\n  height: 100%;\n}\n`,\n    });\n\n  }\n}\n\ninterface ApiServiceFilesOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Bootstraps the web client's API layer: `services/ApiService.ts` (query and mutation hooks\n * keyed per path) and the `helpers/` it is built on. Written once, then owned by the consumer.\n */\nclass ApiServiceFiles extends Component {\n  constructor(project: Project, options: ApiServiceFilesOptions) {\n    super(project);\n\n    new SampleFile(project, `${options.srcdir}/services/ApiService.ts`, {\n      contents: `import { useAuth } from '@clerk/clerk-react';\nimport { QueryClient, useMutation, UseMutationOptions, useQuery, UseQueryOptions } from '@tanstack/react-query';\nimport { useEffect, useMemo, useRef } from 'react';\nimport { loadConfig, useConfig } from '../config';\nimport { RequestCancelledError } from '../helpers/HttpError';\nimport { get, post, put, RequestOptions, TokenGetter } from '../helpers/requests';\n\n/** The React Query key for an API path: its segments, so a prefix's key covers every path under it. */\nexport function apiQueryKey(path: string): string[] {\n  return path.split('/').filter(Boolean);\n}\n\nexport function invalidateApiQueries(queryClient: QueryClient, prefix: string): Promise<void> {\n  return queryClient.invalidateQueries({ queryKey: apiQueryKey(prefix), exact: false });\n}\n\nexport function useApiQuery<TData = unknown>(\n  path: string,\n  options?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>,\n) {\n  const { config } = useConfig();\n  const { getToken } = useAuth();\n  const { enabled, ...restOptions } = options ?? {};\n\n  return useQuery<TData>({\n    queryKey: apiQueryKey(path),\n    queryFn: ({ signal }) => get<TData>(config!.apiBaseUrl, path, getToken as TokenGetter, { signal }),\n    ...restOptions,\n    // A caller's \\`enabled\\` narrows the config gate rather than replacing it: \\`queryFn\\` needs the config.\n    enabled: (enabled ?? true) && !!config?.apiBaseUrl,\n  });\n}\n\nexport interface ApiClient {\n  get<TData = unknown>(path: string, options?: RequestOptions): Promise<TData>;\n  post<TData = unknown>(path: string, body: unknown, options?: RequestOptions): Promise<TData>;\n  put<TData = unknown>(path: string, body: unknown, options?: RequestOptions): Promise<TData>;\n}\n\n/**\n * Calls the API imperatively, reading the runtime config and the token getter at the moment of\n * each call. A call made before the config has arrived waits for the shared load, and fails\n * when that load fails.\n */\nexport function useApiClient(): ApiClient {\n  const { config } = useConfig();\n  const { getToken } = useAuth();\n  const latest = useRef({ config, getToken });\n  useEffect(() => {\n    latest.current = { config, getToken };\n  }, [config, getToken]);\n\n  return useMemo(() => {\n    const untilCancelled = (signal: AbortSignal | undefined) => new Promise<never>((_, reject) => {\n      if (signal?.aborted) {\n        reject(new RequestCancelledError());\n      }\n      signal?.addEventListener('abort', () => reject(new RequestCancelledError()), { once: true });\n    });\n    const apiBaseUrl = async (signal: AbortSignal | undefined): Promise<string> => {\n      const config = latest.current.config\n        ?? await Promise.race([loadConfig().catch(() => undefined), untilCancelled(signal)]);\n      if (!config?.apiBaseUrl) {\n        throw new Error('API base URL not configured');\n      }\n      return config.apiBaseUrl;\n    };\n    const token: TokenGetter = () => (latest.current.getToken as TokenGetter)();\n    return {\n      get: async <TData>(path: string, options?: RequestOptions) =>\n        get<TData>(await apiBaseUrl(options?.signal), path, token, options),\n      post: async <TData>(path: string, body: unknown, options?: RequestOptions) =>\n        post<TData>(await apiBaseUrl(options?.signal), path, body, token, options),\n      put: async <TData>(path: string, body: unknown, options?: RequestOptions) =>\n        put<TData>(await apiBaseUrl(options?.signal), path, body, token, options),\n    };\n  }, []);\n}\n\ntype ApiMutationVariables = { path: string; body: unknown; signal?: AbortSignal };\n\nexport function useApiMutation<TData = unknown>(\n  method: 'POST' | 'PUT',\n  options?: Omit<UseMutationOptions<TData, unknown, ApiMutationVariables>, 'mutationFn'>,\n) {\n  const client = useApiClient();\n\n  return useMutation<TData, unknown, ApiMutationVariables>({\n    mutationFn: ({ path, body, signal }) =>\n      method === 'POST' ? client.post<TData>(path, body, { signal }) : client.put<TData>(path, body, { signal }),\n    ...options,\n  });\n}\n`,\n    });\n\n    new SampleFile(project, `${options.srcdir}/helpers/requests.ts`, {\n      contents: `import { HttpError, RequestCancelledError, RequestTimeoutError, type HttpErrorDetails } from './HttpError';\n\nexport type TokenGetter = () => Promise<string | null | undefined>;\n\n/**\n * How long a request may go unanswered before it fails. It stays above the longest CloudFront\n * can take to give any answer: three 10 s connection attempts to the API origin plus its 30 s\n * response timeout. The local dev server has no limit of its own, so there this is the only one.\n */\nexport const API_REQUEST_TIMEOUT_MS = 65 * 1000;\n\nexport interface RequestOptions {\n  readonly signal?: AbortSignal;\n  /** Called when the API rejects the caller's session (a 401), before the error is thrown. */\n  readonly onSessionRejected?: () => void;\n}\n\ninterface Deadline {\n  readonly signal: AbortSignal;\n  /** Settles with \\`promise\\`, or rejects as soon as the request is abandoned. */\n  race<T>(promise: Promise<T>): Promise<T>;\n  /** Why the request was abandoned, or \\`undefined\\` while it is still live. */\n  readonly abandonment: HttpError | undefined;\n}\n\nasync function withDeadline<T>(callerSignal: AbortSignal | undefined, run: (deadline: Deadline) => Promise<T>): Promise<T> {\n  const controller = new AbortController();\n  let abandonment: HttpError | undefined;\n  const abandoned = new Promise<never>((_, reject) => {\n    controller.signal.addEventListener('abort', () => reject(abandonment), { once: true });\n  });\n  abandoned.catch(() => undefined);\n\n  const abandon = (error: HttpError) => {\n    if (!abandonment) {\n      abandonment = error;\n      controller.abort();\n    }\n  };\n  const timer = setTimeout(() => abandon(new RequestTimeoutError()), API_REQUEST_TIMEOUT_MS);\n  const cancel = () => abandon(new RequestCancelledError());\n  if (callerSignal?.aborted) {\n    cancel();\n  } else {\n    callerSignal?.addEventListener('abort', cancel, { once: true });\n  }\n\n  try {\n    return await run({\n      signal: controller.signal,\n      race: (promise) => Promise.race([promise, abandoned]),\n      get abandonment() {\n        return abandonment;\n      },\n    });\n  } finally {\n    clearTimeout(timer);\n    callerSignal?.removeEventListener('abort', cancel);\n  }\n}\n\nfunction buildUrl(apiBaseUrl: string, path: string): string {\n  const baseUrl = apiBaseUrl.replace(/\\\\/+$/, '');\n  const normalizedPath = path.startsWith('/') ? path : \\`/\\${path}\\`;\n  return \\`\\${baseUrl}\\${normalizedPath}\\`;\n}\n\nasync function request(\n  method: 'GET' | 'POST' | 'PUT',\n  apiBaseUrl: string,\n  path: string,\n  getToken: TokenGetter,\n  deadline: Deadline,\n  body: unknown,\n  onSessionRejected: (() => void) | undefined,\n): Promise<Response> {\n  let response: Response;\n  try {\n    const token = await deadline.race(getToken());\n    response = await fetch(buildUrl(apiBaseUrl, path), {\n      method,\n      headers: {\n        Authorization: \\`Bearer \\${token ?? ''}\\`,\n        ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),\n      },\n      ...(body !== undefined ? { body: JSON.stringify(body) } : {}),\n      signal: deadline.signal,\n    });\n  } catch (error) {\n    throw incomplete(method, path, deadline, error);\n  }\n\n  if (!response.ok) {\n    const parsed = await deadline.race(parseErrorBody(response)).catch(() => undefined);\n    if (!parsed) {\n      throw incomplete(method, path, deadline, undefined);\n    }\n    const { error, message, details } = parsed;\n    console.error(\\`[api] \\${method} \\${path} responded \\${response.status}: \\${message}\\`);\n    if (response.status === 401) {\n      onSessionRejected?.();\n    }\n    throw new HttpError(response.status, error, message, details);\n  }\n\n  return response;\n}\n\n/**\n * The error for a request that got no usable answer, logged before it is thrown so a caller\n * that swallows it still leaves a trace. A caller's own cancellation is not logged.\n */\nfunction incomplete(method: string, path: string, deadline: Deadline, cause: unknown): HttpError {\n  const abandonment = deadline.abandonment;\n  if (abandonment instanceof RequestCancelledError) {\n    return abandonment;\n  }\n  if (abandonment) {\n    console.error(\\`[api] \\${method} \\${path} timed out after \\${API_REQUEST_TIMEOUT_MS} ms\\`);\n    return abandonment;\n  }\n  const message = cause instanceof Error ? cause.message : 'Failed to reach the API';\n  console.error(\\`[api] \\${method} \\${path} failed to reach the API: \\${message}\\`);\n  return new HttpError(0, 'Network Error', message);\n}\n\nfunction send<TData = unknown>(\n  method: 'GET' | 'POST' | 'PUT',\n  apiBaseUrl: string,\n  path: string,\n  getToken: TokenGetter,\n  body: unknown,\n  { signal, onSessionRejected }: RequestOptions = {},\n): Promise<TData> {\n  return withDeadline(signal, async (deadline) => {\n    const response = await request(method, apiBaseUrl, path, getToken, deadline, body, onSessionRejected);\n    try {\n      return await deadline.race(response.json());\n    } catch (error) {\n      if (deadline.abandonment) {\n        throw incomplete(method, path, deadline, error);\n      }\n      throw error;\n    }\n  });\n}\n\n/** Every field of an error body other than \\`error\\` and \\`message\\`. */\nfunction detailsOf(body: Record<string, unknown>): HttpErrorDetails {\n  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'error' && key !== 'message'));\n}\n\nasync function parseErrorBody(response: Response): Promise<{ error: string; message: string; details: HttpErrorDetails }> {\n  try {\n    const body = await response.json();\n    if (body && typeof body.message === 'string') {\n      return {\n        error: typeof body.error === 'string' ? body.error : response.statusText,\n        message: body.message,\n        details: detailsOf(body),\n      };\n    }\n  } catch {\n    // Not JSON (e.g. a proxy's error page): fall through to the generic error below.\n  }\n  return { error: response.statusText || 'Error', message: \\`HTTP error! status: \\${response.status}\\`, details: {} };\n}\n\nexport function get<TData = unknown>(\n  apiBaseUrl: string,\n  path: string,\n  getToken: TokenGetter,\n  options?: RequestOptions,\n): Promise<TData> {\n  return send<TData>('GET', apiBaseUrl, path, getToken, undefined, options);\n}\n\nexport function post<TData = unknown>(\n  apiBaseUrl: string,\n  path: string,\n  body: unknown,\n  getToken: TokenGetter,\n  options?: RequestOptions,\n): Promise<TData> {\n  return send<TData>('POST', apiBaseUrl, path, getToken, body, options);\n}\n\nexport function put<TData = unknown>(\n  apiBaseUrl: string,\n  path: string,\n  body: unknown,\n  getToken: TokenGetter,\n  options?: RequestOptions,\n): Promise<TData> {\n  return send<TData>('PUT', apiBaseUrl, path, getToken, body, options);\n}\n`,\n    });\n\n    new SampleFile(project, `${options.srcdir}/helpers/HttpError.ts`, {\n      contents: `/** The fields an error body carries beyond \\`error\\` and \\`message\\`. */\nexport type HttpErrorDetails = Readonly<Record<string, unknown>>;\n\n/**\n * A failed API request: the HTTP status (0 when the API gave no answer) and the error body's\n * \\`error\\` and \\`message\\`, with any other fields it carries as \\`details\\`.\n */\nexport class HttpError extends Error {\n  status: number;\n  error: string;\n  details: HttpErrorDetails;\n\n  constructor(status: number, error: string, message: string, details: HttpErrorDetails = {}) {\n    super(message);\n    this.name = 'HttpError';\n    this.status = status;\n    this.error = error;\n    this.details = details;\n  }\n}\n\n/** The API did not answer within the client's bound. */\nexport class RequestTimeoutError extends HttpError {\n  constructor() {\n    super(0, 'Timeout', 'The server took too long to respond. Please try again.');\n    this.name = 'RequestTimeoutError';\n  }\n}\n\n/** The caller cancelled the request before the API answered. */\nexport class RequestCancelledError extends HttpError {\n  constructor() {\n    super(0, 'Aborted', 'The request was cancelled.');\n    this.name = 'RequestCancelledError';\n  }\n}\n\n/** Whether \\`error\\`'s message was written for the person using the app: a refusal (4xx) or a timeout. */\nexport function isUserFacing(error: unknown): error is HttpError {\n  return error instanceof RequestTimeoutError || (error instanceof HttpError && error.status >= 400 && error.status < 500);\n}\n`,\n    });\n\n    new SampleFile(project, `${options.srcdir}/helpers/errors.ts`, {\n      contents: `import { HttpError } from './HttpError';\n\n/** A 5xx's message is the server's, not written for the person using the app, so it gets the default. */\nexport function getErrorMessage(error: unknown, defaultMessage: string): string {\n  if (error instanceof HttpError && error.status >= 500) {\n    return defaultMessage;\n  }\n  if (error instanceof Error && error.message) {\n    return error.message;\n  }\n  return defaultMessage;\n}\n`,\n    });\n\n    new SampleFile(project, `${options.srcdir}/helpers/retry.ts`, {\n      contents: `import { HttpError, RequestCancelledError } from './HttpError';\n\n/** React Query's own default: three retries after the first failure. */\nconst MAX_RETRIES = 3;\n\n/**\n * A query \\`retry\\` that never retries a 401, because the API will reject the same token again.\n * Everything else gets React Query's default.\n */\nexport function retryUnlessRejected(failureCount: number, error: unknown): boolean {\n  if (error instanceof HttpError && error.status === 401) {\n    return false;\n  }\n  return failureCount < MAX_RETRIES;\n}\n\n/**\n * A failure worth trying again unchanged: the API answered 5xx, or was not reached or did not\n * answer in time (status 0). A cancellation is not one: whoever cancelled wants it stopped.\n */\nexport function isTransientFailure(error: unknown): boolean {\n  return error instanceof HttpError && !(error instanceof RequestCancelledError) && (error.status === 0 || error.status >= 500);\n}\n`,\n    });\n  }\n}\n\ninterface PlaywrightE2EComponentOptions {\n  readonly publicDir: string;\n}\n\n/**\n * Adds Playwright e2e testing support: devDeps, a `test:e2e` task, e2e-related\n * .gitignore entries, and a scaffolded (one-time, not regenerated on synth)\n * `playwright.config.ts` + `e2e/` starter suite. Generalizes the hand-authored\n * suite added in macedon-technologies/exman#112 so every ViteReactProject\n * consumer gets it for free (macedon-technologies/platform-common#98).\n */\nclass PlaywrightE2EComponent extends Component {\n  constructor(project: ViteReactProject, options: PlaywrightE2EComponentOptions) {\n    super(project);\n\n    project.addDevDeps(\n      '@playwright/test@^1.63.0',\n      '@clerk/testing@^2.2.34',\n      '@clerk/backend@^3.17.2',\n      'dotenv@^17.4.2',\n    );\n\n    project.addTask('test:e2e', {\n      description: 'Run the Playwright e2e suite (needs CLERK_SECRET_KEY and E2E_CLERK_USER_ID -- see e2e/README.md)',\n      exec: 'playwright test',\n    });\n\n    project.addGitIgnore('playwright-report/');\n    project.addGitIgnore('test-results/');\n    project.addGitIgnore('blob-report/');\n    // `*.local` (added elsewhere) already covers `.env.local`, but not a plain `.env` --\n    // exactly where CLERK_SECRET_KEY (a real secret) is documented to go (e2e/README.md).\n    project.addGitIgnore('.env');\n\n    new PlaywrightConfigFile(project);\n    new E2EGlobalSetupFile(project, options);\n    new E2EClerkSignInFile(project);\n    new E2ELiveHelperFile(project);\n    new E2ESmokeSpecFile(project);\n    new E2EReadmeFile(project);\n  }\n}\n\n/**\n * Creates the playwright.config.ts file. A `SampleFile`, not a managed `FileBase` --\n * consumers need to customize this (e.g. exman's own config needed a live/stub\n * branch), the same reason ViteReactProject's App.tsx/main.tsx are SampleFiles too.\n */\nclass PlaywrightConfigFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'playwright.config.ts', {\n      contents: `import { config as loadDotenv } from 'dotenv'\nimport { defineConfig, devices } from '@playwright/test'\nimport { isLiveRun } from './e2e/support/live'\n\n// Loaded here, first, rather than left to @clerk/testing's own internal dotenv call\n// inside global-setup.ts: that call runs inside globalSetup, which executes AFTER\n// Playwright has already collected every spec file and run their module-level code --\n// so anything reading process.env before then would only ever see a .env file's values\n// as unset. Loading it here, at the top of the config file Playwright reads before\n// anything else, means it's populated for collection, globalSetup, and every test.\nloadDotenv()\n\n// Set E2E_BASE_URL to run against a real deployment (e.g. a PR's pr-deploy WebsiteUrl)\n// instead of a local dev server -- see e2e/support/live.ts and e2e/README.md.\n// \\`|| undefined\\`, not \\`??\\`: an empty string (e.g. an unset GitHub Actions output) is\n// not null/undefined, so ?? would leave baseURL as '' while isLiveRun()'s plain !!\n// check still read the run as non-live -- an invalid, silently-mismatched config.\nconst liveBaseUrl = process.env.E2E_BASE_URL || undefined\n\nexport default defineConfig({\n  testDir: './e2e',\n  fullyParallel: false,\n  forbidOnly: !!process.env.CI,\n  retries: process.env.CI ? 1 : 0,\n  reporter: process.env.CI ? [['html', { open: 'never' }]] : 'list',\n  globalSetup: './e2e/support/global-setup.ts',\n  use: {\n    baseURL: liveBaseUrl ?? 'http://localhost:5173',\n    trace: 'on-first-retry',\n  },\n  projects: [\n    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },\n  ],\n  // No local server to manage when pointed at a live deployment.\n  webServer: isLiveRun() ? undefined : {\n    command: '${runScriptCommand(project.package.packageManager, 'dev')}',\n    url: 'http://localhost:5173',\n    reuseExistingServer: !process.env.CI,\n    timeout: 60_000,\n  },\n})\n`,\n    });\n  }\n}\n\ninterface E2EGlobalSetupFileOptions {\n  readonly publicDir: string;\n}\n\n/**\n * Creates e2e/support/global-setup.ts, which primes @clerk/testing for the sign-in\n * flow in clerk-sign-in.ts. Reads the Clerk publishable key from the scaffolded\n * public/config.json (ConfigJsonFile) rather than hardcoding one -- ViteReactProject's\n * own app fetches that key at runtime the same way (see config.ts), so there's no\n * build-time constant this construct could embed instead.\n */\nclass E2EGlobalSetupFile extends SampleFile {\n  constructor(project: ViteReactProject, options: E2EGlobalSetupFileOptions) {\n    super(project, 'e2e/support/global-setup.ts', {\n      contents: `import { readFileSync } from 'fs'\nimport { clerkSetup } from '@clerk/testing/playwright'\n\n// A no-op (not a throw) when CLERK_SECRET_KEY is missing: every spec that needs a\n// signed-in user already skips itself in that case (see ../smoke.spec.ts), so running\n// the suite without secrets configured yet reports \"skipped\", not a crashed global\n// setup. See e2e/README.md for how to get a secret key.\nexport default async function globalSetup() {\n  if (!process.env.CLERK_SECRET_KEY) {\n    return\n  }\n\n  // import.meta.url, not __dirname: the web package sets \"type\": \"module\" (ViteComponent),\n  // so this file runs as ESM, where __dirname isn't defined. fs.readFileSync accepts a URL\n  // directly, so no need to convert it to a path first.\n  const configPath = new URL('../../${options.publicDir}/config.json', import.meta.url)\n  const { clerkPublishableKey } = JSON.parse(readFileSync(configPath, 'utf-8'))\n\n  await clerkSetup({ publishableKey: clerkPublishableKey })\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/support/clerk-sign-in.ts. Signs in as a specific Clerk user by id via a\n * backend-issued sign-in token (ticket strategy), bypassing the app's actual sign-in\n * UI -- which typically only exposes an OAuth provider button that can't be driven\n * reliably from a test. @clerk/testing/playwright's own `clerk.signIn({ emailAddress })`\n * does the same ticket exchange internally after an extra email->user lookup; going\n * from a user id directly (E2E_CLERK_USER_ID) skips that lookup and its failure mode\n * (an existing user without a verified email attached).\n */\nclass E2EClerkSignInFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/support/clerk-sign-in.ts', {\n      contents: `import { createClerkClient } from '@clerk/backend'\nimport { clerk } from '@clerk/testing/playwright'\nimport type { Page } from '@playwright/test'\n\n/**\n * Signs in as a specific Clerk user by id. Requires CLERK_SECRET_KEY (also used by\n * global-setup.ts) and a prior page.goto() to a page that loads Clerk.\n */\nexport async function signInAsUser(page: Page, userId: string): Promise<void> {\n  const clerkClient = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY })\n  const { token } = await clerkClient.signInTokens.createSignInToken({\n    userId,\n    expiresInSeconds: 300,\n  })\n  await clerk.signIn({ page, signInParams: { strategy: 'ticket', ticket: token } })\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/support/live.ts.\n */\nclass E2ELiveHelperFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/support/live.ts', {\n      contents: `/**\n * True when this run targets a real deployment (E2E_BASE_URL set -- see\n * playwright.config.ts) rather than a local dev server. Specs read this to decide\n * whether to stub the backend: a live run must hit the real API to prove anything,\n * and stubbing it would just be testing the stub.\n */\nexport function isLiveRun(): boolean {\n  return !!process.env.E2E_BASE_URL\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/smoke.spec.ts -- a generic starter test that only relies on markup\n * ViteReactProject's own scaffolded main.tsx/App.tsx always render (SignedIn/\n * UserButton), so it works before a consumer has written any real pages. Consumers\n * are expected to extend/replace this with real flows, the same way they already\n * customize App.tsx.\n */\nclass E2ESmokeSpecFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/smoke.spec.ts', {\n      contents: `import { test, expect } from '@playwright/test'\nimport { signInAsUser } from './support/clerk-sign-in'\n\ntest('signs in and shows the authenticated UserButton', async ({ page }) => {\n  // Read from inside the test body, not module scope: Playwright collects (requires)\n  // this file before running globalSetup, so a module-level check would always see a\n  // .env-sourced value as unset. Exporting the var in the shell works either way.\n  const testUserId = process.env.E2E_CLERK_USER_ID\n  test.skip(\n    !testUserId || !process.env.CLERK_SECRET_KEY,\n    'E2E_CLERK_USER_ID and CLERK_SECRET_KEY must both be set -- see e2e/README.md',\n  )\n\n  // signInAsUser requires a prior page.goto() to a page that loads Clerk.\n  await page.goto('/')\n  await signInAsUser(page, testUserId!)\n  await page.goto('/')\n\n  // '.cl-userButtonTrigger' is one of Clerk's own documented, stable \\`cl-\\`-prefixed\n  // class hooks (part of its theming/appearance API), not an incidental DOM detail --\n  // safer to depend on across Clerk versions than app-specific markup this construct\n  // doesn't control.\n  await expect(page.locator('.cl-userButtonTrigger')).toBeVisible()\n})\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/README.md documenting the one-time setup and env var convention every\n * consumer needs, so it doesn't have to be re-derived by hand per repo.\n */\nclass E2EReadmeFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    const testE2eCommand = runScriptCommand(project.package.packageManager, 'test:e2e');\n    super(project, 'e2e/README.md', {\n      contents: `# Playwright e2e suite\n\nRuns against a real dev server (or a live deployment, via \\`E2E_BASE_URL\\`) and real\nClerk authentication.\n\n## One-time setup\n\n1. Install Playwright's browser binary (not covered by a plain dependency install):\n\n   \\`\\`\\`bash\n   npx playwright install chromium\n   \\`\\`\\`\n\n2. Get two values from your Clerk dashboard's dev instance:\n\n   - \\`CLERK_SECRET_KEY\\` -- the **secret** key (API Keys). Never commit this; export it\n     in your shell or put it in a local, gitignored \\`.env\\`.\n   - \\`E2E_CLERK_USER_ID\\` -- the id (\\`user_...\\`) of an existing test user (Users -> click\n     a user, the id is shown at the top). The user needs a verified email address, not\n     just an OAuth connection -- a sign-in token has to bind to a verified\n     identification. Creating a dedicated test user with an email set explicitly is the\n     safer default.\n\n   A run with either variable unset **skips** rather than failing, so \\`${testE2eCommand}\\`\n   is always safe to run without them.\n\n3. This construct doesn't manage \\`vitest.config.ts\\` (it's a hand-authored,\n   per-consumer file). Add an \\`exclude\\` entry so vitest's default test glob doesn't\n   also try to pick up these Playwright spec files:\n\n   \\`\\`\\`ts\n   import { defineConfig, configDefaults } from 'vitest/config'\n\n   export default defineConfig({\n     test: {\n       exclude: [...configDefaults.exclude, 'e2e/**'],\n       // ...your existing config\n     },\n   })\n   \\`\\`\\`\n\n## Running\n\n\\`\\`\\`bash\nCLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... ${testE2eCommand}\n\\`\\`\\`\n\n## Running against a live environment\n\nSet \\`E2E_BASE_URL\\` to point the suite at a real deployment (a personal dev stack, or a\nPR's pr-deploy \\`WebsiteUrl\\`, posted as a PR comment) instead of a local dev server:\n\n\\`\\`\\`bash\nE2E_BASE_URL=https://<your-stack>.example.com \\\\\nCLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... \\\\\n${testE2eCommand}\n\\`\\`\\`\n\n## CI\n\nThe generated \\`pr-deploy.yml\\` workflow (see \\`PrDeployWorkflow\\`) already runs this\nsuite against each PR's deployed \\`WebsiteUrl\\` and uploads the HTML report as a build\nartifact on failure. It self-skips exactly like a local run until both secrets exist\nin the repo:\n\n\\`\\`\\`bash\ngh secret set CLERK_SECRET_KEY\ngh secret set E2E_CLERK_USER_ID\n\\`\\`\\`\n`,\n    });\n  }\n}\n"]}