create-expo 5.0.0 → 5.1.0

package/build/{205.index.js → 589.index.js}

@@ -1,9 +1,9 @@
 "use strict";
-exports.id = 205;
-exports.ids = [205,601];
+exports.id = 589;
+exports.ids = [589,601];
 exports.modules = {
 
-/***/ 8205:
+/***/ 589:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
@@ -12,7 +12,7 @@ __webpack_require__.d(__webpack_exports__, {
   createAsync: () => (/* binding */ createAsync)
 });
 
-// UNUSED EXPORTS: logNodeInstallWarning
+// UNUSED EXPORTS: logNodeInstallWarning, setupDependenciesAsync
 
 // EXTERNAL MODULE: ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js
 var source = __webpack_require__(2314);
@@ -25,7 +25,6 @@ var external_path_ = __webpack_require__(6928);
 var external_path_default = /*#__PURE__*/__webpack_require__.n(external_path_);
 // EXTERNAL MODULE: ../@expo/json-file/build/JsonFile.js
 var JsonFile = __webpack_require__(3064);
-var JsonFile_default = /*#__PURE__*/__webpack_require__.n(JsonFile);
 // EXTERNAL MODULE: ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.js
 var prompts = __webpack_require__(6133);
 var prompts_default = /*#__PURE__*/__webpack_require__.n(prompts);
@@ -36,8 +35,69 @@ var index_min = __webpack_require__(9337);
 // EXTERNAL MODULE: ../../node_modules/.pnpm/ora@3.4.0/node_modules/ora/index.js
 var ora = __webpack_require__(5344);
 var ora_default = /*#__PURE__*/__webpack_require__.n(ora);
-// EXTERNAL MODULE: ../../node_modules/.pnpm/multitars@1.0.0/node_modules/multitars/dist/multitars.mjs
-var multitars = __webpack_require__(912);
+// EXTERNAL MODULE: ./src/log.ts
+var log = __webpack_require__(1545);
+;// CONCATENATED MODULE: ./src/createExpoConfig.ts
+
+
+
+const debug = __webpack_require__(6675)('expo:init:monorepo-config');
+const CREATE_EXPO_CONFIG_NAME = '.create-expo.json';
+/**
+ * Read `.create-expo.json` from the project root and immediately
+ * delete the file from disk so it doesn't leak into the user's project.
+ * Returns the parsed config (or `undefined` if there's no file / it's
+ * malformed). This is the "use it once" entry point that template-extraction
+ * code paths should call — every downstream consumer takes the parsed
+ * object in memory.
+ */
+async function consumeMonorepoConfigAsync(projectRoot) {
+    const config = await loadMonorepoConfigAsync(projectRoot);
+    await external_fs_default().promises
+        .rm(external_path_default().join(projectRoot, CREATE_EXPO_CONFIG_NAME), { force: true })
+        .catch(() => undefined);
+    return config;
+}
+/**
+ * Reads `.create-expo.json` from the project root without touching
+ * the file. Returns `undefined` if the file is missing, unreadable, or
+ * malformed — a missing file is the common case (single-app templates) and
+ * shouldn't warn.
+ *
+ * Prefer `consumeMonorepoConfigAsync` for the create-expo flow so the
+ * template-only config doesn't leak into the user's project. This function
+ * stays exported for tests and any other read-only callers.
+ */
+async function loadMonorepoConfigAsync(projectRoot) {
+    const configPath = external_path_default().join(projectRoot, CREATE_EXPO_CONFIG_NAME);
+    let contents;
+    try {
+        contents = await external_fs_default().promises.readFile(configPath, { encoding: 'utf-8' });
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            log/* Log */.tG.log(`Could not read ${CREATE_EXPO_CONFIG_NAME}; ignoring: ${error?.message ?? error}`);
+        }
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        log/* Log */.tG.log(`${CREATE_EXPO_CONFIG_NAME} could not be parsed as JSON; ignoring: ${error?.message ?? error}`);
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        log/* Log */.tG.log(`${CREATE_EXPO_CONFIG_NAME} did not parse as a JSON object; ignoring.`);
+        return undefined;
+    }
+    debug(`Loaded ${CREATE_EXPO_CONFIG_NAME}`);
+    return parsed;
+}
+
+// EXTERNAL MODULE: ../../node_modules/.pnpm/multitars@1.0.2/node_modules/multitars/dist/multitars.mjs
+var multitars = __webpack_require__(6378);
 // EXTERNAL MODULE: ../../node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/index.js
 var picomatch = __webpack_require__(3268);
 var picomatch_default = /*#__PURE__*/__webpack_require__.n(picomatch);
@@ -45,7 +105,7 @@ var picomatch_default = /*#__PURE__*/__webpack_require__.n(picomatch);
 
 
 
-const debug = __webpack_require__(6675)('expo:init:fileTransform');
+const createFileTransform_debug = __webpack_require__(6675)('expo:init:fileTransform');
 function sanitizedName(name) {
     return name
         .replace(/[\W_]+/g, '')
@@ -87,16 +147,14 @@ function createEntryRenamer(name) {
 }
 function createGlobFilter(globPattern, options) {
     const matcher = picomatch_default()(globPattern, options);
-    debug('filter: created for pattern %s (%s)', globPattern);
+    createFileTransform_debug('filter: created for pattern %s (%s)', globPattern);
     return (path) => {
         const included = matcher(path);
-        debug('filter: %s - %s', included ? 'include' : 'exclude', path);
+        createFileTransform_debug('filter: %s - %s', included ? 'include' : 'exclude', path);
         return included;
     };
 }
 
-// EXTERNAL MODULE: ./src/log.ts
-var log = __webpack_require__(1545);
 // EXTERNAL MODULE: ./src/resolvePackageManager.ts
 var resolvePackageManager = __webpack_require__(9560);
 // EXTERNAL MODULE: ./src/utils/env.ts
@@ -131,6 +189,57 @@ var external_os_ = __webpack_require__(857);
 var external_os_default = /*#__PURE__*/__webpack_require__.n(external_os_);
 // EXTERNAL MODULE: external "stream"
 var external_stream_ = __webpack_require__(2203);
+;// CONCATENATED MODULE: ./src/legacyTemplates.ts
+
+
+
+const LEGACY_TEMPLATES = [
+    {
+        title: 'Default',
+        value: 'expo-template-default',
+        description: 'includes tools recommended for most app developers',
+    },
+    {
+        title: 'Blank',
+        value: 'expo-template-blank',
+        description: 'a minimal app as clean as an empty canvas',
+    },
+    {
+        title: 'Blank (TypeScript)',
+        value: 'expo-template-blank-typescript',
+        description: 'blank app with TypeScript enabled',
+    },
+    {
+        title: 'Navigation (TypeScript)',
+        value: 'expo-template-tabs',
+        description: 'File-based routing with TypeScript enabled',
+    },
+    {
+        title: 'Blank (Bare)',
+        value: 'expo-template-bare-minimum',
+        description: 'blank app with the native code exposed (expo prebuild)',
+    },
+];
+const ALIASES = LEGACY_TEMPLATES.map(({ value }) => value);
+async function promptTemplateAsync() {
+    if (env.env.CI) {
+        throw new Error('Cannot prompt for template in CI');
+    }
+    const { answer } = await prompts_default()({
+        type: 'select',
+        name: 'answer',
+        message: 'Choose a template:',
+        choices: LEGACY_TEMPLATES,
+    });
+    if (!answer) {
+        console.log();
+        console.log(source_default() `Specify the template name, example: {cyan --template expo-template-blank}`);
+        console.log();
+        process.exit(1);
+    }
+    return answer;
+}
+
 // EXTERNAL MODULE: external "node:crypto"
 var external_node_crypto_ = __webpack_require__(5217);
 var external_node_crypto_default = /*#__PURE__*/__webpack_require__.n(external_node_crypto_);
@@ -262,57 +371,6 @@ async function extractAsync(input, output, options) {
     await extractStream(Readable.toWeb(fs.createReadStream(input)), output, options);
 }
 
-;// CONCATENATED MODULE: ./src/legacyTemplates.ts
-
-
-
-const LEGACY_TEMPLATES = [
-    {
-        title: 'Default',
-        value: 'expo-template-default',
-        description: 'includes tools recommended for most app developers',
-    },
-    {
-        title: 'Blank',
-        value: 'expo-template-blank',
-        description: 'a minimal app as clean as an empty canvas',
-    },
-    {
-        title: 'Blank (TypeScript)',
-        value: 'expo-template-blank-typescript',
-        description: 'blank app with TypeScript enabled',
-    },
-    {
-        title: 'Navigation (TypeScript)',
-        value: 'expo-template-tabs',
-        description: 'File-based routing with TypeScript enabled',
-    },
-    {
-        title: 'Blank (Bare)',
-        value: 'expo-template-bare-minimum',
-        description: 'blank app with the native code exposed (expo prebuild)',
-    },
-];
-const ALIASES = LEGACY_TEMPLATES.map(({ value }) => value);
-async function promptTemplateAsync() {
-    if (env.env.CI) {
-        throw new Error('Cannot prompt for template in CI');
-    }
-    const { answer } = await prompts_default()({
-        type: 'select',
-        name: 'answer',
-        message: 'Choose a template:',
-        choices: LEGACY_TEMPLATES,
-    });
-    if (!answer) {
-        console.log();
-        console.log(source_default() `Specify the template name, example: {cyan --template expo-template-blank}`);
-        console.log();
-        process.exit(1);
-    }
-    return answer;
-}
-
 ;// CONCATENATED MODULE: ./src/utils/npm.ts
 
 
@@ -424,8 +482,9 @@ async function npmPackAsync(packageName, cwd = undefined, ...props) {
     }
     try {
         const json = JSON.parse(results);
-        if (Array.isArray(json) && json.every(isNpmPackageInfo)) {
-            return json.map(sanitizeNpmPackageFilename);
+        const packages = normalizeNpmPackResult(json);
+        if (packages?.every(isNpmPackageInfo)) {
+            return packages.map(sanitizeNpmPackageFilename);
         }
         else {
             throw new Error(`Invalid response from npm: ${results}`);
@@ -435,6 +494,18 @@ async function npmPackAsync(packageName, cwd = undefined, ...props) {
         throw new Error(`Could not parse JSON returned from "${cmdString}".\n\n${results}\n\nError: ${error.message}`);
     }
 }
+/** Normalize the npm pack JSON formats used before and after npm 12 */
+function normalizeNpmPackResult(result) {
+    if (Array.isArray(result)) {
+        return result;
+    }
+    else if (result && typeof result === 'object') {
+        return Object.values(result);
+    }
+    else {
+        return null;
+    }
+}
 function getNpmBin() {
     return process.platform === 'win32' ? 'npm.cmd' : 'npm';
 }
@@ -507,6 +578,7 @@ async function downloadAndExtractNpmModuleAsync(npmName, output, props) {
 
 
 
+
 const github_debug = __webpack_require__(6675)('expo:init:github');
 // See: https://github.com/expo/expo/blob/a5a6eecb082b2c7a7fc9956141738231c7df473f/packages/%40expo/cli/src/prebuild/resolveTemplate.ts#L60-L84
 async function getGitHubRepoAsync(url) {
@@ -552,9 +624,15 @@ async function extractRemoteGitHubTarballAsync(url, repo, output, props) {
     const strip = directory.length + 1;
     // Only extract the relevant (sub)directories, ignoring irrelevant files
     // The filter auto-ignores dotfiles, unless explicitly included
-    const filter = createGlobFilter(!directory.length
-        ? ['*/**', '*/ios/.xcode.env']
-        : [`*/${directory.join('/')}/**`, `*/${directory.join('/')}/ios/.xcode.env`], {
+    const subDirPrefix = directory.length ? `*/${directory.join('/')}` : '*';
+    const filter = createGlobFilter([
+        `${subDirPrefix}/**`,
+        `${subDirPrefix}/ios/.xcode.env`,
+        // Templates ship their monorepo config as a root-level dotfile; without
+        // an explicit allow-list entry, picomatch's default `dot: false` drops
+        // it during extraction so downstream consumers see no config at all.
+        `${subDirPrefix}/${CREATE_EXPO_CONFIG_NAME}`,
+    ], {
         // Always ignore the `.xcworkspace` folder
         ignore: ['**/ios/*.xcworkspace/**'],
     });
@@ -569,7 +647,7 @@ async function downloadAndExtractGitHubRepositoryAsync(repoUrl, output, props) {
     const info = await getGitHubRepoAsync(repoUrl);
     const isValid = await isValidGitHubRepoAsync(info);
     if (!isValid) {
-        throw new Error(`Could not to locate repository for "${repoUrl}", ensure this repository exists`);
+        throw new Error(`Could not locate repository for "${repoUrl}", ensure this repository exists`);
     }
     const url = `https://codeload.github.com/${info.owner}/${info.name}/tar.gz/${info.branch}`;
     github_debug('Resolved GitHub repository', info);
@@ -591,6 +669,7 @@ async function downloadAndExtractGitHubRepositoryAsync(repoUrl, output, props) {
 
 
 
+
 const Template_debug = __webpack_require__(6675)('expo:init:template');
 const isMacOS = process.platform === 'darwin';
 // keep this list in sync with the validation helper in WWW: src/utils/experienceParser.ts
@@ -675,6 +754,11 @@ function resolvePackageModuleId(moduleId) {
 /**
  * Extract a template app to a given file path and clean up any properties left over from npm to
  * prepare it for usage.
+ *
+ * If the template ships a `.create-expo.json`, its `renamePatterns`
+ * field overrides the default rename config used by the HelloWorld
+ * find-and-replace pass. The config file is read once and deleted from disk
+ * immediately so it can never leak into the user's project.
  */
 async function extractAndPrepareTemplateAppAsync(projectRoot, { npmPackage }) {
     const projectName = external_path_default().basename(projectRoot);
@@ -692,8 +776,12 @@ async function extractAndPrepareTemplateAppAsync(projectRoot, { npmPackage }) {
             disableCache: type === 'file',
         });
     }
+    const monorepoConfig = await consumeMonorepoConfigAsync(projectRoot);
     try {
-        const files = await getTemplateFilesToRenameAsync({ cwd: projectRoot });
+        const files = await getTemplateFilesToRenameAsync({
+            cwd: projectRoot,
+            renameConfig: monorepoConfig?.renamePatterns,
+        });
         await renameTemplateAppNameAsync({
             cwd: projectRoot,
             files,
@@ -745,8 +833,8 @@ function escapeXMLCharacters(original) {
  * Whitespace is trimmed and whitespace-only lines are ignored.
  *
  * If no rename config has been passed directly to
- * `getTemplateFilesToRenameAsync()` then this default rename config will be
- * used instead.
+ * `getTemplateFilesToRenameAsync()`, then this default
+ * rename config will be used instead.
  */
 const defaultRenameConfig = [
     // Common
@@ -805,7 +893,9 @@ async function renameTemplateAppNameAsync({ cwd, name, files, }) {
         const absoluteFilePath = external_path_default().resolve(cwd, file);
         let contents;
         try {
-            contents = await external_fs_default().promises.readFile(absoluteFilePath, { encoding: 'utf-8' });
+            contents = await external_fs_default().promises.readFile(absoluteFilePath, {
+                encoding: 'utf-8',
+            });
         }
         catch (error) {
             throw new Error(`Failed to read template file: "${absoluteFilePath}". Was it removed mid-operation?`, { cause: error });
@@ -861,12 +951,14 @@ async function sanitizeTemplateAsync(projectRoot) {
         name: projectName,
         slug: projectName,
     };
-    const appFile = new (JsonFile_default())(external_path_default().join(projectRoot, 'app.json'), { default: {} });
+    const appFile = new JsonFile["default"](external_path_default().join(projectRoot, 'app.json'), {
+        default: {},
+    });
     const appContent = (await appFile.readAsync());
     const appJson = deepMerge(appContent, 'expo' in appContent ? { expo: defaultConfig } : defaultConfig);
     await appFile.writeAsync(appJson);
     Template_debug(`Created app.json:\n%O`, appJson);
-    const packageFile = new (JsonFile_default())(external_path_default().join(projectRoot, 'package.json'));
+    const packageFile = new JsonFile["default"](external_path_default().join(projectRoot, 'package.json'));
     const packageJson = await packageFile.readAsync();
     // name and version are required for yarn workspaces (monorepos)
     const inputName = 'name' in appJson ? appJson.name : appJson.expo.name;
@@ -1011,6 +1103,7 @@ function logNewSection(title) {
 
 
 
+
 const Examples_debug = __webpack_require__(6675)('expo:init:template');
 /** List all existing examples directory from https://github.com/expo/examples. */
 async function listExamplesAsync() {
@@ -1066,7 +1159,14 @@ async function promptExamplesAsync() {
     }
     return answer;
 }
-/** Download and move the selected example from https://github.com/expo/examples. */
+/**
+ * Download and move the selected example from https://github.com/expo/examples.
+ *
+ * If the example ships a `.create-expo.json`, its `renamePatterns`
+ * field overrides the default rename config used by the HelloWorld
+ * find-and-replace pass. The config file is read once and deleted from disk
+ * immediately so it can never leak into the user's project.
+ */
 async function downloadAndExtractExampleAsync(root, name) {
     const projectName = external_path_default().basename(root);
     const response = await fetch_fetch('https://codeload.github.com/expo/examples/tar.gz/master');
@@ -1084,7 +1184,11 @@ async function downloadAndExtractExampleAsync(root, name) {
         strip: 2,
         filter: (entryName) => entryName.startsWith(prefix),
     });
-    const files = await getTemplateFilesToRenameAsync({ cwd: root });
+    const monorepoConfig = await consumeMonorepoConfigAsync(root);
+    const files = await getTemplateFilesToRenameAsync({
+        cwd: root,
+        renameConfig: monorepoConfig?.renamePatterns,
+    });
     await renameTemplateAppNameAsync({
         cwd: root,
         files,
@@ -1110,61 +1214,235 @@ async function sanitizeScriptsAsync(root) {
             ios: 'expo start --ios',
             web: 'expo start --web',
         };
-    const packageFile = new (JsonFile_default())(external_path_default().join(root, 'package.json'));
+    const packageFile = new JsonFile["default"](external_path_default().join(root, 'package.json'));
     const packageJson = await packageFile.readAsync();
     const scripts = (packageJson.scripts ?? {});
     packageJson.scripts = { ...defaultScripts, ...scripts };
     await packageFile.writeAsync(packageJson);
 }
 
-;// CONCATENATED MODULE: ./src/generateAgentFiles.ts
+// EXTERNAL MODULE: ../../node_modules/.pnpm/resolve-workspace-root@2.0.1/node_modules/resolve-workspace-root/build/index.js
+var resolve_workspace_root_build = __webpack_require__(8665);
+;// CONCATENATED MODULE: ./src/configureWorkspaces.ts
 
 
-function getExpoSdkVersion(root) {
+
+const configureWorkspaces_debug = __webpack_require__(6675)('expo:init:workspaces');
+const PNPM_WORKSPACE_FILENAME = 'pnpm-workspace.yaml';
+const WORKSPACE_DEP_FIELDS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+];
+/**
+ * Normalize a monorepo template's workspace-package dependency specs to the
+ * chosen package manager's convention, and — for pnpm — write a
+ * `pnpm-workspace.yaml` listing the workspace packages so they're picked up
+ * regardless of the root `package.json` `workspaces` field.
+ */
+async function configureWorkspacesAsync(projectRoot, packageManager) {
+    const workspacePatterns = (await (0,resolve_workspace_root_build.getWorkspaceGlobsAsync)(projectRoot)) ?? [];
+    if (!workspacePatterns.length) {
+        configureWorkspaces_debug(`No workspaces declared at ${projectRoot}; skipping workspace configuration`);
+        return;
+    }
+    const memberPaths = await resolveWorkspaceMemberPathsAsync(projectRoot, workspacePatterns);
+    configureWorkspaces_debug(`Found ${memberPaths.length} workspace member(s): ${memberPaths.join(', ')}`);
+    const targetSpec = packageManager === 'npm' ? '*' : 'workspace:*';
+    for (const memberPath of memberPaths) {
+        await normalizeWorkspaceDepsAsync(memberPath, targetSpec);
+    }
+    if (packageManager === 'pnpm') {
+        await ensurePnpmWorkspaceYamlAsync(projectRoot, workspacePatterns);
+    }
+}
+async function resolveWorkspaceMemberPathsAsync(projectRoot, patterns) {
+    const members = [];
+    const seen = new Set();
+    for (const pattern of patterns) {
+        const expanded = await expandPatternAsync(projectRoot, pattern);
+        for (const member of expanded) {
+            if (!seen.has(member)) {
+                seen.add(member);
+                members.push(member);
+            }
+        }
+    }
+    return members;
+}
+async function expandPatternAsync(projectRoot, pattern) {
+    const segments = pattern.split('/').filter((s) => s.length > 0);
+    if (segments.length === 0) {
+        return [];
+    }
+    // Literal path (no wildcards anywhere) — return it if its package.json exists.
+    if (!segments.some((s) => s.includes('*'))) {
+        const memberDir = external_path_default().resolve(projectRoot, ...segments);
+        return (await packageJsonExistsAsync(memberDir)) ? [memberDir] : [];
+    }
+    // Single trailing wildcard segment — read the parent dir, keep children
+    // whose package.json exists.
+    if (segments[segments.length - 1] === '*' &&
+        !segments.slice(0, -1).some((s) => s.includes('*'))) {
+        const parentDir = external_path_default().resolve(projectRoot, ...segments.slice(0, -1));
+        let entries;
+        try {
+            entries = await external_fs_default().promises.readdir(parentDir, { withFileTypes: true });
+        }
+        catch (error) {
+            configureWorkspaces_debug(`Could not read workspace parent ${parentDir}: ${error?.message ?? error}`);
+            return [];
+        }
+        const matches = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const memberDir = external_path_default().join(parentDir, entry.name);
+            if (await packageJsonExistsAsync(memberDir)) {
+                matches.push(memberDir);
+            }
+        }
+        return matches;
+    }
+    configureWorkspaces_debug(`Unsupported workspace pattern "${pattern}" (only literal paths and trailing /* are handled)`);
+    return [];
+}
+async function packageJsonExistsAsync(memberDir) {
     try {
-        const pkg = JSON.parse(external_fs_default().readFileSync(external_path_default().join(root, 'package.json'), 'utf-8'));
-        const expoVersion = (pkg.dependencies?.expo ?? pkg.devDependencies?.expo);
-        if (!expoVersion)
-            return null;
-        const match = expoVersion.match(/(\d+)\./);
-        return match?.[1] ?? null;
+        const stat = await external_fs_default().promises.stat(external_path_default().join(memberDir, 'package.json'));
+        return stat.isFile();
     }
     catch {
-        return null;
+        return false;
     }
 }
-function getAgentsMdContent(sdkVersion) {
-    const docsUrl = sdkVersion
-        ? `https://docs.expo.dev/versions/v${sdkVersion}.0.0/`
-        : 'https://docs.expo.dev';
-    return `# Expo HAS CHANGED
+async function normalizeWorkspaceDepsAsync(memberDir, targetSpec) {
+    const pkgPath = external_path_default().join(memberDir, 'package.json');
+    const pkg = await readJsonFileAsync(pkgPath);
+    if (!pkg) {
+        configureWorkspaces_debug(`Skipping ${pkgPath} (not readable)`);
+        return;
+    }
+    let changed = false;
+    for (const field of WORKSPACE_DEP_FIELDS) {
+        const deps = pkg[field];
+        if (!deps) {
+            continue;
+        }
+        for (const [name, spec] of Object.entries(deps)) {
+            if ((spec === 'workspace:*' || spec === '*') && spec !== targetSpec) {
+                deps[name] = targetSpec;
+                changed = true;
+            }
+        }
+    }
+    if (changed) {
+        await external_fs_default().promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+        configureWorkspaces_debug(`Normalized workspace deps in ${pkgPath} → "${targetSpec}"`);
+    }
+}
+async function readJsonFileAsync(filePath) {
+    try {
+        const contents = await external_fs_default().promises.readFile(filePath, 'utf-8');
+        return JSON.parse(contents);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Ensure `pnpm-workspace.yaml` contains a `packages:` block listing our
+ * workspace patterns. If the file doesn't exist we write it from scratch. If
+ * it does exist (e.g. the template ships its own with extra pnpm settings),
+ * we preserve all existing content and only append `packages:`
+ */
+async function ensurePnpmWorkspaceYamlAsync(projectRoot, patterns) {
+    if (patterns.length === 0) {
+        return;
+    }
+    const yamlPath = external_path_default().join(projectRoot, PNPM_WORKSPACE_FILENAME);
+    let existing;
+    try {
+        existing = await external_fs_default().promises.readFile(yamlPath, 'utf-8');
+    }
+    catch (error) {
+        if (error?.code !== 'ENOENT') {
+            configureWorkspaces_debug(`Could not read existing ${yamlPath}: ${error?.message ?? error}`);
+        }
+    }
+    const packagesBlock = [
+        'packages:',
+        ...patterns.map((pattern) => `  - ${quoteIfNeeded(pattern)}`),
+    ].join('\n');
+    if (existing === undefined) {
+        await external_fs_default().promises.writeFile(yamlPath, `${packagesBlock}\n`, 'utf-8');
+        configureWorkspaces_debug(`Wrote ${yamlPath}`);
+        return;
+    }
+    if (/^packages:/m.test(existing)) {
+        configureWorkspaces_debug(`Existing ${yamlPath} already declares packages; leaving it alone`);
+        return;
+    }
+    const needsLeadingNewline = existing.length > 0 && !existing.endsWith('\n');
+    const updated = `${existing}${needsLeadingNewline ? '\n' : ''}${packagesBlock}\n`;
+    await external_fs_default().promises.writeFile(yamlPath, updated, 'utf-8');
+    configureWorkspaces_debug(`Appended packages: to existing ${yamlPath}`);
+}
+function quoteIfNeeded(value) {
+    // Quote glob patterns that begin with `*`, `?`, `!`, or `&` so YAML doesn't
+    // mis-parse them as tags or anchors.
+    return /^[!*?&]/.test(value) ? `"${value}"` : value;
+}
 
-Read the exact versioned docs at ${docsUrl} before writing any code.
-`;
+;// CONCATENATED MODULE: ./src/generateAgentFiles.ts
+
+
+
+const AGENT_TEMPLATE_FILE_NAMES = (/* unused pure expression or super */ null && (['AGENTS.md', 'CLAUDE.md']));
+// Agent templates are synced from `expo/llm-configs` at publish time (see
+// `scripts/sync-agent-templates.js`) and bundled under `template/agent-files`, so project
+// creation works offline. `__dirname` is the build output directory, one level below the
+// package root in both the source tree and the published package.
+const AGENT_TEMPLATES_DIR = __webpack_require__.ab + "agent-files";
+function resolveAgentTemplatePath(fileName) {
+    return __webpack_require__.ab + "agent-files/" + fileName;
 }
-const CLAUDE_MD_CONTENT = `@AGENTS.md
-`;
 const CLAUDE_SETTINGS_CONTENT = `{
   "enabledPlugins": {
     "expo@claude-plugins-official": true
   }
 }
 `;
-function generateAgentFiles(root) {
-    const sdkVersion = getExpoSdkVersion(root);
-    const files = [
-        { filePath: external_path_default().join(root, 'AGENTS.md'), content: getAgentsMdContent(sdkVersion) },
-        { filePath: external_path_default().join(root, 'CLAUDE.md'), content: CLAUDE_MD_CONTENT },
-        { filePath: external_path_default().join(root, '.claude', 'settings.json'), content: CLAUDE_SETTINGS_CONTENT },
+function isClaudeCodeInstalled() {
+    const home = external_os_default().homedir();
+    return (!!home &&
+        (external_fs_default().existsSync(external_path_default().join(home, '.claude.json')) || external_fs_default().existsSync(external_path_default().join(home, '.claude'))));
+}
+async function copyFileIfMissing(sourcePath, destinationPath) {
+    if (external_fs_default().existsSync(destinationPath)) {
+        return;
+    }
+    const dir = external_path_default().dirname(destinationPath);
+    await external_fs_default().promises.mkdir(dir, { recursive: true });
+    await external_fs_default().promises.copyFile(sourcePath, destinationPath);
+}
+async function writeFileIfMissing(filePath, content) {
+    if (external_fs_default().existsSync(filePath)) {
+        return;
+    }
+    const dir = external_path_default().dirname(filePath);
+    await external_fs_default().promises.mkdir(dir, { recursive: true });
+    await external_fs_default().promises.writeFile(filePath, content);
+}
+async function generateAgentFiles(root) {
+    const tasks = [
+        copyFileIfMissing(resolveAgentTemplatePath('AGENTS.md'), external_path_default().join(root, 'AGENTS.md')),
     ];
-    for (const { filePath, content } of files) {
-        if (external_fs_default().existsSync(filePath)) {
-            continue;
-        }
-        const dir = external_path_default().dirname(filePath);
-        external_fs_default().mkdirSync(dir, { recursive: true });
-        external_fs_default().writeFileSync(filePath, content);
+    if (isClaudeCodeInstalled()) {
+        tasks.push(copyFileIfMissing(resolveAgentTemplatePath('CLAUDE.md'), external_path_default().join(root, 'CLAUDE.md')), writeFileIfMissing(external_path_default().join(root, '.claude', 'settings.json'), CLAUDE_SETTINGS_CONTENT));
     }
+    await Promise.all(tasks);
 }
 
 ;// CONCATENATED MODULE: ./src/promptSdkVersion.ts
@@ -1433,12 +1711,23 @@ async function resolveProjectRootAsync(input) {
 
 // EXTERNAL MODULE: ./src/telemetry.ts + 2 modules
 var telemetry = __webpack_require__(601);
+// EXTERNAL MODULE: ./src/utils/update-check.ts
+var update_check = __webpack_require__(7517);
 ;// CONCATENATED MODULE: ./src/utils/git.ts
 
 
 
 
+
 const git_debug = __webpack_require__(6675)('expo:init:git');
+const getPackageJson = () => {
+    try {
+        return __webpack_require__(8330);
+    }
+    catch {
+        return null;
+    }
+};
 /** Check if the given directory is inside an existing git repository */
 async function isInsideGitRepoAsync(root) {
     try {
@@ -1487,12 +1776,12 @@ async function initGitRepoAsync(root) {
         // User explicitly chose not to skip, proceed with git init (creates nested repo)
         git_debug(source_default().dim('User chose to initialize git inside existing repo.'));
     }
-    const packageJSON = __webpack_require__(392);
+    const packageJSON = getPackageJson();
     // not in git tree, so let's init
     try {
         await spawnAsync_default()('git', ['init'], { stdio: 'ignore', cwd: root });
         await spawnAsync_default()('git', ['add', '-A'], { stdio: 'ignore', cwd: root });
-        const commitMsg = `Initial commit\n\nGenerated by ${packageJSON.name} ${packageJSON.version}.`;
+        const commitMsg = `Initial commit\n\nGenerated by ${packageJSON?.name ?? update_check.PACKAGE_NAME} ${packageJSON?.version ?? '0.0.0'}.`;
         await spawnAsync_default()('git', ['commit', '-m', commitMsg], {
             stdio: 'ignore',
             cwd: root,
@@ -1544,6 +1833,7 @@ function withSectionLog(action, message) {
 
 
 
+
 const createAsync_debug = __webpack_require__(6675)('expo:init:create');
 async function resolveProjectRootArgAsync(inputPath, { yes }) {
     if (!inputPath && yes) {
@@ -1560,13 +1850,18 @@ async function resolveProjectRootArgAsync(inputPath, { yes }) {
 async function setupDependenciesAsync(projectRoot, props) {
     const shouldInstall = props.install;
     const packageManager = (0,resolvePackageManager/* resolvePackageManager */._c)();
+    // For monorepo templates: normalize workspace-package dependency specs to
+    // the chosen package manager's convention, and write a `pnpm-workspace.yaml`
+    // when pnpm is the resolved manager. No-op for single-app templates.
+    await configureWorkspacesAsync(projectRoot, packageManager);
     // Configure package manager, which is unrelated to installing or not
     await configureNodeDependenciesAsync(projectRoot, packageManager);
     // Install dependencies
     let podsInstalled = false;
+    let nodeModulesInstalled = false;
     const needsPodsInstalled = await external_fs_default().existsSync(external_path_default().join(projectRoot, 'ios'));
     if (shouldInstall) {
-        await installNodeDependenciesAsync(projectRoot, packageManager);
+        nodeModulesInstalled = await installNodeDependenciesAsync(projectRoot, packageManager);
         if (needsPodsInstalled) {
             podsInstalled = await installCocoaPodsAsync(projectRoot);
         }
@@ -1574,7 +1869,8 @@ async function setupDependenciesAsync(projectRoot, props) {
     const cdPath = getChangeDirectoryPath(projectRoot);
     console.log();
     logProjectReady({ cdPath, packageManager });
-    if (!shouldInstall) {
+    // The install can also fail without stopping the command, so check the result and not the flag.
+    if (!nodeModulesInstalled) {
         logNodeInstallWarning(cdPath, packageManager, needsPodsInstalled && !podsInstalled);
     }
 }
@@ -1612,14 +1908,18 @@ async function createTemplateAsync(inputPath, props) {
         event: telemetry.AnalyticsEventTypes.CREATE_EXPO_APP,
         properties: { phase: telemetry.AnalyticsEventPhases.ATTEMPT, template: resolvedTemplate },
     });
-    await withSectionLog(() => extractAndPrepareTemplateAppAsync(projectRoot, { npmPackage: resolvedTemplate }), {
+    await withSectionLog(async () => {
+        await extractAndPrepareTemplateAppAsync(projectRoot, {
+            npmPackage: resolvedTemplate,
+        });
+    }, {
         pending: source_default().bold('Locating project files.'),
         success: 'Downloaded and extracted project files.',
         error: (error) => `Something went wrong in downloading and extracting the project files: ${error.message}`,
     });
     await setupDependenciesAsync(projectRoot, props);
     if (props.agentsMd) {
-        generateAgentFiles(projectRoot);
+        await generateAgentFiles(projectRoot);
     }
     // for now, we will just init a git repo if they have git installed and the
     // project is not inside an existing git tree, and do it silently. we should
@@ -1686,14 +1986,16 @@ async function createExampleAsync(inputPath, props) {
         event: telemetry.AnalyticsEventTypes.CREATE_EXPO_APP,
         properties: { phase: telemetry.AnalyticsEventPhases.ATTEMPT, example: resolvedExample },
     });
-    await withSectionLog(() => downloadAndExtractExampleAsync(projectRoot, resolvedExample), {
+    await withSectionLog(async () => {
+        await downloadAndExtractExampleAsync(projectRoot, resolvedExample);
+    }, {
         pending: source_default().bold('Locating example files...'),
         success: 'Downloaded and extracted example files.',
         error: (error) => `Something went wrong in downloading and extracting the example files: ${error.message}`,
     });
     await setupDependenciesAsync(projectRoot, props);
     if (props.agentsMd) {
-        generateAgentFiles(projectRoot);
+        await generateAgentFiles(projectRoot);
     }
     // for now, we will just init a git repo if they have git installed and the
     // project is not inside an existing git tree, and do it silently. we should
@@ -1726,14 +2028,17 @@ async function configureNodeDependenciesAsync(projectRoot, packageManager) {
         log/* Log */.tG.exception(error);
     }
 }
+/** Install the node modules. Returns `false` when the package manager failed. */
 async function installNodeDependenciesAsync(projectRoot, packageManager) {
     try {
         await (0,resolvePackageManager/* installDependenciesAsync */.DC)(projectRoot, packageManager, { silent: false });
+        return true;
     }
     catch (error) {
         createAsync_debug(`Error installing node modules: %O`, error);
         log/* Log */.tG.error(`Something went wrong installing JavaScript dependencies. Check your ${packageManager} logs. Continuing to create the app.`);
         log/* Log */.tG.exception(error);
+        return false;
     }
 }
 async function installCocoaPodsAsync(projectRoot) {
@@ -1788,7 +2093,6 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: ../@expo/json-file/build/JsonFile.js
 var JsonFile = __webpack_require__(3064);
-var JsonFile_default = /*#__PURE__*/__webpack_require__.n(JsonFile);
 // EXTERNAL MODULE: external "crypto"
 var external_crypto_ = __webpack_require__(6982);
 var external_crypto_default = /*#__PURE__*/__webpack_require__.n(external_crypto_);
@@ -1830,7 +2134,7 @@ const getStateJsonPath = () => external_path_default().join(dotExpoHomeDirectory
 
 function getSession() {
     try {
-        return JsonFile_default().read(getStateJsonPath())?.auth ?? null;
+        return JsonFile["default"].read(getStateJsonPath())?.auth ?? null;
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -1842,6 +2146,8 @@ function getSession() {
 
 // EXTERNAL MODULE: ./src/utils/env.ts
 var utils_env = __webpack_require__(4342);
+// EXTERNAL MODULE: ./src/utils/update-check.ts
+var update_check = __webpack_require__(7517);
 ;// CONCATENATED MODULE: ./src/telemetry.ts
 
 
@@ -1850,11 +2156,19 @@ var utils_env = __webpack_require__(4342);
 
 
 
-const packageJSON = __webpack_require__(8330);
+
+const getPackageJson = () => {
+    try {
+        return __webpack_require__(8330);
+    }
+    catch {
+        return null;
+    }
+};
 const xdlUnifiedWriteKey = '1wabJGd5IiuF9Q8SGlcI90v8WTs';
 const analyticsEndpoint = 'https://cdp.expo.dev/v1/batch';
 const version = '1.0.0';
-const library = packageJSON.name;
+const library = update_check.PACKAGE_NAME;
 const messageBatch = [];
 let analyticsIdentity = null;
 // jest does not clear global variables inbetween tests so we need this helper
@@ -1911,7 +2225,7 @@ function enqueue(type, message) {
         message.originalTimestamp = new Date();
     }
     if (!message.messageId) {
-        // We md5 the messaage to add more randomness. This is primarily meant
+        // We md5 the message to add more randomness. This is primarily meant
         // for use in the browser where the uuid package falls back to Math.random()
         // which is not a great source of randomness.
         // Borrowed from analytics.js (https://github.com/segment-integrations/analytics.js-integration-segmentio/blob/a20d2a2d222aeb3ab2a8c7e72280f1df2618440e/lib/index.js#L255-L256).
@@ -1921,7 +2235,7 @@ function enqueue(type, message) {
     }
     messageBatch.push(message);
 }
-// very barebones implemention...
+// very barebones implementation...
 // does not support multiple concurrent flushes or large numbers of messages
 async function flushAsync() {
     if (utils_env.env.EXPO_NO_TELEMETRY)
@@ -1947,7 +2261,7 @@ async function flushAsync() {
         await fetch(analyticsEndpoint, request);
     }
     catch {
-        // supress errors - likely due to network connectivity or endpoint health
+        // suppress errors - likely due to network connectivity or endpoint health
     }
     // clear array so we don't resend events in subsequent flushes
     messageBatch.splice(0, messageBatch.length);
@@ -1964,7 +2278,7 @@ function getAnalyticsContext() {
     return {
         os: { name: platform, version: external_os_default().release() },
         device: { type: platform, model: platform },
-        app: { name: library, version: packageJSON.version },
+        app: { name: library, version: getPackageJson()?.version ?? undefined },
     };
 }
 //#endregion
@@ -1975,7 +2289,7 @@ function uuidv4() {
         return external_crypto_default().randomUUID();
     }
     catch {
-        // supress errors due to node 13 or less not having randomUUID
+        // suppress errors due to node 13 or less not having randomUUID
         return null;
     }
 }
@@ -1996,14 +2310,14 @@ async function getAnalyticsIdentityAsync() {
     if (!external_fs_default().existsSync(getStateJsonPath())) {
         external_fs_default().writeFileSync(getStateJsonPath(), JSON.stringify({}));
     }
-    const savedDeviceId = await JsonFile_default().getAsync(getStateJsonPath(), 'analyticsDeviceId', null);
+    const savedDeviceId = await JsonFile["default"].getAsync(getStateJsonPath(), 'analyticsDeviceId', null);
     const deviceId = savedDeviceId ?? uuidv4();
     if (!deviceId) {
         // unable to generate an id or load one from disk
         return null;
     }
     if (!savedDeviceId) {
-        await JsonFile_default().setAsync(getStateJsonPath(), 'analyticsDeviceId', deviceId);
+        await JsonFile["default"].setAsync(getStateJsonPath(), 'analyticsDeviceId', deviceId);
     }
     const userId = getSession()?.userId ?? null;
     return userId ? { anonymousId: deviceId, userId } : { anonymousId: deviceId };