expo-bbase 1.0.0

package/dist/index.js

@@ -0,0 +1,3611 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createProject: () => createProject,
+  run: () => run
+});
+module.exports = __toCommonJS(src_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_prompts = __toESM(require("prompts"));
+var import_ora = __toESM(require("ora"));
+var import_path2 = __toESM(require("path"));
+var import_commander = require("commander");
+
+// src/commands/create.ts
+function registerCreateCommand(program) {
+  program.command("create <project-name>").description("Create a new Expo project with selected modules").action(async (projectName) => {
+    await createProject(projectName);
+  });
+}
+
+// src/utils/lines.ts
+function lines(...args) {
+  return args.join("\n");
+}
+
+// src/modules/network.ts
+var networkModule = {
+  id: "network",
+  name: "\u7F51\u7EDC\u8BF7\u6C42",
+  description: "TanStack Query \u5C01\u88C5\uFF0C\u7EDF\u4E00\u62E6\u622A\u5668\u3001\u9519\u8BEF\u5904\u7406",
+  defaultChecked: true,
+  dependencies: {
+    "@tanstack/react-query": "^5.60.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/api/client.ts",
+      content: lines(
+        'import { Alert } from "react-native";',
+        "",
+        'const API_BASE_URL = process.env.EXPO_PUBLIC_API_URL || "https://api.example.com";',
+        "",
+        "interface RequestConfig {",
+        '  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";',
+        "  url: string;",
+        "  data?: unknown;",
+        "  headers?: Record<string, string>;",
+        "  params?: Record<string, string>;",
+        "}",
+        "",
+        "interface ApiResponse<T> {",
+        "  data: T;",
+        "  message: string;",
+        "  code: number;",
+        "}",
+        "",
+        "class ApiClient {",
+        "  private baseUrl: string;",
+        "  private defaultHeaders: Record<string, string>;",
+        "  private requestInterceptors: Array<(config: RequestConfig) => RequestConfig> = [];",
+        "  private responseInterceptors: Array<(response: Response) => Response> = [];",
+        "",
+        "  constructor(baseUrl: string) {",
+        "    this.baseUrl = baseUrl;",
+        "    this.defaultHeaders = {",
+        '      "Content-Type": "application/json",',
+        '      Accept: "application/json",',
+        "    };",
+        "  }",
+        "",
+        "  /** Add a request interceptor */",
+        "  addRequestInterceptor(interceptor: (config: RequestConfig) => RequestConfig): void {",
+        "    this.requestInterceptors.push(interceptor);",
+        "  }",
+        "",
+        "  /** Add a response interceptor */",
+        "  addResponseInterceptor(interceptor: (response: Response) => Response): void {",
+        "    this.responseInterceptors.push(interceptor);",
+        "  }",
+        "",
+        "  /** Set the authorization token */",
+        "  setAuthToken(token: string): void {",
+        '    this.defaultHeaders["Authorization"] = `Bearer ${token}`;',
+        "  }",
+        "",
+        "  /** Clear the authorization token */",
+        "  clearAuthToken(): void {",
+        '    delete this.defaultHeaders["Authorization"];',
+        "  }",
+        "",
+        "  /** Apply request interceptors */",
+        "  private applyRequestInterceptors(config: RequestConfig): RequestConfig {",
+        "    return this.requestInterceptors.reduce(",
+        "      (acc, interceptor) => interceptor(acc),",
+        "      config",
+        "    );",
+        "  }",
+        "",
+        "  /** Build URL with query params */",
+        "  private buildUrl(url: string, params?: Record<string, string>): string {",
+        "    const fullUrl = new URL(url, this.baseUrl);",
+        "    if (params) {",
+        "      Object.entries(params).forEach(([key, value]) => {",
+        "        fullUrl.searchParams.append(key, value);",
+        "      });",
+        "    }",
+        "    return fullUrl.toString();",
+        "  }",
+        "",
+        "  /** Core request method */",
+        "  async request<T>(config: RequestConfig): Promise<ApiResponse<T>> {",
+        "    const interceptedConfig = this.applyRequestInterceptors(config);",
+        "    const url = this.buildUrl(interceptedConfig.url, interceptedConfig.params);",
+        "",
+        "    try {",
+        "      const response = await fetch(url, {",
+        "        method: interceptedConfig.method,",
+        "        headers: {",
+        "          ...this.defaultHeaders,",
+        "          ...interceptedConfig.headers,",
+        "        },",
+        "        body: interceptedConfig.data",
+        "          ? JSON.stringify(interceptedConfig.data)",
+        "          : undefined,",
+        "      });",
+        "",
+        "      if (!response.ok) {",
+        "        const errorData = await response.json().catch(() => null);",
+        "        throw new ApiError(",
+        "          response.status,",
+        "          errorData?.message || response.statusText,",
+        "          errorData",
+        "        );",
+        "      }",
+        "",
+        "      const data: ApiResponse<T> = await response.json();",
+        "      return data;",
+        "    } catch (error) {",
+        "      if (error instanceof ApiError) {",
+        "        throw error;",
+        "      }",
+        '      throw new ApiError(0, "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5", null);',
+        "    }",
+        "  }",
+        "",
+        "  /** GET request */",
+        "  async get<T>(url: string, params?: Record<string, string>): Promise<ApiResponse<T>> {",
+        '    return this.request<T>({ method: "GET", url, params });',
+        "  }",
+        "",
+        "  /** POST request */",
+        "  async post<T>(url: string, data?: unknown): Promise<ApiResponse<T>> {",
+        '    return this.request<T>({ method: "POST", url, data });',
+        "  }",
+        "",
+        "  /** PUT request */",
+        "  async put<T>(url: string, data?: unknown): Promise<ApiResponse<T>> {",
+        '    return this.request<T>({ method: "PUT", url, data });',
+        "  }",
+        "",
+        "  /** PATCH request */",
+        "  async patch<T>(url: string, data?: unknown): Promise<ApiResponse<T>> {",
+        '    return this.request<T>({ method: "PATCH", url, data });',
+        "  }",
+        "",
+        "  /** DELETE request */",
+        "  async delete<T>(url: string): Promise<ApiResponse<T>> {",
+        '    return this.request<T>({ method: "DELETE", url });',
+        "  }",
+        "}",
+        "",
+        "/** Custom API error class */",
+        "export class ApiError extends Error {",
+        "  code: number;",
+        "  detail: unknown;",
+        "",
+        "  constructor(code: number, message: string, detail: unknown) {",
+        "    super(message);",
+        '    this.name = "ApiError";',
+        "    this.code = code;",
+        "    this.detail = detail;",
+        "  }",
+        "}",
+        "",
+        "/** Global error handler */",
+        "export function handleApiError(error: unknown): void {",
+        "  if (error instanceof ApiError) {",
+        "    if (error.code === 401) {",
+        '      Alert.alert("\u8BA4\u8BC1\u5931\u8D25", "\u8BF7\u91CD\u65B0\u767B\u5F55");',
+        "    } else if (error.code === 403) {",
+        '      Alert.alert("\u6743\u9650\u4E0D\u8DB3", "\u60A8\u6CA1\u6709\u6743\u9650\u6267\u884C\u6B64\u64CD\u4F5C");',
+        "    } else if (error.code === 0) {",
+        '      Alert.alert("\u7F51\u7EDC\u9519\u8BEF", error.message);',
+        "    } else {",
+        '      Alert.alert("\u8BF7\u6C42\u5931\u8D25", error.message);',
+        "    }",
+        "  } else {",
+        '    Alert.alert("\u672A\u77E5\u9519\u8BEF", "\u8BF7\u7A0D\u540E\u91CD\u8BD5");',
+        "  }",
+        "}",
+        "",
+        "/** Singleton API client instance */",
+        "export const apiClient = new ApiClient(API_BASE_URL);",
+        "",
+        "export default apiClient;"
+      )
+    },
+    {
+      path: "src/api/interceptors.ts",
+      content: lines(
+        'import type { RequestConfig } from "./client";',
+        'import { apiClient } from "./client";',
+        "",
+        "/**",
+        " * Initialize all request interceptors.",
+        " * Called once during app startup.",
+        " */",
+        "export function setupRequestInterceptors(): void {",
+        "  apiClient.addRequestInterceptor((config: RequestConfig) => {",
+        "    return config;",
+        "  });",
+        "",
+        "  if (__DEV__) {",
+        "    apiClient.addRequestInterceptor((config: RequestConfig) => {",
+        "      console.log(",
+        "        `[API Request] ${config.method} ${config.url}`,",
+        '        config.data ? config.data : ""',
+        "      );",
+        "      return config;",
+        "    });",
+        "  }",
+        "}",
+        "",
+        "/**",
+        " * Initialize all response interceptors.",
+        " * Called once during app startup.",
+        " */",
+        "export function setupResponseInterceptors(): void {",
+        "  if (__DEV__) {",
+        "    apiClient.addResponseInterceptor((response: Response) => {",
+        "      console.log(`[API Response] ${response.status} ${response.url}`);",
+        "      return response;",
+        "    });",
+        "  }",
+        "}",
+        "",
+        "/**",
+        " * Setup all interceptors at once.",
+        " */",
+        "export function setupInterceptors(): void {",
+        "  setupRequestInterceptors();",
+        "  setupResponseInterceptors();",
+        "}"
+      )
+    },
+    {
+      path: "src/api/types.ts",
+      content: lines(
+        "/** Common API response types */",
+        "",
+        "/** Paginated response wrapper */",
+        "export interface PaginatedResponse<T> {",
+        "  data: T[];",
+        "  total: number;",
+        "  page: number;",
+        "  pageSize: number;",
+        "  totalPages: number;",
+        "}",
+        "",
+        "/** Standard API response */",
+        "export interface ApiResponse<T> {",
+        "  data: T;",
+        "  message: string;",
+        "  code: number;",
+        "}",
+        "",
+        "/** Common error response */",
+        "export interface ErrorResponse {",
+        "  message: string;",
+        "  code: number;",
+        "  errors?: Record<string, string[]>;",
+        "}",
+        "",
+        "/** User type example */",
+        "export interface User {",
+        "  id: string;",
+        "  email: string;",
+        "  name: string;",
+        "  avatar?: string;",
+        "  createdAt: string;",
+        "  updatedAt: string;",
+        "}",
+        "",
+        "/** Auth response */",
+        "export interface AuthResponse {",
+        "  user: User;",
+        "  token: string;",
+        "  refreshToken: string;",
+        "}"
+      )
+    },
+    {
+      path: "src/api/queries.ts",
+      content: lines(
+        'import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";',
+        'import { apiClient, handleApiError } from "./client";',
+        'import type { ApiResponse } from "./types";',
+        "",
+        "/**",
+        " * Example query hook for fetching data.",
+        " */",
+        "export function useApiQuery<T>(",
+        "  key: string[],",
+        "  url: string,",
+        "  params?: Record<string, string>",
+        ") {",
+        "  return useQuery({",
+        "    queryKey: key,",
+        "    queryFn: () => apiClient.get<T>(url, params),",
+        "    retry: 2,",
+        "    staleTime: 5 * 60 * 1000,",
+        "  });",
+        "}",
+        "",
+        "/**",
+        " * Example mutation hook for posting data.",
+        " */",
+        "export function useApiMutation<TData, TVariables>(",
+        "  url: string,",
+        '  method: "POST" | "PUT" | "PATCH" = "POST"',
+        ") {",
+        "  const queryClient = useQueryClient();",
+        "",
+        "  return useMutation({",
+        "    mutationFn: (variables: TVariables) => {",
+        "      switch (method) {",
+        '        case "PUT":',
+        "          return apiClient.put<TData>(url, variables);",
+        '        case "PATCH":',
+        "          return apiClient.patch<TData>(url, variables);",
+        "        default:",
+        "          return apiClient.post<TData>(url, variables);",
+        "      }",
+        "    },",
+        "    onSuccess: () => {",
+        "      queryClient.invalidateQueries({ queryKey: [url] });",
+        "    },",
+        "    onError: (error) => {",
+        "      handleApiError(error);",
+        "    },",
+        "  });",
+        "}",
+        "",
+        "/**",
+        " * Example: Fetch current user profile",
+        " */",
+        "export function useUserProfile() {",
+        "  return useApiQuery<ApiResponse<{ name: string; email: string }>>(",
+        '    ["user", "profile"],',
+        '    "/user/profile"',
+        "  );",
+        "}"
+      )
+    }
+  ],
+  layoutProviders: ["<QueryClientProvider client={queryClient}>"],
+  layoutImports: [
+    'import { QueryClient, QueryClientProvider } from "@tanstack/react-query";',
+    "const queryClient = new QueryClient({ defaultOptions: { queries: { retry: 2, staleTime: 5 * 60 * 1000 } } });"
+  ]
+};
+var network_default = networkModule;
+
+// src/modules/state.ts
+var stateModule = {
+  id: "state",
+  name: "\u72B6\u6001\u7BA1\u7406",
+  description: "Zustand stores \u6A21\u677F\uFF0Cpersist \u4E2D\u95F4\u4EF6",
+  defaultChecked: true,
+  dependencies: {
+    zustand: "^5.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/stores/index.ts",
+      content: lines('export { useUserStore } from "./slices/userSlice";')
+    },
+    {
+      path: "src/stores/slices/userSlice.ts",
+      content: lines(
+        'import { create } from "zustand";',
+        'import { persist, createJSONStorage } from "zustand/middleware";',
+        "",
+        "interface User {",
+        "  id: string;",
+        "  email: string;",
+        "  name: string;",
+        "  avatar?: string;",
+        "}",
+        "",
+        "interface UserState {",
+        "  user: User | null;",
+        "  token: string | null;",
+        "  isAuthenticated: boolean;",
+        "  hasHydrated: boolean;",
+        "",
+        "  setUser: (user: User, token: string) => void;",
+        "  updateUser: (partial: Partial<User>) => void;",
+        "  clearUser: () => void;",
+        "  setHasHydrated: (value: boolean) => void;",
+        "}",
+        "",
+        "export const useUserStore = create<UserState>()(",
+        "  persist(",
+        "    (set, get) => ({",
+        "      user: null,",
+        "      token: null,",
+        "      isAuthenticated: false,",
+        "      hasHydrated: false,",
+        "",
+        "      setUser: (user: User, token: string) => {",
+        "        set({ user, token, isAuthenticated: true });",
+        "      },",
+        "",
+        "      updateUser: (partial: Partial<User>) => {",
+        "        const currentUser = get().user;",
+        "        if (currentUser) {",
+        "          set({ user: { ...currentUser, ...partial } });",
+        "        }",
+        "      },",
+        "",
+        "      clearUser: () => {",
+        "        set({ user: null, token: null, isAuthenticated: false });",
+        "      },",
+        "",
+        "      setHasHydrated: (value: boolean) => {",
+        "        set({ hasHydrated: value });",
+        "      },",
+        "    }),",
+        "    {",
+        '      name: "user-store",',
+        "      storage: createJSONStorage(() => {",
+        "        try {",
+        '          const { MMKV } = require("react-native-mmkv");',
+        "          const storage = new MMKV();",
+        "          return {",
+        "            getItem: (name: string) => {",
+        "              const value = storage.getString(name);",
+        "              return value ?? null;",
+        "            },",
+        "            setItem: (name: string, value: string) => {",
+        "              storage.set(name, value);",
+        "            },",
+        "            removeItem: (name: string) => {",
+        "              storage.delete(name);",
+        "            },",
+        "          };",
+        "        } catch {",
+        "          return {",
+        "            getItem: () => null,",
+        "            setItem: () => {},",
+        "            removeItem: () => {},",
+        "          };",
+        "        }",
+        "      }),",
+        "      partialize: (state) => ({",
+        "        user: state.user,",
+        "        token: state.token,",
+        "        isAuthenticated: state.isAuthenticated,",
+        "      }),",
+        "      onRehydrateStorage: () => (state) => {",
+        "        state?.setHasHydrated(true);",
+        "      },",
+        "    }",
+        "  )",
+        ");"
+      )
+    }
+  ]
+};
+var state_default = stateModule;
+
+// src/modules/storage.ts
+var storageModule = {
+  id: "storage",
+  name: "\u672C\u5730\u5B58\u50A8",
+  description: "MMKV \u5C01\u88C5\uFF0C\u7C7B\u578B\u5B89\u5168 API",
+  defaultChecked: true,
+  dependencies: {
+    "react-native-mmkv": "^3.1.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/storage/index.ts",
+      content: lines(
+        'import { MMKV } from "react-native-mmkv";',
+        "",
+        "/**",
+        " * Centralized MMKV storage instance.",
+        " */",
+        "const storage = new MMKV({",
+        '  id: "app-storage",',
+        "  encryptionKey: process.env.EXPO_PUBLIC_STORAGE_KEY || undefined,",
+        "});",
+        "",
+        "/** Storage keys */",
+        "export const StorageKeys = {",
+        '  AUTH_TOKEN: "auth_token",',
+        '  REFRESH_TOKEN: "refresh_token",',
+        '  USER_DATA: "user_data",',
+        '  THEME: "theme",',
+        '  LANGUAGE: "language",',
+        '  ONBOARDING_COMPLETED: "onboarding_completed",',
+        '  LAST_SYNC_TIME: "last_sync_time",',
+        '  CACHE_VERSION: "cache_version",',
+        "} as const;",
+        "",
+        "export type StorageKey = (typeof StorageKeys)[keyof typeof StorageKeys];",
+        "",
+        "export function getString(key: StorageKey): string | null {",
+        "  return storage.getString(key) ?? null;",
+        "}",
+        "",
+        "export function setString(key: StorageKey, value: string): void {",
+        "  storage.set(key, value);",
+        "}",
+        "",
+        "export function getNumber(key: StorageKey): number | null {",
+        "  const value = storage.getNumber(key);",
+        "  return value ?? null;",
+        "}",
+        "",
+        "export function setNumber(key: StorageKey, value: number): void {",
+        "  storage.set(key, value);",
+        "}",
+        "",
+        "export function getBoolean(key: StorageKey): boolean | null {",
+        "  const value = storage.getBoolean(key);",
+        "  return value ?? null;",
+        "}",
+        "",
+        "export function setBoolean(key: StorageKey, value: boolean): void {",
+        "  storage.set(key, value);",
+        "}",
+        "",
+        "export function getJson<T>(key: StorageKey): T | null {",
+        "  const raw = storage.getString(key);",
+        "  if (raw === undefined) return null;",
+        "  try {",
+        "    return JSON.parse(raw) as T;",
+        "  } catch {",
+        "    return null;",
+        "  }",
+        "}",
+        "",
+        "export function setJson<T>(key: StorageKey, value: T): void {",
+        "  storage.set(key, JSON.stringify(value));",
+        "}",
+        "",
+        "export function remove(key: StorageKey): void {",
+        "  storage.delete(key);",
+        "}",
+        "",
+        "export function contains(key: StorageKey): boolean {",
+        "  return storage.contains(key);",
+        "}",
+        "",
+        "export function clearAll(): void {",
+        "  storage.clearAll();",
+        "}",
+        "",
+        "export function getAllKeys(): string[] {",
+        "  return storage.getAllKeys();",
+        "}",
+        "",
+        "export default storage;"
+      )
+    }
+  ],
+  appConfig: {
+    plugins: [
+      [
+        "react-native-mmkv",
+        {
+          MMKV_APP_ID: "app-storage"
+        }
+      ]
+    ]
+  }
+};
+var storage_default = storageModule;
+
+// src/modules/payment.ts
+var paymentModule = {
+  id: "payment",
+  name: "Apple/iOS \u652F\u4ED8",
+  description: "react-native-iap \u5C01\u88C5",
+  defaultChecked: false,
+  dependencies: {
+    "react-native-iap": "^12.15.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/payment/index.ts",
+      content: lines(
+        'export { usePayment } from "./usePayment";',
+        'export type { ProductInfo, PurchaseResult, PaymentError } from "./types";'
+      )
+    },
+    {
+      path: "src/modules/payment/types.ts",
+      content: lines(
+        'import type { Product, Purchase } from "react-native-iap";',
+        "",
+        "export interface ProductInfo {",
+        "  productId: string;",
+        "  title: string;",
+        "  description: string;",
+        "  price: string;",
+        "  currency: string;",
+        "}",
+        "",
+        "export interface PurchaseResult {",
+        "  success: boolean;",
+        "  purchase?: Purchase;",
+        "  error?: PaymentError;",
+        "}",
+        "",
+        "export interface PaymentError {",
+        "  code: string;",
+        "  message: string;",
+        "  nativeError?: unknown;",
+        "}",
+        "",
+        "export interface PaymentConfig {",
+        "  productIds: string[];",
+        "  subscriptionIds?: string[];",
+        "}"
+      )
+    },
+    {
+      path: "src/modules/payment/usePayment.ts",
+      content: lines(
+        'import { useCallback, useEffect, useRef, useState } from "react";',
+        "import {",
+        "  initConnection,",
+        "  endConnection,",
+        "  getProducts,",
+        "  requestPurchase,",
+        "  requestSubscription,",
+        "  finishTransaction,",
+        "  purchaseUpdatedListener,",
+        "  purchaseErrorListener,",
+        "  Product,",
+        "  Purchase,",
+        "  PurchaseError,",
+        '} from "react-native-iap";',
+        'import type { PaymentConfig, ProductInfo, PurchaseResult, PaymentError as AppPaymentError } from "./types";',
+        "",
+        "export function usePayment(config: PaymentConfig) {",
+        "  const [products, setProducts] = useState<ProductInfo[]>([]);",
+        "  const [isLoading, setIsLoading] = useState(false);",
+        "  const [isConnected, setIsConnected] = useState(false);",
+        "  const purchaseUpdateSubscription = useRef<ReturnType<typeof purchaseUpdatedListener> | null>(null);",
+        "  const purchaseErrorSubscription = useRef<ReturnType<typeof purchaseErrorListener> | null>(null);",
+        "",
+        "  const initialize = useCallback(async () => {",
+        "    try {",
+        "      setIsLoading(true);",
+        "      const connected = await initConnection();",
+        "      setIsConnected(connected);",
+        "",
+        "      if (connected) {",
+        "        const allIds = [...config.productIds, ...(config.subscriptionIds || [])];",
+        "        if (allIds.length > 0) {",
+        "          const fetchedProducts = await getProducts({ skus: allIds });",
+        "          const mapped = fetchedProducts.map(mapProductToInfo);",
+        "          setProducts(mapped);",
+        "        }",
+        "      }",
+        "    } catch (error) {",
+        '      console.error("[Payment] Initialization failed:", error);',
+        "    } finally {",
+        "      setIsLoading(false);",
+        "    }",
+        "  }, [config.productIds, config.subscriptionIds]);",
+        "",
+        "  const handlePurchase = useCallback(",
+        "    async (purchase: Purchase): Promise<void> => {",
+        "      const receipt = purchase.transactionReceipt;",
+        "      if (receipt) {",
+        "        // TODO: Validate receipt with your backend server",
+        "        await finishTransaction({ purchase, isConsumable: false });",
+        "      }",
+        "    },",
+        "    []",
+        "  );",
+        "",
+        "  const buyProduct = useCallback(",
+        "    async (productId: string): Promise<PurchaseResult> => {",
+        "      try {",
+        "        const purchase = await requestPurchase({ sku: productId });",
+        "        if (purchase && purchase.length > 0) {",
+        "          await handlePurchase(purchase[0]);",
+        "          return { success: true, purchase: purchase[0] };",
+        "        }",
+        "        return { success: false };",
+        "      } catch (error) {",
+        "        const paymentError = mapError(error);",
+        "        return { success: false, error: paymentError };",
+        "      }",
+        "    },",
+        "    [handlePurchase]",
+        "  );",
+        "",
+        "  const buySubscription = useCallback(",
+        "    async (subscriptionId: string): Promise<PurchaseResult> => {",
+        "      try {",
+        "        const purchase = await requestSubscription({ sku: subscriptionId });",
+        "        if (purchase && purchase.length > 0) {",
+        "          await handlePurchase(purchase[0]);",
+        "          return { success: true, purchase: purchase[0] };",
+        "        }",
+        "        return { success: false };",
+        "      } catch (error) {",
+        "        const paymentError = mapError(error);",
+        "        return { success: false, error: paymentError };",
+        "      }",
+        "    },",
+        "    [handlePurchase]",
+        "  );",
+        "",
+        "  useEffect(() => {",
+        "    initialize();",
+        "",
+        "    purchaseUpdateSubscription.current = purchaseUpdatedListener(",
+        "      async (purchase: Purchase) => {",
+        '        console.log("[Payment] Purchase updated:", purchase.transactionId);',
+        "        await handlePurchase(purchase);",
+        "      }",
+        "    );",
+        "",
+        "    purchaseErrorSubscription.current = purchaseErrorListener(",
+        "      (error: PurchaseError) => {",
+        '        console.error("[Payment] Purchase error:", error.message);',
+        "      }",
+        "    );",
+        "",
+        "    return () => {",
+        "      purchaseUpdateSubscription.current?.remove();",
+        "      purchaseErrorSubscription.current?.remove();",
+        "      endConnection();",
+        "    };",
+        "  }, [initialize, handlePurchase]);",
+        "",
+        "  return {",
+        "    products,",
+        "    isLoading,",
+        "    isConnected,",
+        "    buyProduct,",
+        "    buySubscription,",
+        "    refresh: initialize,",
+        "  };",
+        "}",
+        "",
+        "function mapProductToInfo(product: Product): ProductInfo {",
+        "  return {",
+        "    productId: product.productId,",
+        "    title: product.title,",
+        "    description: product.description,",
+        "    price: product.price,",
+        '    currency: product.currency || "USD",',
+        "  };",
+        "}",
+        "",
+        "function mapError(error: unknown): AppPaymentError {",
+        "  if (error instanceof Error) {",
+        "    return {",
+        '      code: "PURCHASE_ERROR",',
+        "      message: error.message,",
+        "    };",
+        "  }",
+        "  return {",
+        '    code: "UNKNOWN_ERROR",',
+        '    message: "An unknown error occurred",',
+        "  };",
+        "}"
+      )
+    }
+  ]
+};
+var payment_default = paymentModule;
+
+// src/modules/form.ts
+var formModule = {
+  id: "form",
+  name: "\u8868\u5355\u9A8C\u8BC1",
+  description: "React Hook Form + Zod",
+  defaultChecked: false,
+  dependencies: {
+    "react-hook-form": "^7.54.0",
+    "@hookform/resolvers": "^3.9.0",
+    zod: "^3.24.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/form/index.ts",
+      content: lines(
+        'export { useForm } from "react-hook-form";',
+        'export { z } from "zod";',
+        'export { zodResolver } from "@hookform/resolvers/zod";',
+        'export * from "./schemas/auth";'
+      )
+    },
+    {
+      path: "src/modules/form/schemas/auth.ts",
+      content: lines(
+        'import { z } from "zod";',
+        "",
+        "export const loginSchema = z.object({",
+        "  email: z",
+        "    .string()",
+        '    .min(1, "\u8BF7\u8F93\u5165\u90AE\u7BB1\u5730\u5740")',
+        '    .email("\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740"),',
+        "  password: z",
+        "    .string()",
+        '    .min(6, "\u5BC6\u7801\u81F3\u5C116\u4F4D")',
+        '    .max(50, "\u5BC6\u7801\u6700\u591A50\u4F4D"),',
+        "});",
+        "",
+        "export const registerSchema = z",
+        "  .object({",
+        "    name: z",
+        "      .string()",
+        '      .min(2, "\u59D3\u540D\u81F3\u5C112\u4E2A\u5B57\u7B26")',
+        '      .max(50, "\u59D3\u540D\u6700\u591A50\u4E2A\u5B57\u7B26"),',
+        "    email: z",
+        "      .string()",
+        '      .min(1, "\u8BF7\u8F93\u5165\u90AE\u7BB1\u5730\u5740")',
+        '      .email("\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740"),',
+        "    password: z",
+        "      .string()",
+        '      .min(6, "\u5BC6\u7801\u81F3\u5C116\u4F4D")',
+        '      .max(50, "\u5BC6\u7801\u6700\u591A50\u4F4D"),',
+        '    confirmPassword: z.string().min(1, "\u8BF7\u786E\u8BA4\u5BC6\u7801"),',
+        "  })",
+        "  .refine((data) => data.password === data.confirmPassword, {",
+        '    message: "\u4E24\u6B21\u5BC6\u7801\u8F93\u5165\u4E0D\u4E00\u81F4",',
+        '    path: ["confirmPassword"],',
+        "  });",
+        "",
+        "export const resetPasswordSchema = z.object({",
+        "  email: z",
+        "    .string()",
+        '    .min(1, "\u8BF7\u8F93\u5165\u90AE\u7BB1\u5730\u5740")',
+        '    .email("\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740"),',
+        "});",
+        "",
+        "export const changePasswordSchema = z",
+        "  .object({",
+        '    currentPassword: z.string().min(1, "\u8BF7\u8F93\u5165\u5F53\u524D\u5BC6\u7801"),',
+        "    newPassword: z",
+        "      .string()",
+        '      .min(6, "\u65B0\u5BC6\u7801\u81F3\u5C116\u4F4D")',
+        '      .max(50, "\u65B0\u5BC6\u7801\u6700\u591A50\u4F4D"),',
+        '    confirmPassword: z.string().min(1, "\u8BF7\u786E\u8BA4\u65B0\u5BC6\u7801"),',
+        "  })",
+        "  .refine((data) => data.newPassword === data.confirmPassword, {",
+        '    message: "\u4E24\u6B21\u5BC6\u7801\u8F93\u5165\u4E0D\u4E00\u81F4",',
+        '    path: ["confirmPassword"],',
+        "  });",
+        "",
+        "export type LoginFormData = z.infer<typeof loginSchema>;",
+        "export type RegisterFormData = z.infer<typeof registerSchema>;",
+        "export type ResetPasswordFormData = z.infer<typeof resetPasswordSchema>;",
+        "export type ChangePasswordFormData = z.infer<typeof changePasswordSchema>;"
+      )
+    }
+  ]
+};
+var form_default = formModule;
+
+// src/modules/image.ts
+var imageModule = {
+  id: "image",
+  name: "\u56FE\u7247",
+  description: "expo-image \u5C01\u88C5",
+  defaultChecked: false,
+  dependencies: {
+    "expo-image": "~2.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/media/CachedImage.tsx",
+      content: lines(
+        'import React, { useMemo } from "react";',
+        'import { Image, type ImageProps } from "expo-image";',
+        'import { StyleSheet, View, ActivityIndicator } from "react-native";',
+        "",
+        'interface CachedImageProps extends Omit<ImageProps, "source"> {',
+        "  uri: string;",
+        "  width?: number;",
+        "  height?: number;",
+        "  borderRadius?: number;",
+        "  placeholderColor?: string;",
+        "  showLoading?: boolean;",
+        "}",
+        "",
+        "export function CachedImage({",
+        "  uri,",
+        "  width,",
+        "  height,",
+        "  borderRadius,",
+        '  placeholderColor = "#f0f0f0",',
+        "  showLoading = true,",
+        "  style,",
+        "  ...rest",
+        "}: CachedImageProps) {",
+        "  const containerStyle = useMemo(",
+        "    () =>",
+        "      StyleSheet.compose(",
+        "        {",
+        "          width,",
+        "          height,",
+        "          borderRadius,",
+        "          backgroundColor: placeholderColor,",
+        '          overflow: "hidden",',
+        "        },",
+        "        style as any",
+        "      ),",
+        "    [width, height, borderRadius, placeholderColor, style]",
+        "  );",
+        "",
+        "  return (",
+        "    <View style={containerStyle}>",
+        "      <Image",
+        "        source={{ uri }}",
+        "        style={StyleSheet.absoluteFillObject}",
+        '        contentFit="cover"',
+        "        transition={200}",
+        "        placeholder={{",
+        '          blurhash: "LEHV6nWB2yk8pyo0adR*.7kCMdnj",',
+        "        }}",
+        "        {...rest}",
+        "      />",
+        "      {showLoading && (",
+        "        <Image.LoadingIndicatorContainer",
+        "          style={StyleSheet.absoluteFillObject}",
+        "        >",
+        '          <ActivityIndicator color="#999" />',
+        "        </Image.LoadingIndicatorContainer>",
+        "      )}",
+        "    </View>",
+        "  );",
+        "}",
+        "",
+        "export default CachedImage;"
+      )
+    }
+  ]
+};
+var image_default = imageModule;
+
+// src/modules/video.ts
+var videoModule = {
+  id: "video",
+  name: "\u89C6\u9891",
+  description: "expo-av \u5C01\u88C5",
+  defaultChecked: false,
+  dependencies: {
+    "expo-av": "~15.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/media/VideoPlayer.tsx",
+      content: lines(
+        'import React, { useCallback, useRef, useState } from "react";',
+        "import {",
+        "  Video,",
+        "  ResizeMode,",
+        "  type AVPlaybackStatus,",
+        "  type VideoProps,",
+        '} from "expo-av";',
+        'import { StyleSheet, View, TouchableOpacity, ActivityIndicator } from "react-native";',
+        "",
+        'interface VideoPlayerProps extends Omit<VideoProps, "source"> {',
+        "  uri: string;",
+        "  autoPlay?: boolean;",
+        "  loop?: boolean;",
+        "  showControls?: boolean;",
+        "  width?: number;",
+        "  height?: number;",
+        "}",
+        "",
+        "export function VideoPlayer({",
+        "  uri,",
+        "  autoPlay = false,",
+        "  loop = false,",
+        "  showControls = true,",
+        "  width,",
+        "  height,",
+        "  style,",
+        "  ...rest",
+        "}: VideoPlayerProps) {",
+        "  const videoRef = useRef<Video>(null);",
+        "  const [isPlaying, setIsPlaying] = useState(autoPlay);",
+        "  const [isLoading, setIsLoading] = useState(true);",
+        "",
+        "  const handlePlaybackStatusUpdate = useCallback(",
+        "    (status: AVPlaybackStatus) => {",
+        "      if (status.isLoaded) {",
+        "        setIsLoading(status.isBuffering);",
+        "        setIsPlaying(status.isPlaying);",
+        "      }",
+        "    },",
+        "    []",
+        "  );",
+        "",
+        "  const togglePlayback = useCallback(async () => {",
+        "    if (!videoRef.current) return;",
+        "    if (isPlaying) {",
+        "      await videoRef.current.pauseAsync();",
+        "    } else {",
+        "      await videoRef.current.playAsync();",
+        "    }",
+        "  }, [isPlaying]);",
+        "",
+        "  const containerStyle = StyleSheet.compose(",
+        '    { width, height, backgroundColor: "#000", borderRadius: 8, overflow: "hidden" },',
+        "    style as any",
+        "  );",
+        "",
+        "  return (",
+        "    <View style={containerStyle}>",
+        "      <Video",
+        "        ref={videoRef}",
+        "        source={{ uri }}",
+        "        style={StyleSheet.absoluteFillObject}",
+        "        resizeMode={ResizeMode.CONTAIN}",
+        "        shouldPlay={autoPlay}",
+        "        isLooping={loop}",
+        "        onPlaybackStatusUpdate={handlePlaybackStatusUpdate}",
+        "        {...rest}",
+        "      />",
+        "",
+        "      {isLoading && (",
+        "        <View style={styles.overlay}>",
+        '          <ActivityIndicator color="#fff" size="large" />',
+        "        </View>",
+        "      )}",
+        "",
+        "      {showControls && !isLoading && (",
+        "        <TouchableOpacity",
+        "          style={styles.overlay}",
+        "          onPress={togglePlayback}",
+        "          activeOpacity={0.7}",
+        "        />",
+        "      )}",
+        "    </View>",
+        "  );",
+        "}",
+        "",
+        "const styles = StyleSheet.create({",
+        "  overlay: {",
+        "    ...StyleSheet.absoluteFillObject,",
+        '    justifyContent: "center",',
+        '    alignItems: "center",',
+        '    backgroundColor: "rgba(0, 0, 0, 0.3)",',
+        "  },",
+        "});",
+        "",
+        "export default VideoPlayer;"
+      )
+    }
+  ]
+};
+var video_default = videoModule;
+
+// src/modules/auth-google.ts
+var authGoogleModule = {
+  id: "auth-google",
+  name: "Google \u767B\u5F55",
+  description: "@react-native-google-signin/google-signin",
+  defaultChecked: false,
+  dependencies: {
+    "@react-native-google-signin/google-signin": "^13.1.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/auth/google.ts",
+      content: lines(
+        "import {",
+        "  GoogleSignin,",
+        "  statusCodes,",
+        "  type User,",
+        '} from "@react-native-google-signin/google-signin";',
+        "",
+        "export interface GoogleAuthConfig {",
+        "  iosClientId?: string;",
+        "  webClientId?: string;",
+        "  offlineAccess?: boolean;",
+        "  forceCodeForRefreshToken?: boolean;",
+        "}",
+        "",
+        "export function setupGoogleAuth(config: GoogleAuthConfig): void {",
+        "  GoogleSignin.configure({",
+        "    iosClientId: config.iosClientId,",
+        "    webClientId: config.webClientId,",
+        "    offlineAccess: config.offlineAccess ?? false,",
+        "    forceCodeForRefreshToken: config.forceCodeForRefreshToken ?? true,",
+        "  });",
+        "}",
+        "",
+        "export async function signInWithGoogle(): Promise<{",
+        "  user: User | null;",
+        "  idToken: string | null;",
+        "  error: string | null;",
+        "}> {",
+        "  try {",
+        "    await GoogleSignin.hasPlayServices({",
+        "      showPlayServicesUpdateDialog: true,",
+        "    });",
+        "",
+        "    const userInfo = await GoogleSignin.signIn();",
+        "    const idToken = userInfo.data?.idToken ?? null;",
+        "",
+        "    return {",
+        "      user: userInfo.data ?? null,",
+        "      idToken,",
+        "      error: null,",
+        "    };",
+        "  } catch (error: any) {",
+        '    let errorMessage = "Google \u767B\u5F55\u5931\u8D25";',
+        "",
+        "    if (error.code === statusCodes.SIGN_IN_CANCELLED) {",
+        '      errorMessage = "\u7528\u6237\u53D6\u6D88\u4E86\u767B\u5F55";',
+        "    } else if (error.code === statusCodes.IN_PROGRESS) {",
+        '      errorMessage = "\u767B\u5F55\u6B63\u5728\u8FDB\u884C\u4E2D";',
+        "    } else if (error.code === statusCodes.PLAY_SERVICES_NOT_AVAILABLE) {",
+        '      errorMessage = "\u8BBE\u5907\u4E0D\u652F\u6301 Google Play \u670D\u52A1";',
+        "    }",
+        "",
+        '    console.error("[GoogleAuth] Error:", errorMessage, error);',
+        "    return { user: null, idToken: null, error: errorMessage };",
+        "  }",
+        "}",
+        "",
+        "export async function signOutGoogle(): Promise<void> {",
+        "  try {",
+        "    await GoogleSignin.signOut();",
+        "  } catch (error) {",
+        '    console.error("[GoogleAuth] Sign out error:", error);',
+        "  }",
+        "}",
+        "",
+        "export async function getCurrentGoogleUser(): Promise<User | null> {",
+        "  try {",
+        "    const user = await GoogleSignin.getCurrentUser();",
+        "    return user;",
+        "  } catch {",
+        "    return null;",
+        "  }",
+        "}",
+        "",
+        "export async function isGoogleSignedIn(): Promise<boolean> {",
+        "  try {",
+        "    return GoogleSignin.hasPreviousSignIn();",
+        "  } catch {",
+        "    return false;",
+        "  }",
+        "}"
+      )
+    }
+  ]
+};
+var auth_google_default = authGoogleModule;
+
+// src/modules/auth-facebook.ts
+var authFacebookModule = {
+  id: "auth-facebook",
+  name: "Facebook \u767B\u5F55",
+  description: "expo-facebook",
+  defaultChecked: false,
+  dependencies: {
+    "expo-facebook": "~13.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/auth/facebook.ts",
+      content: lines(
+        'import * as Facebook from "expo-facebook";',
+        "",
+        "export interface FacebookAuthConfig {",
+        "  appId: string;",
+        "  appName: string;",
+        "}",
+        "",
+        "export async function setupFacebookAuth(config: FacebookAuthConfig): Promise<void> {",
+        "  await Facebook.initializeAsync({",
+        "    appId: config.appId,",
+        "    appName: config.appName,",
+        "  });",
+        "}",
+        "",
+        "export async function signInWithFacebook(): Promise<{",
+        "  token: string | null;",
+        "  userId: string | null;",
+        "  userName: string | null;",
+        "  error: string | null;",
+        "}> {",
+        "  try {",
+        "    const result = await Facebook.logInWithReadPermissionsAsync({",
+        '      permissions: ["public_profile", "email"],',
+        "    });",
+        "",
+        '    if (result.type === "success") {',
+        "      const response = await fetch(",
+        "        `https://graph.facebook.com/me?access_token=${result.token}&fields=id,name,email`",
+        "      );",
+        "      const userData = await response.json();",
+        "",
+        "      return {",
+        "        token: result.token,",
+        "        userId: userData.id,",
+        "        userName: userData.name,",
+        "        error: null,",
+        "      };",
+        "    } else {",
+        "      return {",
+        "        token: null,",
+        "        userId: null,",
+        "        userName: null,",
+        '        error: "\u7528\u6237\u53D6\u6D88\u4E86 Facebook \u767B\u5F55",',
+        "      };",
+        "    }",
+        "  } catch (error) {",
+        '    console.error("[FacebookAuth] Error:", error);',
+        "    return {",
+        "      token: null,",
+        "      userId: null,",
+        "      userName: null,",
+        '      error: "Facebook \u767B\u5F55\u5931\u8D25",',
+        "    };",
+        "  }",
+        "}",
+        "",
+        "export async function signOutFacebook(): Promise<void> {",
+        "  try {",
+        "    await Facebook.logOutAsync();",
+        "  } catch (error) {",
+        '    console.error("[FacebookAuth] Sign out error:", error);',
+        "  }",
+        "}"
+      )
+    }
+  ],
+  appConfig: {
+    plugins: [
+      [
+        "expo-facebook",
+        {
+          appId: "YOUR_FACEBOOK_APP_ID"
+        }
+      ]
+    ]
+  }
+};
+var auth_facebook_default = authFacebookModule;
+
+// src/modules/auth-apple.ts
+var authAppleModule = {
+  id: "auth-apple",
+  name: "Apple \u767B\u5F55",
+  description: "expo-apple-authentication",
+  defaultChecked: false,
+  dependencies: {
+    "expo-apple-authentication": "~8.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/auth/apple.ts",
+      content: lines(
+        'import * as AppleAuthentication from "expo-apple-authentication";',
+        'import { Platform } from "react-native";',
+        "",
+        "export interface AppleAuthResult {",
+        "  user: string;",
+        "  email: string | null;",
+        "  fullName: AppleAuthentication.AppleAuthenticationFullName | null;",
+        "  identityToken: string | null;",
+        "  authorizationCode: string | null;",
+        "  error: string | null;",
+        "}",
+        "",
+        "export async function isAppleAuthAvailable(): Promise<boolean> {",
+        '  if (Platform.OS !== "ios") return false;',
+        "  return AppleAuthentication.isAvailableAsync();",
+        "}",
+        "",
+        "export async function signInWithApple(): Promise<AppleAuthResult> {",
+        "  try {",
+        "    const credential = await AppleAuthentication.signInAsync({",
+        "      requestedScopes: [",
+        "        AppleAuthentication.AppleAuthenticationScope.FULL_NAME,",
+        "        AppleAuthentication.AppleAuthenticationScope.EMAIL,",
+        "      ],",
+        "    });",
+        "",
+        "    return {",
+        "      user: credential.user,",
+        "      email: credential.email ?? null,",
+        "      fullName: credential.fullName ?? null,",
+        "      identityToken: credential.identityToken ?? null,",
+        "      authorizationCode: credential.authorizationCode ?? null,",
+        "      error: null,",
+        "    };",
+        "  } catch (error: any) {",
+        '    if (error.code === "ERR_CANCELED") {',
+        "      return {",
+        '        user: "",',
+        "        email: null,",
+        "        fullName: null,",
+        "        identityToken: null,",
+        "        authorizationCode: null,",
+        '        error: "\u7528\u6237\u53D6\u6D88\u4E86 Apple \u767B\u5F55",',
+        "      };",
+        "    }",
+        "",
+        '    console.error("[AppleAuth] Error:", error);',
+        "    return {",
+        '      user: "",',
+        "      email: null,",
+        "      fullName: null,",
+        "      identityToken: null,",
+        "      authorizationCode: null,",
+        '      error: "Apple \u767B\u5F55\u5931\u8D25",',
+        "    };",
+        "  }",
+        "}",
+        "",
+        "export async function getAppleCredentialState(",
+        "  userId: string",
+        "): Promise<AppleAuthentication.AppleAuthenticationCredentialState> {",
+        "  return AppleAuthentication.getCredentialStateAsync(userId);",
+        "}",
+        "",
+        "export async function signOutApple(userId: string): Promise<boolean> {",
+        "  try {",
+        "    const state = await getAppleCredentialState(userId);",
+        "    return state === AppleAuthentication.AppleAuthenticationCredentialState.REVOKED;",
+        "  } catch {",
+        "    return false;",
+        "  }",
+        "}"
+      )
+    }
+  ],
+  appConfig: {
+    plugins: ["expo-apple-authentication"]
+  }
+};
+var auth_apple_default = authAppleModule;
+
+// src/modules/webview.ts
+var webviewModule = {
+  id: "webview",
+  name: "WebView \u5BB9\u5668",
+  description: "react-native-webview + JS Bridge",
+  defaultChecked: false,
+  dependencies: {
+    "react-native-webview": "^13.12.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/webview/WebViewContainer.tsx",
+      content: lines(
+        'import React, { useCallback, useRef } from "react";',
+        'import { View, StyleSheet, ActivityIndicator } from "react-native";',
+        "import WebView, {",
+        "  type WebViewMessageEvent,",
+        "  type WebViewProps,",
+        '} from "react-native-webview";',
+        'import { bridge, type BridgeMessage } from "./bridge";',
+        "",
+        'interface WebViewContainerProps extends Omit<WebViewProps, "source"> {',
+        "  uri: string;",
+        "  showLoading?: boolean;",
+        "  onBridgeMessage?: (message: BridgeMessage) => void;",
+        "}",
+        "",
+        "export function WebViewContainer({",
+        "  uri,",
+        "  showLoading = true,",
+        "  onBridgeMessage,",
+        "  style,",
+        "  ...rest",
+        "}: WebViewContainerProps) {",
+        "  const webViewRef = useRef<WebView>(null);",
+        "",
+        "  const handleMessage = useCallback(",
+        "    (event: WebViewMessageEvent) => {",
+        "      try {",
+        "        const data = JSON.parse(event.nativeEvent.data) as BridgeMessage;",
+        "        const processed = bridge.receive(data);",
+        "        if (onBridgeMessage) {",
+        "          onBridgeMessage(processed);",
+        "        }",
+        "      } catch (error) {",
+        '        console.warn("[WebView] Failed to parse message:", error);',
+        "      }",
+        "    },",
+        "    [onBridgeMessage]",
+        "  );",
+        "",
+        "  const sendToWebView = useCallback(",
+        "    (message: BridgeMessage) => {",
+        "      const script = bridge.buildSendScript(message);",
+        "      webViewRef.current?.injectJavaScript(script);",
+        "    },",
+        "    []",
+        "  );",
+        "",
+        "  const injectedJavaScript = [",
+        '    "(function() {",',
+        '    "  window.ReactNativeWebView = window.ReactNativeWebView || {};",',
+        '    "  window.NativeBridge = {",',
+        '    "    send: function(type, payload) {",',
+        '    "      window.ReactNativeWebView.postMessage(JSON.stringify({ type: type, payload: payload }));",',
+        '    "    }",,',
+        '    "  };,',
+        '    "})();,',
+        '    "true;,',
+        '  ].join("\\\\n");',
+        "",
+        "  return (",
+        "    <View style={styles.container}>",
+        "      <WebView",
+        "        ref={webViewRef}",
+        "        source={{ uri }}",
+        "        style={[styles.webview, style]}",
+        '        originWhitelist={["*"]}',
+        "        javaScriptEnabled",
+        "        domStorageEnabled",
+        "        injectedJavaScript={injectedJavaScript}",
+        "        onMessage={handleMessage}",
+        "        startInLoadingState={showLoading}",
+        "        renderLoading={() =>",
+        "          showLoading ? (",
+        "            <View style={styles.loadingContainer}>",
+        '              <ActivityIndicator size="large" color="#007AFF" />',
+        "            </View>",
+        "          ) : null",
+        "        }",
+        "        {...rest}",
+        "      />",
+        "    </View>",
+        "  );",
+        "}",
+        "",
+        "const styles = StyleSheet.create({",
+        "  container: {",
+        "    flex: 1,",
+        "  },",
+        "  webview: {",
+        "    flex: 1,",
+        "  },",
+        "  loadingContainer: {",
+        '    position: "absolute",',
+        "    top: 0,",
+        "    left: 0,",
+        "    right: 0,",
+        "    bottom: 0,",
+        '    justifyContent: "center",',
+        '    alignItems: "center",',
+        '    backgroundColor: "rgba(255, 255, 255, 0.8)",',
+        "  },",
+        "});",
+        "",
+        "export default WebViewContainer;"
+      )
+    },
+    {
+      path: "src/modules/webview/bridge.ts",
+      content: lines(
+        "export interface BridgeMessage {",
+        "  type: string;",
+        "  payload: Record<string, unknown>;",
+        "}",
+        "",
+        "export const BridgeMessageType = {",
+        '  NAVIGATE: "NAVIGATE",',
+        '  SHARE: "SHARE",',
+        '  PAYMENT: "PAYMENT",',
+        '  AUTH: "AUTH",',
+        '  TOAST: "TOAST",',
+        '  CLOSE: "CLOSE",',
+        '  CUSTOM: "CUSTOM",',
+        "} as const;",
+        "",
+        "export type BridgeMessageTypeValue =",
+        "  (typeof BridgeMessageType)[keyof typeof BridgeMessageType];",
+        "",
+        "export const bridge = {",
+        "  receive(message: BridgeMessage): BridgeMessage {",
+        "    if (!message.type) {",
+        `      throw new Error("Bridge message must have a 'type' field");`,
+        "    }",
+        "    return {",
+        "      type: message.type,",
+        "      payload: message.payload || {},",
+        "    };",
+        "  },",
+        "",
+        "  buildSendScript(message: BridgeMessage): string {",
+        "    const payload = JSON.stringify(message.payload);",
+        "    return [",
+        '      "(function() {",',
+        `      "  if (typeof window.onNativeMessage === 'function') {",`,
+        `      "    window.onNativeMessage('" + message.type + "', " + payload + ");",`,
+        '      "  }",',
+        '      "})();",',
+        '      "true;",',
+        '    ].join("\\\\n");',
+        "  },",
+        "",
+        "  createMessage(",
+        "    type: BridgeMessageTypeValue | string,",
+        "    payload: Record<string, unknown> = {}",
+        "  ): BridgeMessage {",
+        "    return { type, payload };",
+        "  },",
+        "};"
+      )
+    }
+  ]
+};
+var webview_default = webviewModule;
+
+// src/modules/i18n.ts
+var i18nModule = {
+  id: "i18n",
+  name: "\u591A\u8BED\u8A00",
+  description: "i18next + react-i18next",
+  defaultChecked: false,
+  dependencies: {
+    i18next: "^24.2.0",
+    "react-i18next": "^15.2.0",
+    "expo-localization": "~16.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/i18n/index.ts",
+      content: lines(
+        'import i18n from "i18next";',
+        'import { initReactI18next } from "react-i18next";',
+        'import { getLocales } from "expo-localization";',
+        'import en from "./locales/en.json";',
+        'import zh from "./locales/zh.json";',
+        "",
+        "const resources = {",
+        "  en: { translation: en },",
+        "  zh: { translation: zh },",
+        "};",
+        "",
+        "function getDeviceLanguage(): string {",
+        "  const locales = getLocales();",
+        '  const deviceLang = locales[0]?.languageCode ?? "en";',
+        '  return deviceLang in resources ? deviceLang : "en";',
+        "}",
+        "",
+        "i18n.use(initReactI18next).init({",
+        "  resources,",
+        "  lng: getDeviceLanguage(),",
+        '  fallbackLng: "en",',
+        "  interpolation: {",
+        "    escapeValue: false,",
+        "  },",
+        '  compatibilityJSON: "v4",',
+        "});",
+        "",
+        "export default i18n;",
+        "",
+        'export { useTranslation } from "react-i18next";'
+      )
+    },
+    {
+      path: "src/modules/i18n/locales/en.json",
+      content: [
+        "{",
+        '  "common": {',
+        '    "ok": "OK",',
+        '    "cancel": "Cancel",',
+        '    "confirm": "Confirm",',
+        '    "save": "Save",',
+        '    "delete": "Delete",',
+        '    "edit": "Edit",',
+        '    "loading": "Loading...",',
+        '    "error": "Something went wrong",',
+        '    "retry": "Retry",',
+        '    "search": "Search"',
+        "  },",
+        '  "auth": {',
+        '    "login": "Sign In",',
+        '    "register": "Sign Up",',
+        '    "logout": "Sign Out",',
+        '    "email": "Email",',
+        '    "password": "Password",',
+        '    "forgotPassword": "Forgot Password?"',
+        "  },",
+        '  "home": {',
+        '    "title": "Home",',
+        '    "welcome": "Welcome"',
+        "  },",
+        '  "settings": {',
+        '    "title": "Settings",',
+        '    "language": "Language",',
+        '    "theme": "Theme",',
+        '    "about": "About"',
+        "  },",
+        '  "errors": {',
+        '    "network": "Network error. Please check your connection.",',
+        '    "unauthorized": "Session expired. Please sign in again.",',
+        `    "forbidden": "You don't have permission to do this.",`,
+        '    "notFound": "The requested resource was not found.",',
+        '    "server": "Server error. Please try again later."',
+        "  }",
+        "}"
+      ].join("\n")
+    },
+    {
+      path: "src/modules/i18n/locales/zh.json",
+      content: [
+        "{",
+        '  "common": {',
+        '    "ok": "\u786E\u5B9A",',
+        '    "cancel": "\u53D6\u6D88",',
+        '    "confirm": "\u786E\u8BA4",',
+        '    "save": "\u4FDD\u5B58",',
+        '    "delete": "\u5220\u9664",',
+        '    "edit": "\u7F16\u8F91",',
+        '    "loading": "\u52A0\u8F7D\u4E2D...",',
+        '    "error": "\u51FA\u4E86\u70B9\u95EE\u9898",',
+        '    "retry": "\u91CD\u8BD5",',
+        '    "search": "\u641C\u7D22"',
+        "  },",
+        '  "auth": {',
+        '    "login": "\u767B\u5F55",',
+        '    "register": "\u6CE8\u518C",',
+        '    "logout": "\u9000\u51FA\u767B\u5F55",',
+        '    "email": "\u90AE\u7BB1",',
+        '    "password": "\u5BC6\u7801",',
+        '    "forgotPassword": "\u5FD8\u8BB0\u5BC6\u7801\uFF1F"',
+        "  },",
+        '  "home": {',
+        '    "title": "\u9996\u9875",',
+        '    "welcome": "\u6B22\u8FCE"',
+        "  },",
+        '  "settings": {',
+        '    "title": "\u8BBE\u7F6E",',
+        '    "language": "\u8BED\u8A00",',
+        '    "theme": "\u4E3B\u9898",',
+        '    "about": "\u5173\u4E8E"',
+        "  },",
+        '  "errors": {',
+        '    "network": "\u7F51\u7EDC\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002",',
+        '    "unauthorized": "\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u3002",',
+        '    "forbidden": "\u60A8\u6CA1\u6709\u6743\u9650\u6267\u884C\u6B64\u64CD\u4F5C\u3002",',
+        '    "notFound": "\u672A\u627E\u5230\u8BF7\u6C42\u7684\u8D44\u6E90\u3002",',
+        '    "server": "\u670D\u52A1\u5668\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002"',
+        "  }",
+        "}"
+      ].join("\n")
+    }
+  ]
+};
+var i18n_default = i18nModule;
+
+// src/modules/animation.ts
+var animationModule = {
+  id: "animation",
+  name: "\u52A8\u753B/\u624B\u52BF",
+  description: "Reanimated 3 + Gesture Handler",
+  defaultChecked: false,
+  dependencies: {
+    "react-native-reanimated": "~3.17.0",
+    "react-native-gesture-handler": "~2.22.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/animation/index.ts",
+      content: lines(
+        'export { FadeIn, FadeOut, SlideIn, SlideOut, ScaleIn, ScaleOut } from "./transitions";'
+      )
+    },
+    {
+      path: "src/modules/animation/transitions.ts",
+      content: lines(
+        "import Animated, {",
+        "  FadeIn as ReanimatedFadeIn,",
+        "  FadeOut as ReanimatedFadeOut,",
+        "  SlideInUp as ReanimatedSlideInUp,",
+        "  SlideInDown as ReanimatedSlideInDown,",
+        "  SlideInLeft as ReanimatedSlideInLeft,",
+        "  SlideInRight as ReanimatedSlideInRight,",
+        "  SlideOutUp as ReanimatedSlideOutUp,",
+        "  SlideOutDown as ReanimatedSlideOutDown,",
+        "  SlideOutLeft as ReanimatedSlideOutLeft,",
+        "  SlideOutRight as ReanimatedSlideOutRight,",
+        "  ZoomIn as ReanimatedZoomIn,",
+        "  ZoomOut as ReanimatedZoomOut,",
+        "  type EntryExitAnimationFunction,",
+        '} from "react-native-reanimated";',
+        "",
+        "export const FadeIn = ReanimatedFadeIn.duration(300);",
+        "export const FadeOut = ReanimatedFadeOut.duration(300);",
+        "export const SlideIn = ReanimatedSlideInDown.duration(300).springify();",
+        "export const SlideInTop = ReanimatedSlideInUp.duration(300).springify();",
+        "export const SlideInLeft = ReanimatedSlideInLeft.duration(300).springify();",
+        "export const SlideInRight = ReanimatedSlideInRight.duration(300).springify();",
+        "export const SlideOut = ReanimatedSlideOutDown.duration(300).springify();",
+        "export const SlideOutTop = ReanimatedSlideOutUp.duration(300).springify();",
+        "export const SlideOutLeft = ReanimatedSlideOutLeft.duration(300).springify();",
+        "export const SlideOutRight = ReanimatedSlideOutRight.duration(300).springify();",
+        "export const ScaleIn = ReanimatedZoomIn.duration(200).springify();",
+        "export const ScaleOut = ReanimatedZoomOut.duration(200).springify();",
+        "",
+        "export function staggerFadeIn(",
+        "  index: number,",
+        "  baseDelay: number = 50",
+        "): EntryExitAnimationFunction {",
+        "  return ReanimatedFadeIn.duration(300).delay(index * baseDelay);",
+        "}",
+        "",
+        "export function staggerSlideIn(",
+        "  index: number,",
+        "  baseDelay: number = 80",
+        "): EntryExitAnimationFunction {",
+        "  return ReanimatedSlideInDown.duration(400).springify().delay(index * baseDelay);",
+        "}",
+        "",
+        "export { Animated };"
+      )
+    }
+  ],
+  babelPlugins: ["react-native-reanimated/plugin"]
+};
+var animation_default = animationModule;
+
+// src/modules/ota.ts
+var otaModule = {
+  id: "ota",
+  name: "OTA \u66F4\u65B0",
+  description: "expo-updates",
+  defaultChecked: false,
+  dependencies: {
+    "expo-updates": "~7.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/ota/useOTAUpdate.ts",
+      content: lines(
+        'import { useCallback, useEffect, useState } from "react";',
+        'import * as Updates from "expo-updates";',
+        'import { Alert, Platform } from "react-native";',
+        "",
+        "interface OTAUpdateState {",
+        "  isUpdateAvailable: boolean;",
+        "  isDownloading: boolean;",
+        "  progress: number;",
+        "  error: string | null;",
+        "}",
+        "",
+        "export function useOTAUpdate() {",
+        "  const [state, setState] = useState<OTAUpdateState>({",
+        "    isUpdateAvailable: false,",
+        "    isDownloading: false,",
+        "    progress: 0,",
+        "    error: null,",
+        "  });",
+        "",
+        "  const checkForUpdate = useCallback(async () => {",
+        '    if (__DEV__ || Platform.OS === "web") {',
+        "      return;",
+        "    }",
+        "",
+        "    try {",
+        "      const update = await Updates.checkForUpdateAsync();",
+        "      setState((prev) => ({",
+        "        ...prev,",
+        "        isUpdateAvailable: update.isAvailable,",
+        "        error: null,",
+        "      }));",
+        "      return update.isAvailable;",
+        "    } catch (error) {",
+        '      const message = error instanceof Error ? error.message : "\u68C0\u67E5\u66F4\u65B0\u5931\u8D25";',
+        "      setState((prev) => ({ ...prev, error: message }));",
+        "      return false;",
+        "    }",
+        "  }, []);",
+        "",
+        "  const downloadUpdate = useCallback(async () => {",
+        '    if (__DEV__ || Platform.OS === "web") return null;',
+        "",
+        "    try {",
+        "      setState((prev) => ({ ...prev, isDownloading: true, progress: 0 }));",
+        "      const result = await Updates.fetchUpdateAsync();",
+        "      setState((prev) => ({",
+        "        ...prev,",
+        "        isDownloading: false,",
+        "        isUpdateAvailable: false,",
+        "        progress: 1,",
+        "      }));",
+        "      return result;",
+        "    } catch (error) {",
+        '      const message = error instanceof Error ? error.message : "\u4E0B\u8F7D\u66F4\u65B0\u5931\u8D25";',
+        "      setState((prev) => ({",
+        "        ...prev,",
+        "        isDownloading: false,",
+        "        error: message,",
+        "      }));",
+        "      return null;",
+        "    }",
+        "  }, []);",
+        "",
+        "  const downloadAndRestart = useCallback(async () => {",
+        "    const result = await downloadUpdate();",
+        "    if (result?.isNew) {",
+        "      Alert.alert(",
+        '        "\u66F4\u65B0\u5DF2\u4E0B\u8F7D",',
+        '        "\u5E94\u7528\u9700\u8981\u91CD\u542F\u4EE5\u5B8C\u6210\u66F4\u65B0\uFF0C\u662F\u5426\u7ACB\u5373\u91CD\u542F\uFF1F",',
+        "        [",
+        '          { text: "\u7A0D\u540E", style: "cancel" },',
+        "          {",
+        '            text: "\u7ACB\u5373\u91CD\u542F",',
+        '            style: "default",',
+        "            onPress: async () => {",
+        "              await Updates.reloadAsync();",
+        "            },",
+        "          },",
+        "        ]",
+        "      );",
+        "    }",
+        "  }, [downloadUpdate]);",
+        "",
+        "  const restartApp = useCallback(async () => {",
+        "    await Updates.reloadAsync();",
+        "  }, []);",
+        "",
+        "  useEffect(() => {",
+        "    checkForUpdate();",
+        "  }, [checkForUpdate]);",
+        "",
+        "  return {",
+        "    ...state,",
+        "    checkForUpdate,",
+        "    downloadUpdate,",
+        "    downloadAndRestart,",
+        "    restartApp,",
+        "  };",
+        "}"
+      )
+    }
+  ]
+};
+var ota_default = otaModule;
+
+// src/modules/notification.ts
+var notificationModule = {
+  id: "notification",
+  name: "\u5E94\u7528\u5185\u901A\u77E5",
+  description: "expo-notifications + \u81EA\u5B9A\u4E49\u7EC4\u4EF6",
+  defaultChecked: false,
+  dependencies: {
+    "expo-notifications": "~0.30.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/notification/index.ts",
+      content: lines(
+        'export { InAppNotification, useInAppNotification } from "./InAppNotification";',
+        'export { setupNotificationHandlers } from "./InAppNotification";'
+      )
+    },
+    {
+      path: "src/modules/notification/InAppNotification.tsx",
+      content: lines(
+        "import React, {",
+        "  createContext,",
+        "  useCallback,",
+        "  useContext,",
+        "  useEffect,",
+        "  useMemo,",
+        "  useRef,",
+        "  useState,",
+        '} from "react";',
+        'import { Animated, StyleSheet, Text, TouchableOpacity, View } from "react-native";',
+        'import * as Notifications from "expo-notifications";',
+        'import type { Subscription } from "expo-notifications";',
+        "",
+        "export function setupNotificationHandlers(): void {",
+        "  Notifications.setNotificationHandler({",
+        "    handleNotification: async () => ({",
+        "      shouldShowAlert: true,",
+        "      shouldPlaySound: true,",
+        "      shouldSetBadge: true,",
+        "    }),",
+        "  });",
+        "}",
+        "",
+        "interface NotificationData {",
+        "  id: string;",
+        "  title: string;",
+        "  message: string;",
+        '  type: "info" | "success" | "warning" | "error";',
+        "  duration?: number;",
+        "}",
+        "",
+        "interface InAppNotificationContextType {",
+        '  showNotification: (data: Omit<NotificationData, "id">) => void;',
+        "}",
+        "",
+        "const InAppNotificationContext = createContext<InAppNotificationContextType>({",
+        "  showNotification: () => {},",
+        "});",
+        "",
+        "export function useInAppNotification(): InAppNotificationContextType {",
+        "  return useContext(InAppNotificationContext);",
+        "}",
+        "",
+        "let notificationIdCounter = 0;",
+        "",
+        "export function InAppNotificationProvider({",
+        "  children,",
+        "}: {",
+        "  children: React.ReactNode;",
+        "}) {",
+        "  const [notifications, setNotifications] = useState<NotificationData[]>([]);",
+        "  const timersRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());",
+        "",
+        "  const removeNotification = useCallback((id: string) => {",
+        "    setNotifications((prev) => prev.filter((n) => n.id !== id));",
+        "    const timer = timersRef.current.get(id);",
+        "    if (timer) {",
+        "      clearTimeout(timer);",
+        "      timersRef.current.delete(id);",
+        "    }",
+        "  }, []);",
+        "",
+        "  const showNotification = useCallback(",
+        '    (data: Omit<NotificationData, "id">) => {',
+        "      const id = `notification-${++notificationIdCounter}`;",
+        "      const notification: NotificationData = { ...data, id };",
+        "      setNotifications((prev) => [...prev, notification]);",
+        "",
+        "      const duration = data.duration ?? 3000;",
+        "      const timer = setTimeout(() => {",
+        "        removeNotification(id);",
+        "      }, duration);",
+        "      timersRef.current.set(id, timer);",
+        "    },",
+        "    [removeNotification]",
+        "  );",
+        "",
+        "  const contextValue = useMemo(",
+        "    () => ({ showNotification }),",
+        "    [showNotification]",
+        "  );",
+        "",
+        "  return (",
+        "    <InAppNotificationContext.Provider value={contextValue}>",
+        "      {children}",
+        '      <View style={styles.container} pointerEvents="box-none">',
+        "        {notifications.map((notification) => (",
+        "          <NotificationCard",
+        "            key={notification.id}",
+        "            notification={notification}",
+        "            onDismiss={() => removeNotification(notification.id)}",
+        "          />",
+        "        ))}",
+        "      </View>",
+        "    </InAppNotificationContext.Provider>",
+        "  );",
+        "}",
+        "",
+        "interface NotificationCardProps {",
+        "  notification: NotificationData;",
+        "  onDismiss: () => void;",
+        "}",
+        "",
+        'const typeColors: Record<NotificationData["type"], string> = {',
+        '  info: "#007AFF",',
+        '  success: "#34C759",',
+        '  warning: "#FF9500",',
+        '  error: "#FF3B30",',
+        "};",
+        "",
+        "function NotificationCard({ notification, onDismiss }: NotificationCardProps) {",
+        "  const opacity = useRef(new Animated.Value(0)).current;",
+        "",
+        "  useEffect(() => {",
+        "    Animated.timing(opacity, {",
+        "      toValue: 1,",
+        "      duration: 300,",
+        "      useNativeDriver: true,",
+        "    }).start();",
+        "  }, [opacity]);",
+        "",
+        "  const handleDismiss = useCallback(() => {",
+        "    Animated.timing(opacity, {",
+        "      toValue: 0,",
+        "      duration: 200,",
+        "      useNativeDriver: true,",
+        "    }).start(() => onDismiss());",
+        "  }, [opacity, onDismiss]);",
+        "",
+        "  return (",
+        "    <Animated.View style={[styles.card, { opacity }]}>",
+        "      <View",
+        "        style={[styles.accent, { backgroundColor: typeColors[notification.type] }]}",
+        "      />",
+        "      <View style={styles.content}>",
+        "        <Text style={styles.title}>{notification.title}</Text>",
+        "        <Text style={styles.message}>{notification.message}</Text>",
+        "      </View>",
+        "      <TouchableOpacity onPress={handleDismiss} style={styles.closeButton}>",
+        "        <Text style={styles.closeButtonText}>X</Text>",
+        "      </TouchableOpacity>",
+        "    </Animated.View>",
+        "  );",
+        "}",
+        "",
+        "const styles = StyleSheet.create({",
+        "  container: {",
+        '    position: "absolute",',
+        "    top: 60,",
+        "    left: 16,",
+        "    right: 16,",
+        "    zIndex: 9999,",
+        "    gap: 8,",
+        "  },",
+        "  card: {",
+        '    flexDirection: "row",',
+        '    alignItems: "center",',
+        '    backgroundColor: "#fff",',
+        "    borderRadius: 12,",
+        '    shadowColor: "#000",',
+        "    shadowOffset: { width: 0, height: 2 },",
+        "    shadowOpacity: 0.15,",
+        "    shadowRadius: 8,",
+        "    elevation: 5,",
+        '    overflow: "hidden",',
+        "  },",
+        "  accent: {",
+        "    width: 4,",
+        '    height: "100%",',
+        "    minHeight: 48,",
+        "  },",
+        "  content: {",
+        "    flex: 1,",
+        "    paddingVertical: 12,",
+        "    paddingHorizontal: 12,",
+        "  },",
+        "  title: {",
+        "    fontSize: 14,",
+        '    fontWeight: "600",',
+        '    color: "#1a1a1a",',
+        "  },",
+        "  message: {",
+        "    fontSize: 13,",
+        '    color: "#666",',
+        "    marginTop: 2,",
+        "  },",
+        "  closeButton: {",
+        "    padding: 12,",
+        "  },",
+        "  closeButtonText: {",
+        "    fontSize: 14,",
+        '    color: "#999",',
+        "  },",
+        "});",
+        "",
+        "export const InAppNotification = InAppNotificationProvider;"
+      )
+    }
+  ],
+  layoutProviders: ["<InAppNotification>"],
+  layoutImports: [
+    'import { InAppNotification } from "../modules/notification/InAppNotification";'
+  ]
+};
+var notification_default = notificationModule;
+
+// src/modules/permission.ts
+var permissionModule = {
+  id: "permission",
+  name: "\u7528\u6237\u6743\u9650\u7BA1\u7406",
+  description: "\u6743\u9650\u8BF7\u6C42/\u68C0\u67E5\u5C01\u88C5",
+  defaultChecked: false,
+  dependencies: {
+    "expo-image-picker": "~16.0.0",
+    "expo-camera": "~16.0.0",
+    "expo-location": "~18.0.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/modules/permission/index.ts",
+      content: lines(
+        'import * as ImagePicker from "expo-image-picker";',
+        'import * as Camera from "expo-camera";',
+        'import * as Location from "expo-location";',
+        'import { Alert, Platform } from "react-native";',
+        "",
+        'export type PermissionStatus = "granted" | "denied" | "undetermined";',
+        "",
+        "export interface PermissionResult {",
+        "  status: PermissionStatus;",
+        "  canAskAgain: boolean;",
+        "}",
+        "",
+        "export async function checkCameraPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } = await Camera.getCameraPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function requestCameraPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } = await Camera.requestCameraPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function checkPhotoLibraryPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } =",
+        "    await ImagePicker.getMediaLibraryPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function requestPhotoLibraryPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } =",
+        "    await ImagePicker.requestMediaLibraryPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function checkLocationPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } = await Location.getForegroundPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function requestLocationPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } =",
+        "    await Location.requestForegroundPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function requestBackgroundLocationPermission(): Promise<PermissionResult> {",
+        "  const { status, canAskAgain } =",
+        "    await Location.requestBackgroundPermissionsAsync();",
+        "  return { status: status as PermissionStatus, canAskAgain };",
+        "}",
+        "",
+        "export async function requestPermissionWithAlert(",
+        "  permissionName: string,",
+        "  requestFn: () => Promise<PermissionResult>,",
+        "  onGranted?: () => void,",
+        "  onDenied?: () => void",
+        "): Promise<PermissionResult> {",
+        "  const result = await requestFn();",
+        "",
+        '  if (result.status === "granted") {',
+        "    onGranted?.();",
+        "  } else {",
+        "    const message = result.canAskAgain",
+        "      ? `\u60A8\u9700\u8981\u6388\u4E88${permissionName}\u6743\u9650\u624D\u80FD\u4F7F\u7528\u6B64\u529F\u80FD`",
+        "      : `${permissionName}\u6743\u9650\u5DF2\u88AB\u62D2\u7EDD\uFF0C\u8BF7\u5728\u7CFB\u7EDF\u8BBE\u7F6E\u4E2D\u624B\u52A8\u5F00\u542F`;",
+        "",
+        '    Alert.alert("\u9700\u8981\u6743\u9650", message, [',
+        '      { text: "\u53D6\u6D88", style: "cancel", onPress: onDenied },',
+        "      ...(result.canAskAgain",
+        "        ? [",
+        "            {",
+        '              text: "\u518D\u6B21\u8BF7\u6C42",',
+        '              style: "default" as const,',
+        "              onPress: () => requestFn(),",
+        "            },",
+        "          ]",
+        "        : []),",
+        "    ]);",
+        "  }",
+        "",
+        "  return result;",
+        "}",
+        "",
+        "export async function pickImageWithPermission(): Promise<ImagePicker.ImagePickerResult | null> {",
+        "  const permission = await requestPhotoLibraryPermission();",
+        '  if (permission.status !== "granted") {',
+        '    Alert.alert("\u9700\u8981\u6743\u9650", "\u8BF7\u6388\u4E88\u76F8\u518C\u8BBF\u95EE\u6743\u9650");',
+        "    return null;",
+        "  }",
+        "",
+        "  const result = await ImagePicker.launchImageLibraryAsync({",
+        "    mediaTypes: ImagePicker.MediaTypeOptions.Images,",
+        "    allowsEditing: true,",
+        "    aspect: [1, 1],",
+        "    quality: 0.8,",
+        "  });",
+        "",
+        "  return result;",
+        "}",
+        "",
+        "export async function takePhotoWithPermission(): Promise<ImagePicker.ImagePickerResult | null> {",
+        "  const permission = await requestCameraPermission();",
+        '  if (permission.status !== "granted") {',
+        '    Alert.alert("\u9700\u8981\u6743\u9650", "\u8BF7\u6388\u4E88\u76F8\u673A\u8BBF\u95EE\u6743\u9650");',
+        "    return null;",
+        "  }",
+        "",
+        "  const result = await ImagePicker.launchCameraAsync({",
+        "    allowsEditing: true,",
+        "    aspect: [1, 1],",
+        "    quality: 0.8,",
+        "  });",
+        "",
+        "  return result;",
+        "}"
+      )
+    }
+  ],
+  appConfig: {
+    plugins: [
+      [
+        "expo-camera",
+        {
+          cameraPermission: "Allow $(PRODUCT_NAME) to access your camera"
+        }
+      ],
+      [
+        "expo-image-picker",
+        {
+          photosPermission: "Allow $(PRODUCT_NAME) to access your photos"
+        }
+      ],
+      [
+        "expo-location",
+        {
+          locationAlwaysAndWhenInUsePermission: "Allow $(PRODUCT_NAME) to use your location"
+        }
+      ]
+    ]
+  }
+};
+var permission_default = permissionModule;
+
+// src/modules/bottom-sheet.ts
+var bottomSheetModule = {
+  id: "bottom-sheet",
+  name: "Bottom Sheet",
+  description: "@gorhom/bottom-sheet",
+  defaultChecked: false,
+  dependencies: {
+    "@gorhom/bottom-sheet": "^5.1.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/components/AppBottomSheet.tsx",
+      content: lines(
+        'import React, { useCallback, useRef } from "react";',
+        'import { View, Text, StyleSheet } from "react-native";',
+        "import BottomSheet, {",
+        "  BottomSheetBackdrop,",
+        "  BottomSheetView,",
+        "  type BottomSheetBackdropProps,",
+        "  type BottomSheetProps,",
+        '} from "@gorhom/bottom-sheet";',
+        "",
+        'interface AppBottomSheetProps extends Omit<BottomSheetProps, "children"> {',
+        "  title?: string;",
+        "  children: React.ReactNode;",
+        "  onClose?: () => void;",
+        "}",
+        "",
+        "export const AppBottomSheet = React.forwardRef<BottomSheet, AppBottomSheetProps>(",
+        '  ({ title, children, onClose, snapPoints = ["50%"], ...rest }, ref) => {',
+        "    const localRef = useRef<BottomSheet>(null);",
+        "    const sheetRef = (ref as React.RefObject<BottomSheet>) || localRef;",
+        "",
+        "    const renderBackdrop = useCallback(",
+        "      (props: BottomSheetBackdropProps) => (",
+        "        <BottomSheetBackdrop",
+        "          {...props}",
+        "          disappearsOnIndex={-1}",
+        "          appearsOnIndex={0}",
+        '          pressBehavior="close"',
+        "        />",
+        "      ),",
+        "      []",
+        "    );",
+        "",
+        "    const handleSheetChange = useCallback(",
+        "      (index: number) => {",
+        "        if (index === -1 && onClose) {",
+        "          onClose();",
+        "        }",
+        "      },",
+        "      [onClose]",
+        "    );",
+        "",
+        "    return (",
+        "      <BottomSheet",
+        "        ref={sheetRef}",
+        "        index={-1}",
+        "        snapPoints={snapPoints}",
+        "        backdropComponent={renderBackdrop}",
+        "        onChange={handleSheetChange}",
+        "        enablePanDownToClose",
+        "        backgroundStyle={styles.background}",
+        "        handleIndicatorStyle={styles.handleIndicator}",
+        "        {...rest}",
+        "      >",
+        "        <BottomSheetView style={styles.content}>",
+        "          {title && <Text style={styles.title}>{title}</Text>}",
+        "          {children}",
+        "        </BottomSheetView>",
+        "      </BottomSheet>",
+        "    );",
+        "  }",
+        ");",
+        "",
+        'AppBottomSheet.displayName = "AppBottomSheet";',
+        "",
+        "const styles = StyleSheet.create({",
+        "  background: {",
+        "    borderRadius: 16,",
+        "  },",
+        "  handleIndicator: {",
+        '    backgroundColor: "#d1d5db",',
+        "    width: 40,",
+        "  },",
+        "  content: {",
+        "    paddingHorizontal: 16,",
+        "    paddingBottom: 24,",
+        "  },",
+        "  title: {",
+        "    fontSize: 18,",
+        '    fontWeight: "600",',
+        '    color: "#1a1a1a",',
+        "    marginBottom: 16,",
+        "  },",
+        "});",
+        "",
+        "export default AppBottomSheet;"
+      )
+    }
+  ],
+  layoutProviders: ["<BottomSheetModalProvider>"],
+  layoutImports: [
+    'import { BottomSheetModalProvider } from "@gorhom/bottom-sheet";'
+  ]
+};
+var bottom_sheet_default = bottomSheetModule;
+
+// src/modules/flashlist.ts
+var flashlistModule = {
+  id: "flashlist",
+  name: "FlashList",
+  description: "@shopify/flash-list",
+  defaultChecked: false,
+  dependencies: {
+    "@shopify/flash-list": "^1.7.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/components/AppFlashList.tsx",
+      content: lines(
+        'import React, { useCallback } from "react";',
+        'import { View, Text, StyleSheet, type ListRenderItemInfo } from "react-native";',
+        "import {",
+        "  FlashList,",
+        "  type FlashListProps,",
+        '} from "@shopify/flash-list";',
+        "",
+        "export interface ListItem {",
+        "  id: string;",
+        "  [key: string]: unknown;",
+        "}",
+        "",
+        "interface AppFlashListProps<T extends ListItem>",
+        '  extends Omit<FlashListProps<T>, "renderItem" | "estimatedItemSize"> {',
+        "  renderItem: (info: ListRenderItemInfo<T>) => React.ReactElement | null;",
+        "  estimatedItemSize?: number;",
+        "  ListEmptyComponent?: React.ReactElement;",
+        "  isLoading?: boolean;",
+        "  LoadingComponent?: React.ReactElement;",
+        "}",
+        "",
+        "export function AppFlashList<T extends ListItem>({",
+        "  data,",
+        "  renderItem,",
+        "  estimatedItemSize = 50,",
+        "  ListEmptyComponent,",
+        "  isLoading,",
+        "  LoadingComponent,",
+        "  ...rest",
+        "}: AppFlashListProps<T>) {",
+        "  const defaultEmptyComponent = React.useMemo(",
+        "    () => (",
+        "      <View style={styles.emptyContainer}>",
+        "        <Text style={styles.emptyText}>\u6682\u65E0\u6570\u636E</Text>",
+        "      </View>",
+        "    ),",
+        "    []",
+        "  );",
+        "",
+        "  const defaultLoadingComponent = React.useMemo(",
+        "    () => (",
+        "      <View style={styles.loadingContainer}>",
+        "        <Text style={styles.loadingText}>\u52A0\u8F7D\u4E2D...</Text>",
+        "      </View>",
+        "    ),",
+        "    []",
+        "  );",
+        "",
+        "  if (isLoading) {",
+        "    return LoadingComponent ?? defaultLoadingComponent;",
+        "  }",
+        "",
+        "  return (",
+        "    <FlashList",
+        "      data={data}",
+        "      renderItem={renderItem}",
+        "      estimatedItemSize={estimatedItemSize}",
+        "      ListEmptyComponent={ListEmptyComponent ?? defaultEmptyComponent}",
+        "      drawDistance={200}",
+        "      {...rest}",
+        "    />",
+        "  );",
+        "}",
+        "",
+        "const styles = StyleSheet.create({",
+        "  emptyContainer: {",
+        "    flex: 1,",
+        '    justifyContent: "center",',
+        '    alignItems: "center",',
+        "    paddingVertical: 40,",
+        "  },",
+        "  emptyText: {",
+        "    fontSize: 16,",
+        '    color: "#999",',
+        "  },",
+        "  loadingContainer: {",
+        "    flex: 1,",
+        '    justifyContent: "center",',
+        '    alignItems: "center",',
+        "    paddingVertical: 40,",
+        "  },",
+        "  loadingText: {",
+        "    fontSize: 16,",
+        '    color: "#999",',
+        "  },",
+        "});",
+        "",
+        "export default AppFlashList;"
+      )
+    }
+  ]
+};
+var flashlist_default = flashlistModule;
+
+// src/modules/ui-reusables.ts
+var uiReusablesModule = {
+  id: "ui-reusables",
+  name: "reactnative.reusables UI",
+  description: "\u9884\u7F6E UI \u7EC4\u4EF6",
+  defaultChecked: false,
+  dependencies: {
+    "reactnative.reusables": "^0.1.0",
+    "react-native-svg": "^15.8.0",
+    "@rn-primitives/slot": "^1.1.0",
+    "@rn-primitives/types": "^1.1.0"
+  },
+  devDependencies: {},
+  files: [
+    {
+      path: "src/components/ui/button.tsx",
+      content: lines(
+        'import React from "react";',
+        'import { Text, Pressable, type PressableProps, type StyleProp, type ViewStyle, type TextStyle } from "react-native";',
+        'import { Slot } from "@rn-primitives/slot";',
+        "",
+        'type ButtonVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";',
+        'type ButtonSize = "default" | "sm" | "lg" | "icon";',
+        "",
+        "interface ButtonProps extends PressableProps {",
+        "  variant?: ButtonVariant;",
+        "  size?: ButtonSize;",
+        "  asChild?: boolean;",
+        "  style?: StyleProp<ViewStyle>;",
+        "  textStyle?: StyleProp<TextStyle>;",
+        "  children: React.ReactNode;",
+        "}",
+        "",
+        "const variantStyles: Record<ButtonVariant, ViewStyle> = {",
+        '  default: { backgroundColor: "#0f172a" },',
+        '  destructive: { backgroundColor: "#ef4444" },',
+        '  outline: { backgroundColor: "transparent", borderWidth: 1, borderColor: "#d4d4d8" },',
+        '  secondary: { backgroundColor: "#f4f4f5" },',
+        '  ghost: { backgroundColor: "transparent" },',
+        '  link: { backgroundColor: "transparent" },',
+        "};",
+        "",
+        "const variantTextStyles: Record<ButtonVariant, TextStyle> = {",
+        '  default: { color: "#fafafa" },',
+        '  destructive: { color: "#fafafa" },',
+        '  outline: { color: "#18181b" },',
+        '  secondary: { color: "#18181b" },',
+        '  ghost: { color: "#18181b" },',
+        '  link: { color: "#2563eb", textDecorationLine: "underline" },',
+        "};",
+        "",
+        "const sizeStyles: Record<ButtonSize, ViewStyle> = {",
+        "  default: { height: 44, paddingHorizontal: 16 },",
+        "  sm: { height: 36, paddingHorizontal: 12 },",
+        "  lg: { height: 52, paddingHorizontal: 24 },",
+        "  icon: { height: 44, width: 44 },",
+        "};",
+        "",
+        "const sizeTextStyles: Record<ButtonSize, TextStyle> = {",
+        "  default: { fontSize: 16 },",
+        "  sm: { fontSize: 14 },",
+        "  lg: { fontSize: 18 },",
+        "  icon: { fontSize: 16 },",
+        "};",
+        "",
+        "export function Button({",
+        '  variant = "default",',
+        '  size = "default",',
+        "  asChild = false,",
+        "  style,",
+        "  textStyle,",
+        "  children,",
+        "  ...rest",
+        "}: ButtonProps) {",
+        "  const containerStyle: StyleProp<ViewStyle> = [",
+        "    {",
+        "      borderRadius: 8,",
+        '      flexDirection: "row",',
+        '      alignItems: "center",',
+        '      justifyContent: "center",',
+        "    },",
+        "    variantStyles[variant],",
+        "    sizeStyles[size],",
+        "    style,",
+        "  ];",
+        "",
+        "  const textStyling: StyleProp<TextStyle> = [",
+        "    {",
+        '      fontWeight: "600",',
+        '      textAlign: "center",',
+        "    },",
+        "    variantTextStyles[variant],",
+        "    sizeTextStyles[size],",
+        "    textStyle,",
+        "  ];",
+        "",
+        "  if (asChild && React.isValidElement(children)) {",
+        "    return (",
+        "      <Pressable style={containerStyle} {...rest}>",
+        "        <Slot>{children}</Slot>",
+        "      </Pressable>",
+        "    );",
+        "  }",
+        "",
+        "  return (",
+        "    <Pressable style={containerStyle} {...rest}>",
+        '      {typeof children === "string" ? (',
+        "        <Text style={textStyling}>{children}</Text>",
+        "      ) : (",
+        "        children",
+        "      )}",
+        "    </Pressable>",
+        "  );",
+        "}",
+        "",
+        "export default Button;"
+      )
+    },
+    {
+      path: "src/components/ui/input.tsx",
+      content: lines(
+        'import React, { forwardRef } from "react";',
+        "import {",
+        "  TextInput,",
+        "  type TextInputProps,",
+        "  type StyleProp,",
+        "  type ViewStyle,",
+        "  type TextStyle,",
+        "  View,",
+        "  Text,",
+        '} from "react-native";',
+        "",
+        "interface InputProps extends TextInputProps {",
+        "  label?: string;",
+        "  error?: string;",
+        "  containerStyle?: StyleProp<ViewStyle>;",
+        "  inputStyle?: StyleProp<TextStyle>;",
+        "}",
+        "",
+        "export const Input = forwardRef<TextInput, InputProps>(",
+        "  ({ label, error, containerStyle, inputStyle, ...rest }, ref) => {",
+        "    return (",
+        "      <View style={containerStyle}>",
+        "        {label && <Text style={styles.label}>{label}</Text>}",
+        "        <TextInput",
+        "          ref={ref}",
+        "          style={[",
+        "            styles.input,",
+        "            error && styles.inputError,",
+        "            inputStyle,",
+        "          ]}",
+        '          placeholderTextColor="#a1a1aa"',
+        "          {...rest}",
+        "        />",
+        "        {error && <Text style={styles.errorText}>{error}</Text>}",
+        "      </View>",
+        "    );",
+        "  }",
+        ");",
+        "",
+        'Input.displayName = "Input";',
+        "",
+        "const styles = {",
+        "  label: {",
+        "    fontSize: 14,",
+        '    fontWeight: "500",',
+        '    color: "#18181b",',
+        "    marginBottom: 6,",
+        "  } as TextStyle,",
+        "  input: {",
+        "    height: 44,",
+        "    borderWidth: 1,",
+        '    borderColor: "#d4d4d8",',
+        "    borderRadius: 8,",
+        "    paddingHorizontal: 12,",
+        "    fontSize: 16,",
+        '    color: "#18181b",',
+        '    backgroundColor: "#ffffff",',
+        "  } as TextStyle,",
+        "  inputError: {",
+        '    borderColor: "#ef4444",',
+        "  } as TextStyle,",
+        "  errorText: {",
+        "    fontSize: 12,",
+        '    color: "#ef4444",',
+        "    marginTop: 4,",
+        "  } as TextStyle,",
+        "};",
+        "",
+        "export default Input;"
+      )
+    },
+    {
+      path: "src/components/ui/card.tsx",
+      content: lines(
+        'import React from "react";',
+        'import { View, Text, type StyleProp, type ViewStyle, type TextStyle } from "react-native";',
+        "",
+        "interface CardProps {",
+        "  title?: string;",
+        "  description?: string;",
+        "  children: React.ReactNode;",
+        "  style?: StyleProp<ViewStyle>;",
+        "  titleStyle?: StyleProp<TextStyle>;",
+        "  descriptionStyle?: StyleProp<TextStyle>;",
+        '  padding?: "none" | "sm" | "md" | "lg";',
+        "}",
+        "",
+        'const paddingMap: Record<NonNullable<CardProps["padding"]>, number> = {',
+        "  none: 0,",
+        "  sm: 8,",
+        "  md: 16,",
+        "  lg: 24,",
+        "};",
+        "",
+        "export function Card({",
+        "  title,",
+        "  description,",
+        "  children,",
+        "  style,",
+        "  titleStyle,",
+        "  descriptionStyle,",
+        '  padding = "md",',
+        "}: CardProps) {",
+        "  return (",
+        "    <View",
+        "      style={[",
+        "        {",
+        '          backgroundColor: "#ffffff",',
+        "          borderRadius: 12,",
+        "          borderWidth: 1,",
+        '          borderColor: "#e4e4e7",',
+        "          padding: paddingMap[padding],",
+        "        },",
+        "        style,",
+        "      ]}",
+        "    >",
+        "      {title && (",
+        "        <Text style={[styles.title, titleStyle]}>{title}</Text>",
+        "      )}",
+        "      {description && (",
+        "        <Text style={[styles.description, descriptionStyle]}>",
+        "          {description}",
+        "        </Text>",
+        "      )}",
+        "      {children}",
+        "    </View>",
+        "  );",
+        "}",
+        "",
+        "const styles = {",
+        "  title: {",
+        "    fontSize: 18,",
+        '    fontWeight: "600",',
+        '    color: "#18181b",',
+        "    marginBottom: 4,",
+        "  } as TextStyle,",
+        "  description: {",
+        "    fontSize: 14,",
+        '    color: "#71717a",',
+        "    marginBottom: 12,",
+        "  } as TextStyle,",
+        "};",
+        "",
+        "export default Card;"
+      )
+    }
+  ]
+};
+var ui_reusables_default = uiReusablesModule;
+
+// src/modules/index.ts
+var modules = [
+  // P0 — Core (default checked)
+  network_default,
+  state_default,
+  storage_default,
+  // Note: expo-router and nativewind are always included in the base template
+  // P1 — Feature modules
+  payment_default,
+  form_default,
+  image_default,
+  video_default,
+  auth_google_default,
+  auth_facebook_default,
+  auth_apple_default,
+  webview_default,
+  i18n_default,
+  animation_default,
+  // P2 — Additional modules
+  ota_default,
+  notification_default,
+  permission_default,
+  bottom_sheet_default,
+  flashlist_default,
+  ui_reusables_default
+];
+function getModuleById(id) {
+  return modules.find((m) => m.id === id);
+}
+function getModulesByIds(ids) {
+  return ids.map((id) => getModuleById(id)).filter((m) => m !== void 0);
+}
+
+// src/templates/base.ts
+function generateBaseTemplates(projectName) {
+  return [
+    // ─── app/_layout.tsx ────────────────────────────────────────────────
+    {
+      path: "app/_layout.tsx",
+      content: `import { DarkTheme, DefaultTheme, ThemeProvider } from "@react-navigation/native";
+import { useFonts } from "expo-font";
+import { Stack } from "expo-router";
+import * as SplashScreen from "expo-splash-screen";
+import { useEffect } from "react";
+import { useColorScheme } from "react-native";
+
+import { Colors } from "@/src/constants/Colors";
+
+SplashScreen.preventAutoHideAsync();
+
+export default function RootLayout() {
+  const colorScheme = useColorScheme();
+  const [loaded] = useFonts({
+    SpaceMono: require("../assets/fonts/SpaceMono-Regular.ttf"),
+  });
+
+  useEffect(() => {
+    if (loaded) {
+      SplashScreen.hideAsync();
+    }
+  }, [loaded]);
+
+  if (!loaded) {
+    return null;
+  }
+
+  return (
+    <ThemeProvider value={colorScheme === "dark" ? DarkTheme : DefaultTheme}>
+      <Stack>
+        <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
+        <Stack.Screen name="+not-found" />
+      </Stack>
+    </ThemeProvider>
+  );
+}
+`
+    },
+    // ─── app/(tabs)/_layout.tsx ─────────────────────────────────────────
+    {
+      path: "app/(tabs)/_layout.tsx",
+      content: `import { Tabs } from "expo-router";
+import { Platform } from "react-native";
+
+import { Colors } from "@/src/constants/Colors";
+import { useColorScheme } from "@/src/hooks/useColorScheme";
+
+export default function TabLayout() {
+  const colorScheme = useColorScheme();
+
+  return (
+    <Tabs
+      screenOptions={{
+        tabBarActiveTintColor: Colors[colorScheme ?? "light"].tint,
+        headerStyle: {
+          backgroundColor: Colors[colorScheme ?? "light"].background,
+        },
+        headerShadowVisible: false,
+        tabBarStyle: Platform.select({
+          ios: {
+            position: "absolute",
+          },
+          default: {},
+        }),
+      }}
+    >
+      <Tabs.Screen
+        name="index"
+        options={{
+          title: "Home",
+          tabBarIcon: () => null,
+        }}
+      />
+      <Tabs.Screen
+        name="explore"
+        options={{
+          title: "Explore",
+          tabBarIcon: () => null,
+        }}
+      />
+    </Tabs>
+  );
+}
+`
+    },
+    // ─── app/(tabs)/index.tsx ───────────────────────────────────────────
+    {
+      path: "app/(tabs)/index.tsx",
+      content: `import { Image, StyleSheet, Platform } from "react-native";
+import { HelloWave } from "@/src/components/HelloWave";
+import { ThemedText } from "@/src/components/Themed";
+import { ThemedView } from "@/src/components/Themed";
+import { Link } from "expo-router";
+
+export default function HomeScreen() {
+  return (
+    <ThemedView style={styles.container}>
+      <ThemedView style={styles.titleContainer}>
+        <ThemedText type="title">${projectName}</ThemedText>
+        <HelloWave />
+      </ThemedView>
+      <ThemedView style={styles.stepContainer}>
+        <ThemedText type="subtitle">Step 1: Try it</ThemedText>
+        <ThemedText>
+          Edit <ThemedText type="defaultSemiBold">app/(tabs)/index.tsx</ThemedText> to see changes.
+          Press{" "}
+          <ThemedText type="defaultSemiBold">
+            {Platform.select({ ios: "cmd + d", android: "cmd + m" })}
+          </ThemedText>{" "}
+          to open developer tools.
+        </ThemedText>
+      </ThemedView>
+      <ThemedView style={styles.stepContainer}>
+        <ThemedText type="subtitle">Step 2: Explore</ThemedText>
+        <ThemedText>
+          Tap the Explore tab to learn more about what's included in this starter.
+        </ThemedText>
+        <Link href="/explore">
+          <ThemedText type="link">Go to Explore \u2192</ThemedText>
+        </Link>
+      </ThemedView>
+    </ThemedView>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  titleContainer: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8,
+  },
+  stepContainer: {
+    gap: 8,
+    marginBottom: 8,
+  },
+});
+`
+    },
+    // ─── app/(tabs)/explore.tsx ─────────────────────────────────────────
+    {
+      path: "app/(tabs)/explore.tsx",
+      content: `import { StyleSheet, Image, Platform } from "react-native";
+import { ThemedText } from "@/src/components/Themed";
+import { ThemedView } from "@/src/components/Themed";
+
+export default function ExploreScreen() {
+  return (
+    <ThemedView style={styles.container}>
+      <ThemedText type="title">Explore</ThemedText>
+      <ThemedText style={styles.subtitle}>
+        This screen shows what you can do with this scaffolded project.
+      </ThemedText>
+    </ThemedView>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  subtitle: {
+    fontSize: 16,
+    textAlign: "center",
+    marginTop: 8,
+  },
+});
+`
+    },
+    // ─── app/+not-found.tsx ─────────────────────────────────────────────
+    {
+      path: "app/+not-found.tsx",
+      content: `import { Link, Stack } from "expo-router";
+import { StyleSheet } from "react-native";
+import { ThemedText } from "@/src/components/Themed";
+import { ThemedView } from "@/src/components/Themed";
+
+export default function NotFoundScreen() {
+  return (
+    <>
+      <Stack.Screen options={{ title: "Oops!" }} />
+      <ThemedView style={styles.container}>
+        <ThemedText type="title">This screen doesn't exist.</ThemedText>
+        <Link href="/" style={styles.link}>
+          <ThemedText type="link">Go to home screen!</ThemedText>
+        </Link>
+      </ThemedView>
+    </>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center",
+    padding: 20,
+  },
+  link: {
+    marginTop: 15,
+    paddingVertical: 15,
+  },
+});
+`
+    },
+    // ─── src/components/Themed.tsx ───────────────────────────────────────
+    {
+      path: "src/components/Themed.tsx",
+      content: `import { Text, type TextProps, View, type ViewProps } from "react-native";
+import { useColorScheme } from "@/src/hooks/useColorScheme";
+import { Colors } from "@/src/constants/Colors";
+
+/** Themed text component that adapts to light/dark mode */
+export function ThemedText({
+  style,
+  type = "default",
+  ...rest
+}: TextProps & { type?: "default" | "title" | "defaultSemiBold" | "subtitle" | "link" }) {
+  const colorScheme = useColorScheme();
+  const color = Colors[colorScheme ?? "light"].text;
+
+  return (
+    <Text
+      style={[
+        { color },
+        type === "default" ? { fontSize: 16, lineHeight: 24 } : undefined,
+        type === "title" ? { fontSize: 28, fontWeight: "bold", lineHeight: 32 } : undefined,
+        type === "defaultSemiBold" ? { fontSize: 16, lineHeight: 24, fontWeight: "600" } : undefined,
+        type === "subtitle" ? { fontSize: 20, fontWeight: "bold" } : undefined,
+        type === "link" ? { fontSize: 16, lineHeight: 24, color: Colors[colorScheme ?? "light"].tint } : undefined,
+        style,
+      ]}
+      {...rest}
+    />
+  );
+}
+
+/** Themed view component that adapts to light/dark mode */
+export function ThemedView({ style, ...rest }: ViewProps) {
+  const colorScheme = useColorScheme();
+  const backgroundColor = Colors[colorScheme ?? "light"].background;
+
+  return <View style={[{ backgroundColor }, style]} {...rest} />;
+}
+`
+    },
+    // ─── src/components/HelloWave.tsx ────────────────────────────────────
+    {
+      path: "src/components/HelloWave.tsx",
+      content: `import { useEffect } from "react";
+import { Animated, Easing } from "react-native";
+import { ThemedText } from "./Themed";
+
+export function HelloWave() {
+  const rotationAnim = new Animated.Value(0);
+
+  useEffect(() => {
+    Animated.loop(
+      Animated.sequence([
+        Animated.timing(rotationAnim, {
+          toValue: 1,
+          duration: 150,
+          easing: Easing.linear,
+          useNativeDriver: true,
+        }),
+        Animated.timing(rotationAnim, {
+          toValue: 0,
+          duration: 150,
+          easing: Easing.linear,
+          useNativeDriver: true,
+        }),
+      ])
+    ).start();
+  }, [rotationAnim]);
+
+  return (
+    <Animated.View
+      style={{
+        transform: [
+          {
+            rotate: rotationAnim.interpolate({
+              inputRange: [0, 1],
+              outputRange: ["0deg", "14deg"],
+            }),
+          },
+        ],
+      }}
+    >
+      <ThemedText style={{ fontSize: 28 }}>\u{1F44B}</ThemedText>
+    </Animated.View>
+  );
+}
+`
+    },
+    // ─── src/hooks/useColorScheme.ts ─────────────────────────────────────
+    {
+      path: "src/hooks/useColorScheme.ts",
+      content: `import { useColorScheme as useRNColorScheme } from "react-native";
+
+/**
+ * Returns the current color scheme (light or dark).
+ * Defaults to "light" if the system preference is not available.
+ */
+export function useColorScheme(): "light" | "dark" {
+  return useRNColorScheme() ?? "light";
+}
+`
+    },
+    // ─── src/constants/Colors.ts ─────────────────────────────────────────
+    {
+      path: "src/constants/Colors.ts",
+      content: `/**
+ * Color tokens for light and dark themes.
+ * Used by Themed components and navigation theming.
+ */
+export const Colors = {
+  light: {
+    text: "#11181C",
+    background: "#fff",
+    tint: "#0a7ea4",
+    tabIconDefault: "#687076",
+    tabIconSelected: "#0a7ea4",
+  },
+  dark: {
+    text: "#ECEDEE",
+    background: "#151718",
+    tint: "#fff",
+    tabIconDefault: "#9BA1A6",
+    tabIconSelected: "#fff",
+  },
+};
+`
+    },
+    // ─── src/types/index.ts ─────────────────────────────────────────────
+    {
+      path: "src/types/index.ts",
+      content: `/** Global type definitions */
+
+/** Extend this to declare module-specific types */
+declare global {
+  // Add global type augmentations here
+}
+
+export {};
+`
+    },
+    // ─── app.json ────────────────────────────────────────────────────────
+    {
+      path: "app.json",
+      content: `{
+  "expo": {
+    "name": "${projectName}",
+    "slug": "${projectName}",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/icon.png",
+    "userInterfaceStyle": "light",
+    "splash": {
+      "image": "./assets/splash.png",
+      "resizeMode": "contain",
+      "backgroundColor": "#ffffff"
+    },
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.${projectName}.app"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "foregroundImage": "./assets/adaptive-icon.png",
+        "backgroundColor": "#ffffff"
+      },
+      "package": "com.${projectName}.app"
+    },
+    "web": {
+      "favicon": "./assets/favicon.png"
+    },
+    "plugins": [
+      "expo-router",
+      "expo-splash-screen"
+    ]
+  }
+}
+`
+    },
+    // ─── tsconfig.json ───────────────────────────────────────────────────
+    {
+      path: "tsconfig.json",
+      content: `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "strict": true,
+    "jsx": "react-jsx",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts"],
+  "exclude": ["node_modules"]
+}
+`
+    },
+    // ─── tailwind.config.js ──────────────────────────────────────────────
+    {
+      path: "tailwind.config.js",
+      content: `/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./app/**/*.{js,jsx,ts,tsx}",
+    "./src/**/*.{js,jsx,ts,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+`
+    },
+    // ─── metro.config.js ─────────────────────────────────────────────────
+    {
+      path: "metro.config.js",
+      content: `const { getDefaultConfig } = require("expo/metro-config");
+const { withTailwind } = require("@expo/metro-config/tailwind");
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = withTailwind(config);
+`
+    },
+    // ─── babel.config.js ─────────────────────────────────────────────────
+    {
+      path: "babel.config.js",
+      content: `module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: ["babel-preset-expo"],
+    plugins: ["nativewind/babel"],
+  };
+};
+`
+    },
+    // ─── .gitignore ─────────────────────────────────────────────────────
+    {
+      path: ".gitignore",
+      content: `# Learn more https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
+
+# dependencies
+node_modules/
+
+# Expo
+.expo/
+dist/
+web-build/
+
+# Native
+*.orig.*
+*.jks
+*.p8
+*.p12
+*.key
+*.mobileprovision
+
+# Metro
+.metro-health-check*
+
+# debug
+npm-debug.*
+yarn-debug.*
+yarn-error.*
+
+# macOS
+.DS_Store
+*.pem
+
+# local env files
+.env*.local
+
+# typescript
+*.tsbuildinfo
+
+# generated files
+expo-env.d.ts
+`
+    }
+  ];
+}
+
+// src/utils/file.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+async function writeFile(filePath, content) {
+  const dir = import_path.default.dirname(filePath);
+  await import_fs_extra.default.ensureDir(dir);
+  await import_fs_extra.default.writeFile(filePath, content, "utf-8");
+}
+async function writeJson(filePath, data, spaces = 2) {
+  const dir = import_path.default.dirname(filePath);
+  await import_fs_extra.default.ensureDir(dir);
+  await import_fs_extra.default.writeJson(filePath, data, { spaces });
+}
+function replaceTemplateVars(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+    result = result.replace(regex, value);
+  }
+  return result;
+}
+
+// src/utils/package.ts
+function generateBasePackageJson(projectName) {
+  return {
+    name: projectName,
+    version: "1.0.0",
+    main: "expo-router/entry",
+    scripts: {
+      start: "expo start",
+      android: "expo start --android",
+      ios: "expo start --ios",
+      web: "expo start --web",
+      lint: "eslint ."
+    },
+    dependencies: {
+      expo: "~54.0.0",
+      "expo-router": "~5.0.0",
+      "expo-linking": "~7.0.0",
+      "expo-constants": "~18.0.0",
+      "expo-status-bar": "~2.0.0",
+      "expo-splash-screen": "~1.0.0",
+      react: "19.0.0",
+      "react-native": "0.79.0",
+      "react-native-safe-area-context": "5.4.0",
+      "react-native-screens": "~4.6.0",
+      nativewind: "^4.1.0",
+      tailwindcss: "^3.4.0"
+    },
+    devDependencies: {
+      "@types/react": "~19.0.0",
+      typescript: "^5.5.0"
+    }
+  };
+}
+
+// src/index.ts
+var import_execa = require("execa");
+async function run() {
+  const program = new import_commander.Command();
+  program.name("expo-bbase").description("Expo SDK 54+ \u811A\u624B\u67B6 CLI \u5DE5\u5177").version("1.0.0");
+  program.argument("[project-name]", "Name of the project to create").action(async (projectName) => {
+    if (!projectName) {
+      console.error(import_chalk.default.red("Error: Please provide a project name."));
+      console.log(import_chalk.default.gray("Usage: npx expo-bbase <project-name>"));
+      process.exit(1);
+    }
+    await createProject(projectName);
+  });
+  registerCreateCommand(program);
+  await program.parseAsync(process.argv);
+}
+async function createProject(projectName) {
+  console.log();
+  console.log(
+    import_chalk.default.bold.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")
+  );
+  console.log(
+    import_chalk.default.bold.cyan("  \u2551     expo-bbase \u2014 Expo \u811A\u624B\u67B6\u5DE5\u5177      \u2551")
+  );
+  console.log(
+    import_chalk.default.bold.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")
+  );
+  console.log();
+  const choices = modules.map((m) => ({
+    title: `${import_chalk.default.bold(m.name)} \u2014 ${import_chalk.default.gray(m.description)}`,
+    value: m.id,
+    selected: m.defaultChecked
+  }));
+  const { selectedModules } = await (0, import_prompts.default)({
+    type: "multiselect",
+    name: "selectedModules",
+    message: "\u9009\u62E9\u9700\u8981\u7684\u529F\u80FD\u6A21\u5757\uFF08\u7A7A\u683C\u5207\u6362\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+    choices,
+    hint: "- \u7A7A\u683C\u5207\u6362\u9009\u62E9 \xB7 a \u5168\u9009/\u53D6\u6D88 \xB7 \u56DE\u8F66\u786E\u8BA4",
+    instructions: false
+  });
+  if (selectedModules === void 0) {
+    console.log(import_chalk.default.yellow("\n\u5DF2\u53D6\u6D88\u521B\u5EFA\u9879\u76EE\u3002"));
+    process.exit(0);
+  }
+  const selectedModuleDefs = getModulesByIds(selectedModules);
+  const targetDir = import_path2.default.resolve(process.cwd(), projectName);
+  console.log();
+  console.log(import_chalk.default.white(`  \u{1F4E6} \u9879\u76EE\u540D\u79F0: ${import_chalk.default.bold(projectName)}`));
+  console.log(
+    import_chalk.default.white(`  \u{1F4C2} \u76EE\u6807\u8DEF\u5F84: ${import_chalk.default.gray(targetDir)}`)
+  );
+  console.log(
+    import_chalk.default.white(
+      `  \u{1F9E9} \u9009\u62E9\u6A21\u5757: ${import_chalk.default.green(selectedModuleDefs.map((m) => m.name).join(", ") || "\u65E0")}`
+    )
+  );
+  console.log();
+  const spinner = (0, import_ora.default)("\u6B63\u5728\u521B\u5EFA\u9879\u76EE...").start();
+  try {
+    const baseTemplates = generateBaseTemplates(projectName);
+    for (const file of baseTemplates) {
+      const filePath = import_path2.default.join(targetDir, file.path);
+      const content = replaceTemplateVars(file.content, {
+        projectName
+      });
+      await writeFile(filePath, content);
+    }
+    spinner.text = "\u6B63\u5728\u5199\u5165\u6A21\u5757\u6587\u4EF6...";
+    for (const mod of selectedModuleDefs) {
+      for (const file of mod.files) {
+        const filePath = import_path2.default.join(targetDir, file.path);
+        const content = replaceTemplateVars(file.content, {
+          projectName
+        });
+        await writeFile(filePath, content);
+      }
+    }
+    spinner.text = "\u6B63\u5728\u751F\u6210 package.json...";
+    const pkgJson = generateBasePackageJson(projectName);
+    const allDeps = {};
+    const allDevDeps = {};
+    for (const mod of selectedModuleDefs) {
+      Object.assign(allDeps, mod.dependencies);
+      Object.assign(allDevDeps, mod.devDependencies);
+    }
+    Object.assign(pkgJson.dependencies, allDeps);
+    Object.assign(
+      pkgJson.devDependencies,
+      allDevDeps
+    );
+    const pkgPath = import_path2.default.join(targetDir, "package.json");
+    await writeJson(pkgPath, pkgJson);
+    spinner.text = "\u6B63\u5728\u914D\u7F6E app.json...";
+    await updateAppJson(targetDir, selectedModuleDefs, projectName);
+    spinner.text = "\u6B63\u5728\u914D\u7F6E Babel...";
+    await updateBabelConfig(targetDir, selectedModuleDefs);
+    spinner.text = "\u6B63\u5728\u914D\u7F6E\u5165\u53E3\u6587\u4EF6...";
+    await updateLayoutFile(targetDir, selectedModuleDefs);
+    spinner.text = "\u6B63\u5728\u5B89\u88C5\u4F9D\u8D56 (npm install)...";
+    try {
+      await (0, import_execa.execa)("npm", ["install"], {
+        cwd: targetDir,
+        timeout: 3e5
+        // 5 minute timeout
+      });
+    } catch (installError) {
+      spinner.warn("npm install \u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C npm install");
+      console.log(
+        import_chalk.default.gray(`  cd ${projectName} && npm install`)
+      );
+    }
+    spinner.succeed(import_chalk.default.green("\u9879\u76EE\u521B\u5EFA\u6210\u529F\uFF01"));
+    console.log();
+    console.log(import_chalk.default.bold("  \u{1F389} \u4E0B\u4E00\u6B65\uFF1A"));
+    console.log(import_chalk.default.white(`     cd ${projectName}`));
+    console.log(import_chalk.default.white("     npx expo start"));
+    console.log();
+    if (selectedModuleDefs.length > 0) {
+      console.log(import_chalk.default.bold("  \u{1F4CB} \u5DF2\u9009\u6A21\u5757\uFF1A"));
+      for (const mod of selectedModuleDefs) {
+        console.log(import_chalk.default.white(`     \u2713 ${mod.name}`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail(import_chalk.default.red("\u9879\u76EE\u521B\u5EFA\u5931\u8D25"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function updateAppJson(targetDir, selectedModules, projectName) {
+  const appJsonPath = import_path2.default.join(targetDir, "app.json");
+  const appJson = await import("fs-extra").then(
+    (fs2) => fs2.readJson(appJsonPath)
+  );
+  const existingPlugins = appJson.expo?.plugins || [];
+  for (const mod of selectedModules) {
+    if (mod.appConfig?.plugins) {
+      const modulePlugins = mod.appConfig.plugins;
+      for (const plugin of modulePlugins) {
+        const pluginName = typeof plugin === "string" ? plugin : plugin[0];
+        const exists = existingPlugins.some(
+          (p) => typeof p === "string" ? p === pluginName : p[0] === pluginName
+        );
+        if (!exists) {
+          existingPlugins.push(plugin);
+        }
+      }
+    }
+  }
+  appJson.expo.plugins = existingPlugins;
+  await writeJson(appJsonPath, appJson);
+}
+async function updateBabelConfig(targetDir, selectedModules) {
+  const babelPath = import_path2.default.join(targetDir, "babel.config.js");
+  const fs2 = await import("fs-extra");
+  let content = await fs2.readFile(babelPath, "utf-8");
+  const extraPlugins = [];
+  for (const mod of selectedModules) {
+    if (mod.babelPlugins) {
+      extraPlugins.push(...mod.babelPlugins);
+    }
+  }
+  if (extraPlugins.length > 0) {
+    const pluginStrings = extraPlugins.map((p) => `    "${p}"`).join(",\n");
+    content = content.replace(
+      /plugins:\s*\[([^\]]*)\]/,
+      `plugins: [$1${pluginStrings ? ",\n" + pluginStrings : ""}]`
+    );
+    await fs2.writeFile(babelPath, content, "utf-8");
+  }
+}
+async function updateLayoutFile(targetDir, selectedModules) {
+  const layoutPath = import_path2.default.join(targetDir, "app/_layout.tsx");
+  const fs2 = await import("fs-extra");
+  let content = await fs2.readFile(layoutPath, "utf-8");
+  const extraImports = [];
+  const extraProviderPairs = [];
+  for (const mod of selectedModules) {
+    if (mod.layoutImports) {
+      extraImports.push(...mod.layoutImports);
+    }
+    if (mod.layoutProviders) {
+      for (const provider of mod.layoutProviders) {
+        const match = provider.match(/^<(\w+)/);
+        if (match) {
+          const tagName = match[1];
+          extraProviderPairs.push({
+            open: `      ${provider}`,
+            close: `      </${tagName}>`
+          });
+        }
+      }
+    }
+  }
+  if (extraImports.length === 0 && extraProviderPairs.length === 0) {
+    return;
+  }
+  if (extraImports.length > 0) {
+    const lastImportIndex = content.lastIndexOf("import ");
+    const lineEndIndex = content.indexOf("\n", lastImportIndex);
+    const importBlock = "\n" + extraImports.join("\n");
+    content = content.slice(0, lineEndIndex + 1) + importBlock + content.slice(lineEndIndex + 1);
+  }
+  if (extraProviderPairs.length > 0) {
+    const returnMatch = content.indexOf("return (");
+    if (returnMatch !== -1) {
+      const openingProviders = extraProviderPairs.map((p) => p.open).join("\n");
+      const closingProviders = extraProviderPairs.reverse().map((p) => p.close).join("\n");
+      const themeProviderOpen = content.indexOf("<ThemeProvider");
+      const themeProviderClose = content.lastIndexOf("</ThemeProvider>");
+      if (themeProviderOpen !== -1 && themeProviderClose !== -1) {
+        content = content.slice(0, themeProviderOpen) + openingProviders + "\n" + content.slice(themeProviderOpen);
+        const newThemeProviderClose = content.lastIndexOf("</ThemeProvider>");
+        const afterClose = newThemeProviderClose + "</ThemeProvider>".length;
+        content = content.slice(0, afterClose) + "\n" + closingProviders + content.slice(afterClose);
+      }
+    }
+  }
+  await fs2.writeFile(layoutPath, content, "utf-8");
+}
+run().catch((error) => {
+  console.error(import_chalk.default.red("Fatal error:"), error);
+  process.exit(1);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProject,
+  run
+});
+//# sourceMappingURL=index.js.map