codingpixel-expo-app 0.1.0

package/dist/install.js

@@ -0,0 +1,243 @@
+// Phase 7 step 2 — `installNativeDeps` + `retryWithIsolation`.
+// Phase 8 step 1 — `ensureLockfile`.
+import fs from "node:fs";
+import path from "node:path";
+import { execa } from "execa";
+import { log } from "./util.js";
+// ---------- always-installed list (SPEC §7 + Deviation #4) ----------
+export function buildAlwaysInstalledList(workletsPkg) {
+    return [
+        // From plan §7
+        "@reduxjs/toolkit",
+        "react-redux",
+        "redux-persist",
+        "react-native-mmkv",
+        "@tanstack/react-query",
+        "axios",
+        "formik",
+        "yup",
+        "expo-router",
+        "expo-dev-client",
+        "react-native-safe-area-context",
+        "react-native-gesture-handler",
+        "react-native-screens",
+        "react-native-reanimated",
+        workletsPkg, // react-native-worklets or -core per Phase 0 Probe 3
+        "react-native-keyboard-controller",
+        "react-error-boundary",
+        "react-native-responsive-fontsize",
+        "@expo/vector-icons",
+        "@shopify/flash-list",
+        // Deviation #4 (docs/MIRROR_NOTES.md) — needed by mirrored components
+        "expo-device",
+        "expo-image",
+        "expo-font",
+        "expo-linear-gradient",
+        "react-native-logs",
+        "react-native-reanimated-skeleton",
+        // Deviation #7 — Phase 7 patchBabel injects ["module-resolver", { alias }];
+        // Metro fails on first bundle if the plugin pkg isn't installed.
+        "babel-plugin-module-resolver",
+    ];
+}
+export function buildConditionalDeps(answers) {
+    const out = [];
+    if (answers.bottomSheet)
+        out.push("@gorhom/bottom-sheet");
+    if (answers.imagePicker)
+        out.push("expo-image-picker");
+    return out;
+}
+// ---------- error classification ----------
+const TRANSIENT_MARKERS = [
+    "ETIMEDOUT",
+    "ECONNRESET",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "socket hang up",
+    "network",
+    "registry returned 5",
+    "503",
+    "502",
+];
+export function isTransientError(stderr) {
+    const lower = stderr.toLowerCase();
+    return TRANSIENT_MARKERS.some((m) => lower.includes(m.toLowerCase()));
+}
+const FAILING_DEP_PATTERNS = [
+    /(?:Cannot find|Could not resolve|No matching version for|Conflicting peer dependency for)\s+["']?([@\w/.-]+)["']?/i,
+    /version resolution failed for\s+["']?([@\w/.-]+)["']?/i,
+];
+/**
+ * Extract the name of the failing dep from Expo CLI stderr. Returns the name
+ * only if it matches one of `remaining` (defends against false positives like
+ * package names mentioned in surrounding diagnostic context). Returns null on
+ * unparseable input.
+ */
+export function parseFailingDep(stderr, remaining) {
+    for (const re of FAILING_DEP_PATTERNS) {
+        const m = stderr.match(re);
+        if (m && remaining.includes(m[1]))
+            return m[1];
+    }
+    // Last-mention fallback: scan stderr for any `remaining` package name; return the last one mentioned.
+    // No `\b` boundary — scoped package names start with `@`, which is non-word so
+    // `\b@tanstack` would never match. Use `(^|[^@\w/-])` instead so we don't
+    // accidentally match a substring inside another package path.
+    let lastIdx = -1;
+    let lastDep = null;
+    for (const dep of remaining) {
+        const escaped = dep.replace(/[/\-^$.*+?()[\]{}|\\]/g, "\\$&");
+        const re = new RegExp(`(^|[^@\\w/-])${escaped}([^@\\w/-]|$)`, "g");
+        let match;
+        while ((match = re.exec(stderr)) !== null) {
+            if (match.index > lastIdx) {
+                lastIdx = match.index;
+                lastDep = dep;
+            }
+        }
+    }
+    return lastDep;
+}
+export async function retryWithIsolation(target, deps, pmFlag) {
+    let remaining = [...deps];
+    const failedTwice = new Set();
+    let lastStderr = "";
+    while (remaining.length > 0) {
+        const args = ["--yes", "expo", "install", ...remaining];
+        if (pmFlag)
+            args.push(pmFlag);
+        const result = await execa("npx", args, { cwd: target, reject: false });
+        if (result.exitCode === 0)
+            return;
+        lastStderr = result.stderr ?? "";
+        if (isTransientError(lastStderr)) {
+            throw new Error(`Network failure during expo install — check connection and retry. ` +
+                `Target dir preserved; re-run CLI to retry.\n${lastStderr}`);
+        }
+        const culprit = parseFailingDep(lastStderr, remaining);
+        if (!culprit) {
+            throw new Error(`Install failed with unparseable stderr:\n${lastStderr}`);
+        }
+        if (failedTwice.has(culprit)) {
+            throw new Error(`'${culprit}' failed twice; aborting.\n${lastStderr}`);
+        }
+        failedTwice.add(culprit);
+        remaining = remaining.filter((d) => d !== culprit);
+        log.warn(`expo install: dropping '${culprit}' and retrying remaining ${remaining.length}`);
+    }
+    if (failedTwice.size > 0) {
+        throw new Error(`Could not install: ${[...failedTwice].join(", ")}\n${lastStderr}`);
+    }
+}
+/**
+ * Phase 7 step 2 — single `expo install` call (with PM-flag or pre-seeded
+ * lockfile per Phase 0 probe outcome). On atomic failure, falls back to
+ * `retryWithIsolation` for deterministic errors only.
+ */
+export async function installNativeDeps(target, answers, opts) {
+    const allDeps = [
+        ...buildAlwaysInstalledList(opts.workletsPkg),
+        ...buildConditionalDeps(answers),
+    ];
+    // Branch A: pass --yarn / --npm flag.
+    // Branch B: pre-seed lockfile, run without flag.
+    let pmFlag = null;
+    if (opts.flagsOk) {
+        pmFlag = answers.packageManager === "yarn" ? "--yarn" : "--npm";
+    }
+    else {
+        seedLockfile(target, answers.packageManager);
+    }
+    // Pre-install: materialize `expo` package so `expo install` can read SDK
+    // version. create-expo-app was invoked with `--no-install`, so node_modules
+    // is empty at this point. `expo install` itself shells out to `expo` (a
+    // local module) and refuses to run without it.
+    const pmCmd = answers.packageManager === "yarn" ? "yarn" : "npm";
+    log.step(`Materializing template deps via ${pmCmd} install…`);
+    await execa(pmCmd, ["install"], { cwd: target, stdio: "inherit" });
+    log.step(`Installing ${allDeps.length} native deps via expo install (${answers.packageManager})…`);
+    const args = ["--yes", "expo", "install", ...allDeps];
+    if (pmFlag)
+        args.push(pmFlag);
+    const result = await execa("npx", args, {
+        cwd: target,
+        stdio: "inherit",
+        reject: false,
+    });
+    if (result.exitCode !== 0) {
+        // stdio: inherit means we don't have stderr captured. Re-run silently to capture.
+        const verbose = await execa("npx", args, { cwd: target, reject: false });
+        const stderr = verbose.stderr ?? "";
+        if (isTransientError(stderr)) {
+            throw new Error(`Network failure during expo install — check connection and retry. ` +
+                `Target dir preserved; re-run CLI to retry.\n${stderr}`);
+        }
+        log.warn("expo install failed atomically — falling back to retryWithIsolation");
+        await retryWithIsolation(target, allDeps, pmFlag);
+    }
+}
+/**
+ * Phase 7 step 2 Branch B — pre-seed the chosen PM's lockfile so Expo CLI
+ * auto-detects PM from lockfile presence (when `--yarn`/`--npm` flag is absent
+ * in installed @expo/cli).
+ */
+export function seedLockfile(target, pm) {
+    if (pm === "yarn") {
+        const p = path.join(target, "yarn.lock");
+        if (!fs.existsSync(p))
+            fs.writeFileSync(p, "");
+    }
+    else {
+        const p = path.join(target, "package-lock.json");
+        if (!fs.existsSync(p)) {
+            const minimalNpmLock = {
+                name: path.basename(target),
+                version: "1.0.0",
+                lockfileVersion: 3,
+                requires: true,
+                packages: {},
+            };
+            fs.writeFileSync(p, JSON.stringify(minimalNpmLock, null, 2) + "\n");
+        }
+    }
+}
+export async function ensureLockfile(target, answers, opts) {
+    if (!opts.probePass) {
+        const installCmd = answers.packageManager === "yarn" ? "yarn" : "npm";
+        log.step(`Phase 0 probe indicated explicit ${installCmd} install needed; running…`);
+        await execa(installCmd, ["install"], { cwd: target, stdio: "inherit" });
+    }
+    const yarnLock = path.join(target, "yarn.lock");
+    const npmLock = path.join(target, "package-lock.json");
+    const yarnExists = fs.existsSync(yarnLock);
+    const npmExists = fs.existsSync(npmLock);
+    if (!yarnExists && !npmExists) {
+        throw new Error("ensureLockfile: install completed but no lockfile present. " +
+            "expo install may have failed silently — check stderr above.");
+    }
+    if (yarnExists && npmExists) {
+        if (opts.flagsOk) {
+            throw new Error("Both yarn.lock and package-lock.json present after expo install --<pm> succeeded. " +
+                "Installed Expo CLI version is not honoring the PM flag. " +
+                "File an issue with Expo CLI version (npx expo --version) + this CLI's version.");
+        }
+        else {
+            throw new Error("Both yarn.lock and package-lock.json present after lockfile pre-seed. " +
+                "expo install created the other PM's lockfile, ignoring the seed. " +
+                `Re-run with EXPO_PACKAGE_MANAGER=${answers.packageManager === "yarn" ? "npm" : "yarn"} as a workaround; file an issue.`);
+        }
+    }
+    const producedPm = yarnExists ? "yarn" : "npm";
+    const mismatch = producedPm !== answers.packageManager;
+    if (mismatch) {
+        const other = answers.packageManager === "yarn" ? "package-lock.json" : "yarn.lock";
+        log.warn(`⚠️  PM MISMATCH: requested ${answers.packageManager} but Expo CLI produced ${other}.\n` +
+            `Installed Expo CLI version likely ignored the PM flag/seed.\n` +
+            `Recovery options:\n` +
+            `  (1) Accept the produced PM — your project is functional.\n` +
+            `  (2) Re-run with EXPO_PACKAGE_MANAGER=${producedPm} to align config with reality.\n` +
+            `  (3) Delete ${other}, then run \`${answers.packageManager} install\` manually.`);
+    }
+    return { producedPm, mismatch };
+}

package/dist/overlay.js

@@ -0,0 +1,141 @@
+// Phase 4 overlay engine — sentinel matcher, alias rewriter, template copier.
+// Sentinel rules per PLAN_V5.md Phase 4 "Placeholder conventions".
+import fs from "node:fs";
+import path from "node:path";
+import fse from "fs-extra";
+// ---------- Sentinels ----------
+/** Module-position sentinel: own line, line-comment form. */
+export const MODULE_SENTINEL = /^\s*\/\/\s*@@([A-Z_]+)@@\s*$/;
+/** JSX-position sentinel: own line, JSX expression containing a block comment. */
+export const JSX_SENTINEL = /^\s*\{\/\*\s*@@([A-Z_]+)@@\s*\*\/\}\s*$/;
+/** Same shape, anywhere on the line — used to catch malformed/orphan tokens. */
+export const ORPHAN_PROBE = /@@[A-Z_]+@@/;
+/**
+ * Replace whole-line sentinels in `source` per `replacements`.
+ *
+ * Rules:
+ *   - A line matching MODULE_SENTINEL OR JSX_SENTINEL is replaced with the
+ *     corresponding string from `replacements`. If the replacement is empty,
+ *     the line is dropped entirely (no orphan blank).
+ *   - A line containing `@@[A-Z_]+@@` that matches NEITHER regex (e.g. inline
+ *     sentinel, mismatched opener/closer, or sentinel-not-owning-line) MUST
+ *     throw — these are malformed and would silently leak past Phase 6 audit.
+ *   - Any token in `replacements` whose key never appears throws — catches
+ *     typos / renames in the sentinel list.
+ */
+export function applySentinels(source, replacements, filePath) {
+    const seen = new Set();
+    const out = [];
+    for (const line of source.split("\n")) {
+        const moduleMatch = line.match(MODULE_SENTINEL);
+        const jsxMatch = line.match(JSX_SENTINEL);
+        if (moduleMatch || jsxMatch) {
+            const token = (moduleMatch ?? jsxMatch)[1];
+            if (!(token in replacements)) {
+                throw new Error(`Sentinel @@${token}@@ in ${filePath} has no replacement provided.`);
+            }
+            seen.add(token);
+            const replacement = replacements[token];
+            if (replacement === "") {
+                // Drop the whole line — no orphan blank.
+                continue;
+            }
+            out.push(replacement);
+            continue;
+        }
+        if (ORPHAN_PROBE.test(line)) {
+            throw new Error(`Malformed sentinel in ${filePath} (not whole-line, opener↔closer mismatched, ` +
+                `or inline inside live code): ${line.trim()}`);
+        }
+        out.push(line);
+    }
+    // Optional: warn on unused replacement keys (typo guard). Keep silent here —
+    // some templates legitimately use a subset of the global sentinel map.
+    void seen;
+    return out.join("\n");
+}
+/**
+ * Module-reference forms we rewrite. Plan v5-r6: extended beyond `from "x"`
+ * to cover dynamic import + require + jest.mock so future mirrored files
+ * (any form) don't silently miss.
+ */
+const SPECIFIER_FORMS = [
+    /(\bfrom\s+)(["'])([^"']+)(\2)/g,
+    /(\bimport\s*\(\s*)(["'])([^"']+)(\2)/g,
+    /(\brequire\s*\(\s*)(["'])([^"']+)(\2)/g,
+    /(\bjest\.mock\s*\(\s*)(["'])([^"']+)(\2)/g,
+];
+/**
+ * Rewrite import specifiers per `aliasMap`.
+ *
+ * Iteration order: longest source prefix first (so a hypothetical short prefix
+ * like `@/` doesn't consume a longer-specific one like `@/assets`).
+ *
+ * Idempotent: applying `(@x → @x)` is a no-op; applying twice yields same result.
+ */
+export function rewriteImports(source, aliasMap) {
+    const sortedEntries = Object.entries(aliasMap).sort((a, b) => b[0].length - a[0].length);
+    function rewriteSpecifier(spec) {
+        for (const [from, to] of sortedEntries) {
+            if (spec === from || spec.startsWith(from)) {
+                return to + spec.slice(from.length);
+            }
+        }
+        return spec;
+    }
+    let out = source;
+    for (const re of SPECIFIER_FORMS) {
+        out = out.replace(re, (_match, head, openQuote, spec, closeQuote) => {
+            return `${head}${openQuote}${rewriteSpecifier(spec)}${closeQuote}`;
+        });
+    }
+    return out;
+}
+// ---------- Copying ----------
+/**
+ * Recursively copy `srcRoot` → `destRoot`. Idempotent: existing files at dest
+ * are overwritten (we own the template overlay, not the user).
+ */
+export function copyTemplate(srcRoot, destRoot) {
+    if (!fs.existsSync(srcRoot)) {
+        throw new Error(`copyTemplate: source missing: ${srcRoot}`);
+    }
+    fse.copySync(srcRoot, destRoot, { overwrite: true });
+}
+/**
+ * Apply `templates/base/` overlay to `target`.
+ *
+ * `templates/base/` lives inside this CLI package. `target` is the user's
+ * generated app dir (post-create-expo-app + cleanupBlankTemplate).
+ */
+export function applyBase(target, templatesRoot) {
+    const baseDir = path.join(templatesRoot, "base");
+    copyTemplate(baseDir, target);
+}
+/**
+ * Phase 5 step 3 — overlay the 5 bottom-sheet appComponents on top of base.
+ * No-op when answers.bottomSheet === false (caller checks before invoking).
+ */
+export function applyBottomSheet(target, templatesRoot) {
+    const bsDir = path.join(templatesRoot, "bottom-sheet");
+    if (!fs.existsSync(bsDir))
+        return;
+    copyTemplate(bsDir, target);
+}
+/**
+ * Phase 5 step 3 — overlay PermissionService.ts when answers.imagePicker. The
+ * media-constants snippet is spliced separately by `patchConstants` (Phase 5
+ * step 4) — this overlay only copies the service file.
+ */
+export function applyImagePicker(target, templatesRoot) {
+    const ipDir = path.join(templatesRoot, "image-picker");
+    if (!fs.existsSync(ipDir))
+        return;
+    // Copy the `src/` subtree only — the snippet file lives at the root of
+    // templates/image-picker/ for `patchConstants` to read directly, and we
+    // don't want it ending up in the generated project.
+    const srcSubtree = path.join(ipDir, "src");
+    if (fs.existsSync(srcSubtree)) {
+        copyTemplate(srcSubtree, path.join(target, "src"));
+    }
+}

package/dist/patch.js

@@ -0,0 +1,212 @@
+// Patcher set per PLAN_V5.md Phases 4 (app.json, expo-router entry),
+// 5 (constants, app.json plugins), 6 (layout/fonts sentinels), 7 (package.json
+// scripts, tsconfig, babel.config).
+//
+// Patches MUST be idempotent — re-running the CLI on the same target after a
+// mid-phase failure must converge (Phase 7 "Cross-cutting" subsection).
+import fs from "node:fs";
+import path from "node:path";
+import fse from "fs-extra";
+import { applySentinels } from "./overlay.js";
+import { fileExists, log } from "./util.js";
+// ---------- helpers ----------
+/** Convert a free-form app name to an Expo `scheme` (lower-kebab-case, alnum + `-`). */
+export function slugify(name) {
+    return (name
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "") // strip diacritics
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase() || "app");
+}
+function readJson(p) {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+}
+function writeJson(p, value) {
+    fs.writeFileSync(p, JSON.stringify(value, null, 2) + "\n");
+}
+const nameOf = (entry) => Array.isArray(entry) ? String(entry[0]) : String(entry);
+/**
+ * Phase 4 step 7 — set `expo.name`, `expo.slug`, `expo.scheme = slugify(name)`,
+ * add `"expo-router"` to `expo.plugins` if missing. Uses `nameOf` equality
+ * predicate so a user-customized `["expo-router", {...options}]` entry is
+ * preserved (matches Phase 5 step 5).
+ *
+ * `expo.name` + `expo.slug` are also set by create-expo-app from the positional
+ * dir arg — we set them again here (defense in depth) so the values are
+ * guaranteed even if upstream changes its naming heuristic.
+ */
+export function patchAppJson(target, name, _answers) {
+    const p = path.join(target, "app.json");
+    if (!fileExists(p)) {
+        throw new Error(`patchAppJson: ${p} not found.`);
+    }
+    const json = readJson(p);
+    json.expo ??= {};
+    json.expo.name = name;
+    json.expo.slug = slugify(name);
+    json.expo.scheme = slugify(name);
+    json.expo.plugins ??= [];
+    if (!json.expo.plugins.some((e) => nameOf(e) === "expo-router")) {
+        json.expo.plugins.push("expo-router");
+    }
+    writeJson(p, json);
+}
+/**
+ * Phase 5 step 5 — add image-picker plugin entry conditionally. Idempotent via
+ * `nameOf` equality (user-customized options object preserved).
+ */
+export function patchAppJsonPlugins(target, answers) {
+    if (!answers.imagePicker)
+        return;
+    const p = path.join(target, "app.json");
+    const json = readJson(p);
+    json.expo ??= {};
+    json.expo.plugins ??= [];
+    const entry = [
+        "expo-image-picker",
+        {
+            photosPermission: "The app accesses your photos to let you share them with your friends.",
+        },
+    ];
+    if (!json.expo.plugins.some((e) => nameOf(e) === nameOf(entry))) {
+        json.expo.plugins.push(entry);
+    }
+    writeJson(p, json);
+}
+// ---------- expo-router entry + tsconfig.extends ----------
+/**
+ * Phase 4 step 8 — set `package.json#main` to `expo-router/entry` + ensure
+ * tsconfig extends `expo/tsconfig.base`.
+ */
+export function patchExpoRouterEntry(target) {
+    const pkgPath = path.join(target, "package.json");
+    const pkg = readJson(pkgPath);
+    pkg.main = "expo-router/entry";
+    writeJson(pkgPath, pkg);
+    const tsPath = path.join(target, "tsconfig.json");
+    if (fileExists(tsPath)) {
+        const ts = readJson(tsPath);
+        if (!ts.extends)
+            ts.extends = "expo/tsconfig.base";
+        writeJson(tsPath, ts);
+    }
+}
+// ---------- constants splice (Phase 5 step 4) ----------
+/**
+ * Always runs — drops the `@@MEDIA_CONSTANTS@@` sentinel line cleanly even
+ * when `imagePicker === false` (fixes v3 orphan-sentinel bug). Splices the
+ * media-constants snippet on `imagePicker === true`.
+ */
+export function patchConstants(target, templatesRoot, answers) {
+    const p = path.join(target, "src/core/utils/constants.ts");
+    if (!fileExists(p)) {
+        throw new Error(`patchConstants: ${p} missing — was applyBase run first?`);
+    }
+    const source = fs.readFileSync(p, "utf8");
+    let replacement = "";
+    if (answers.imagePicker) {
+        const sp = path.join(templatesRoot, "image-picker/media-constants.snippet.ts");
+        replacement = fs.readFileSync(sp, "utf8").trimEnd();
+    }
+    const out = applySentinels(source, { MEDIA_CONSTANTS: replacement }, p);
+    fs.writeFileSync(p, out);
+}
+// ---------- layout + fonts splice (Phase 6 step 4) ----------
+export function patchLayout(target, replacements) {
+    const layoutPath = path.join(target, "src/app/_layout.tsx");
+    const fontsPath = path.join(target, "src/ui/theme/fonts.ts");
+    for (const p of [layoutPath, fontsPath]) {
+        if (!fileExists(p)) {
+            throw new Error(`patchLayout: ${p} missing — was applyBase run first?`);
+        }
+        const before = fs.readFileSync(p, "utf8");
+        const after = applySentinels(before, replacements, p);
+        fs.writeFileSync(p, after);
+    }
+}
+// ---------- package.json scripts (Phase 7 step 1) ----------
+export function patchPackageJsonScripts(target) {
+    const p = path.join(target, "package.json");
+    const pkg = readJson(p);
+    pkg.scripts ??= {};
+    const want = {
+        start: "expo start",
+        android: "expo start --android",
+        ios: "expo start --ios",
+        web: "expo start --web",
+        lint: "expo lint",
+    };
+    for (const [k, v] of Object.entries(want)) {
+        if (!(k in pkg.scripts))
+            pkg.scripts[k] = v;
+    }
+    writeJson(p, pkg);
+}
+/**
+ * SPEC §9 path aliases.
+ * `@/*` is a catchall resolving to `src/*`; longer specifics map to their
+ * concrete dirs. Identity-mirrored from MyRoster naming so mirrored imports
+ * resolve unchanged in the generated app.
+ */
+const SPEC_PATHS = {
+    "@/*": ["src/*"],
+    "@theme/*": ["src/ui/theme/*"],
+    "@utils/*": ["src/core/utils/*"],
+    "@redux/*": ["src/core/redux/*"],
+    "@core/*": ["src/core/*"],
+    "@services/*": ["src/core/services/*"],
+    "@hooks/*": ["src/core/hooks/*"],
+    "@appComponents/*": ["src/ui/appComponents/*"],
+    "@components/*": ["src/ui/components/*"],
+    "@icons/*": ["src/ui/iconComponents/*"],
+    "@features/*": ["src/features/*"],
+    "@assets": ["assets"],
+};
+/**
+ * Phase 7 step 3 — patch tsconfig:
+ *   - Preserve `extends: "expo/tsconfig.base"`.
+ *   - baseUrl resolution (3-tier):
+ *       1. user already set → preserve.
+ *       2. expo/tsconfig.base provides one (Phase 0 probe `EXPO_TSCONFIG_BASEURL` ≠ null) → no-op.
+ *       3. else → set "." here.
+ *   - Deep-merge `compilerOptions.paths` with SPEC §9 aliases; preserve user's existing aliases.
+ *   - Detect `@/*` collision (user already mapped `@/*` to non-`src/*` target) → warn + skip our `@/*`.
+ *
+ * `expoBaseUrlInherited` is read from Phase 0 SDK_NOTES at runtime by the caller.
+ */
+export function patchTsconfig(target, opts) {
+    const p = path.join(target, "tsconfig.json");
+    const ts = fileExists(p) ? readJson(p) : {};
+    if (!ts.extends)
+        ts.extends = "expo/tsconfig.base";
+    ts.compilerOptions ??= {};
+    // baseUrl 3-tier resolution.
+    const userBaseUrl = ts.compilerOptions.baseUrl;
+    if (!userBaseUrl && !opts.expoBaseUrlInherited) {
+        ts.compilerOptions.baseUrl = ".";
+    }
+    // paths deep-merge with collision detection.
+    ts.compilerOptions.paths ??= {};
+    for (const [alias, defaultTargets] of Object.entries(SPEC_PATHS)) {
+        if (alias in ts.compilerOptions.paths) {
+            // User-defined value — only warn on the `@/*` catchall collision case.
+            const existing = ts.compilerOptions.paths[alias];
+            if (alias === "@/*" && JSON.stringify(existing) !== JSON.stringify(defaultTargets)) {
+                log.warn(`tsconfig.json compilerOptions.paths["@/*"] already set to ${JSON.stringify(existing)}; preserving user value (template imports assume "src/*").`);
+            }
+            continue;
+        }
+        ts.compilerOptions.paths[alias] = defaultTargets;
+    }
+    writeJson(p, ts);
+}
+// ---------- babel.config.js (Phase 7 step 4) ----------
+// Implemented in src/babel.ts to keep AST plumbing in one file.
+// ---------- file copy helpers (for tests) ----------
+/** Copy a single file into the target dir (preserving relative path). */
+export function copyInto(target, srcAbs, relInside) {
+    const dst = path.join(target, relInside);
+    fse.ensureDirSync(path.dirname(dst));
+    fse.copySync(srcAbs, dst);
+}