codingpixel-expo-app 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 codingpixel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# `codingpixel-expo-app`
+
+Opinionated Expo SDK 54+ app scaffolder. Mirrors the [MyRoster](https://github.com/) project's component / redux / theme conventions; layers them on top of `create-expo-app`'s `blank-typescript` template; runs all native-dep installs through `expo install` so versions match the target SDK; ships a single lockfile (yarn OR npm — never both).
+
+## Quickstart
+
+```bash
+npx codingpixel-expo-app my-app
+cd my-app
+npx expo prebuild
+yarn ios       # or: npm run ios / yarn android / npm run android
+```
+
+The bin name is `codingpixel-expo` (used after global install). Invoke through `npx codingpixel-expo-app` (the package name) for one-shot runs.
+
+## Not Expo Go-compatible
+
+This template ships native modules that Expo Go can't load:
+
+- `react-native-mmkv` (redux-persist storage)
+- `react-native-gesture-handler`
+- `react-native-reanimated` (+ `react-native-worklets`)
+- `react-native-keyboard-controller`
+- `@gorhom/bottom-sheet` (when bottom-sheet support enabled)
+
+You **must** prebuild + run a custom dev-client:
+
+```bash
+npx expo prebuild
+yarn ios       # or yarn android / npm run ios / npm run android
+```
+
+Subsequent runs use the dev-client + bundler (`yarn start`).
+
+## Fonts
+
+Fonts are intentionally disabled in v0.1.x — generated `src/ui/theme/fonts.ts` exports `Fonts = {} as const` + `FontKey = never`, and `_layout.tsx` ships without `useFonts`. Apps that need custom fonts wire `expo-font` themselves (drop `.ttf`s into `assets/fonts/`, populate `Fonts`, add `useFonts(...)` + a loading guard in `_layout.tsx`).
+
+`expo-font` is already in `dependencies`, so no extra install is needed.
+
+## `@/*` alias
+
+The template overrides `expo/tsconfig.base`'s default by setting `@/*` → `src/*`. All MyRoster-style aliases (`@theme/*`, `@utils/*`, `@redux/*`, `@core/*`, `@services/*`, `@hooks/*`, `@appComponents/*`, `@components/*`, `@icons/*`, `@features/*`, `@assets`) resolve to their concrete dirs in `src/`. See `tsconfig.json` `compilerOptions.paths`.
+
+If your generated app's `tsconfig.json` already has a `@/*` mapping, the CLI preserves it + warns.
+
+## First-time dev-client build
+
+iOS:
+- Xcode + CocoaPods installed (`sudo gem install cocoapods` if missing).
+- `npx expo prebuild` then `yarn ios` (or `npm run ios`) — opens the iOS simulator with your custom dev-client.
+
+Android:
+- Android SDK + emulator running (or a USB-attached device with debugging enabled).
+- `JAVA_HOME` pointing at JDK 17.
+- `npx expo prebuild` then `yarn android` (or `npm run android`).
+
+## Expo SDK compatibility
+
+Built + tested against Expo SDK 54.x (probed via `docs/SDK_NOTES.md` at template-author time). Native dep versions are inherited at scaffold time via `expo install`, so subsequent SDK bumps update the deps without a CLI release.
+
+If `expo install` reports version-resolution failures, the CLI runs an isolation retry (`retryWithIsolation`) — drops the failing dep, retries the rest, and surfaces the failed name + verbatim Expo stderr at the end.
+
+## Environment variables (non-interactive runs)
+
+Required when stdin is not a TTY (e.g. slash-command flows).
+
+| Var | Type | Notes |
+|---|---|---|
+| `EXPO_INCLUDE_BOTTOM_SHEET` | `"0"` or `"1"` | Other values throw before any fs mutation. |
+| `EXPO_INCLUDE_IMAGE_PICKER` | `"0"` or `"1"` | Same. |
+| `EXPO_PACKAGE_MANAGER` | `"yarn"` or `"npm"` | Optional override; auto-detect otherwise. Other values throw. |
+
+`EXPO_PRIMARY_FONT` / `EXPO_SECONDARY_FONT` are silently ignored (fonts disabled — see "Fonts" above).
+
+## Bin name
+
+- npm package: `codingpixel-expo-app` (unscoped, public).
+- Bin: `codingpixel-expo`.
+- Run as `npx codingpixel-expo-app <dir>` (the package name) — `npx codingpixel-expo` only resolves after a `yarn global add` / `npm i -g` of this package.
+
+## Recovery from mid-run failures
+
+The CLI mutates `<target>` in place. If a patch throws partway through:
+
+1. **Patches are idempotent.** Fix the root cause (e.g. install missing PATH entry, retry network) and re-run the same command. The CLI converges.
+2. **Or:** `rm -rf <target>` and start fresh.
+
+The CLI **never** auto-deletes the target dir.
+
+## Contributing / publish
+
+```bash
+yarn install
+yarn build
+yarn test
+yarn audit:templates    # also runs as prepublishOnly
+```
+
+`prepublishOnly` chains `npm run build && npm run test && npm run audit:templates` — `audit:templates` greps mirrored files for unmapped MyRoster prefixes + Fonts-as-type misuse, blocking publish on stale audits. See `docs/MIRROR_NOTES.md` for the deviation log.
+
+Publish:
+
+```bash
+npm publish
+```
+
+(Unscoped packages publish public by default — no `--access` flag needed.)
+
+## License
+
+MIT.

package/bin/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import("../dist/index.js").catch((err) => {
+  if (err?.code === "ERR_MODULE_NOT_FOUND") {
+    console.error("Build artifacts missing. Did you run `yarn build`?");
+    process.exit(1);
+  }
+  console.error(err);
+  process.exit(1);
+});

package/dist/babel.js

@@ -0,0 +1,198 @@
+// Phase 7 step 4 — `babel.config.js` AST merge.
+//
+// Why AST + not regex:
+//   create-expo-app's default `babel.config.js` is a `module.exports = function`
+//   returning an object literal. We need to insert/dedup `plugins[]` entries
+//   while preserving comments, presets, env-conditional branches, etc. Regex
+//   gets fragile fast; AST is the only safe path.
+//
+// Why plugin order matters:
+//   reanimated/worklets plugin MUST be the LAST entry in `plugins[]` per
+//   upstream docs. `module-resolver` (when we insert it) goes at the FRONT
+//   so its presence can never displace the worklets last-slot reservation.
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import * as _traverseNS from "@babel/traverse";
+import * as _generateNS from "@babel/generator";
+import * as t from "@babel/types";
+import { fileExists, log } from "./util.js";
+// ESM/CJS interop — Node's ESM loader wraps CJS modules so @babel/traverse +
+// @babel/generator surface as `{ default: { default: <fn>, ...other } }` from
+// `import * as ns`. Unwrap up to two levels so the callable is reached
+// regardless of how the underlying CJS module is shaped (some Babel versions
+// expose the function directly on .default; newer ones nest one level deeper).
+function unwrap(ns) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let cur = ns;
+    for (let i = 0; i < 3; i++) {
+        if (typeof cur === "function")
+            return cur;
+        if (cur && typeof cur.default !== "undefined") {
+            cur = cur.default;
+            continue;
+        }
+        break;
+    }
+    return cur;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = unwrap(_traverseNS);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const generate = unwrap(_generateNS);
+const isWorklets = (entry) => {
+    const name = nameOfEntry(entry);
+    return /^react-native-worklets(-core)?\/plugin$/.test(name);
+};
+const isModuleResolver = (entry) => nameOfEntry(entry) === "module-resolver";
+function nameOfEntry(entry) {
+    if (Array.isArray(entry))
+        return String(entry[0]);
+    return String(entry);
+}
+/** Get the string name from an AST plugin entry (string literal or array literal whose first elem is a string). */
+function pluginEntryName(node) {
+    if (t.isStringLiteral(node))
+        return node.value;
+    if (t.isArrayExpression(node)) {
+        const first = node.elements[0];
+        if (first && t.isStringLiteral(first))
+            return first.value;
+    }
+    return "";
+}
+/** Build an AST node for `["module-resolver", { alias: <map> }]`. */
+function buildModuleResolverEntry(aliasMap) {
+    const aliasObject = t.objectExpression(Object.entries(aliasMap).map(([from, to]) => t.objectProperty(t.stringLiteral(from), t.stringLiteral(to))));
+    return t.arrayExpression([
+        t.stringLiteral("module-resolver"),
+        t.objectExpression([t.objectProperty(t.identifier("alias"), aliasObject)]),
+    ]);
+}
+/**
+ * Patch `<target>/babel.config.js`. Idempotent. Throws on parse failure or on
+ * unsupported config form (e.g. .ts/.cjs/.mjs only).
+ */
+export function patchBabel(target, opts) {
+    // File-extension detection: .ts/.cjs/.mjs without .js → unsupported.
+    const jsPath = path.join(target, "babel.config.js");
+    for (const alt of ["babel.config.ts", "babel.config.cjs", "babel.config.mjs"]) {
+        if (fileExists(path.join(target, alt)) && !fileExists(jsPath)) {
+            throw new Error(`manual babel config (${alt}) not yet supported — patchBabel handles babel.config.js only.`);
+        }
+    }
+    // Deviation #8 (docs/MIRROR_NOTES.md): SDK 54 blank-typescript no longer
+    // ships `babel.config.js` — preset-only via expo-router auto-config.
+    // Create the minimal stub here; patcher AST below then layers our entries on top.
+    if (!fileExists(jsPath)) {
+        const stub = `module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+    plugins: [],
+  };
+};
+`;
+        fs.writeFileSync(jsPath, stub);
+        log.step("babel.config.js missing — wrote default stub before patching.");
+    }
+    const source = fs.readFileSync(jsPath, "utf8");
+    const ast = parse(source, {
+        sourceType: "script", // create-expo-app default is CJS module.exports
+        plugins: [],
+    });
+    // Locate the returned ObjectExpression (return value of the exported function).
+    // `let configObj: any` so traverse-callback assignments don't trip TS narrowing.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let configObj = null;
+    traverse(ast, {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ReturnStatement(p) {
+            if (configObj)
+                return;
+            const arg = p.node.argument;
+            if (arg && t.isObjectExpression(arg)) {
+                configObj = arg;
+                p.stop();
+            }
+        },
+    });
+    if (!configObj) {
+        // Fallback: top-level `module.exports = { ... }` form (no function wrapper).
+        traverse(ast, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            AssignmentExpression(p) {
+                if (configObj)
+                    return;
+                if (t.isMemberExpression(p.node.left) &&
+                    t.isIdentifier(p.node.left.object, { name: "module" }) &&
+                    t.isIdentifier(p.node.left.property, { name: "exports" }) &&
+                    t.isObjectExpression(p.node.right)) {
+                    configObj = p.node.right;
+                    p.stop();
+                }
+            },
+        });
+    }
+    if (!configObj) {
+        throw new Error("patchBabel: could not locate config ObjectExpression in babel.config.js");
+    }
+    const config = configObj;
+    // Find or create `plugins` property.
+    let pluginsProp = config.properties.find((p) => t.isObjectProperty(p) &&
+        ((t.isIdentifier(p.key) && p.key.name === "plugins") ||
+            (t.isStringLiteral(p.key) && p.key.value === "plugins")));
+    if (!pluginsProp) {
+        pluginsProp = t.objectProperty(t.identifier("plugins"), t.arrayExpression([]));
+        config.properties.push(pluginsProp);
+    }
+    if (!t.isArrayExpression(pluginsProp.value)) {
+        throw new Error("patchBabel: plugins is not an array literal — cannot patch.");
+    }
+    const plugins = pluginsProp.value;
+    // ----- Step 0: decision prelude -----
+    const namesOnly = plugins.elements
+        .filter((e) => e !== null)
+        .map(pluginEntryName);
+    const moduleResolverPresent = namesOnly.includes("module-resolver");
+    const moduleResolverIsLast = namesOnly.length > 0 && namesOnly[namesOnly.length - 1] === "module-resolver";
+    const workletsPresent = namesOnly.some((n) => /^react-native-worklets(-core)?\/plugin$/.test(n));
+    const workletsNeedsInsertion = !opts.workletsAutoIncluded && !workletsPresent;
+    // ----- Step A: module-resolver -----
+    if (moduleResolverIsLast && workletsNeedsInsertion) {
+        throw new Error("module-resolver cannot occupy the final plugin slot when worklets plugin is required; " +
+            "please reorder babel.config.js plugins manually.");
+    }
+    if (!moduleResolverPresent) {
+        plugins.elements.unshift(buildModuleResolverEntry(opts.aliasMap));
+    }
+    // ----- Step B: worklets -----
+    if (workletsNeedsInsertion) {
+        plugins.elements.push(t.stringLiteral(`${opts.workletsPkg}/plugin`));
+    }
+    // ----- Step C: post-patch invariant assert with user-mutation tolerance -----
+    const finalNames = plugins.elements
+        .filter((e) => e !== null)
+        .map(pluginEntryName);
+    const workletsIdx = finalNames.findIndex((n) => /^react-native-worklets(-core)?\/plugin$/.test(n));
+    if (workletsIdx !== -1 && workletsIdx !== finalNames.length - 1) {
+        const trailing = finalNames.slice(workletsIdx + 1);
+        const OURS = new Set(["module-resolver"]);
+        const oursAfter = trailing.filter((n) => OURS.has(n));
+        const userAfter = trailing.filter((n) => !OURS.has(n));
+        if (oursAfter.length > 0) {
+            throw new Error(`babel.config.js: our patch corrupted plugin order — worklets must be last. ` +
+                `Offending trailing entries from our patch: ${oursAfter.join(", ")}`);
+        }
+        if (userAfter.length > 0) {
+            log.warn(`babel.config.js: plugin(s) [${userAfter.join(", ")}] appear after worklets — ` +
+                `reanimated requires worklets last; please reorder.`);
+        }
+    }
+    // Regenerate.
+    const out = generate(ast, { retainLines: false, comments: true }, source).code;
+    fs.writeFileSync(jsPath, out + (out.endsWith("\n") ? "" : "\n"));
+    // sanity: also verify the runtime predicates still match what we computed.
+    void isWorklets;
+    void isModuleResolver;
+}

package/dist/bootstrap.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import prompts from "prompts";
+import { dirExists, ensureDir, fileExists, isDirEmpty } from "./util.js";
+/**
+ * Resolve the target directory + app name from a positional CLI arg.
+ *
+ * Modes (per PLAN_V5.md Phase 1):
+ *   - `arg === undefined | ""` → prompt for name; recurse with answer.
+ *   - `arg === "."`            → use cwd. Throws if `package.json` already present.
+ *   - `arg` non-empty          → join with cwd, mkdir -p; throws if non-empty.
+ *
+ * Hard rejects (security + clarity):
+ *   - Absolute paths (Phase 1 step 2).
+ *   - `..`-traversal (Phase 1 step 2).
+ */
+export async function resolveTargetDir(arg) {
+    // Empty-arg branch — prompt then recurse.
+    if (arg === undefined || arg === "") {
+        if (!process.stdin.isTTY) {
+            throw new Error('No app name provided and stdin is not a TTY. Pass a directory: `codingpixel-expo my-app`.');
+        }
+        const ans = await prompts({
+            type: "text",
+            name: "name",
+            message: "App name?",
+            validate: (v) => (v.trim() === "" ? "Required" : true),
+        });
+        if (!ans.name)
+            throw new Error("Aborted.");
+        return resolveTargetDir(String(ans.name).trim());
+    }
+    // Reject absolute paths + ..-traversal BEFORE any path math.
+    if (path.isAbsolute(arg)) {
+        throw new Error(`Absolute paths not allowed: "${arg}". Use a directory name relative to cwd.`);
+    }
+    if (arg.split(/[/\\]/).some((seg) => seg === "..")) {
+        throw new Error(`Path traversal not allowed: "${arg}". Use a name relative to cwd.`);
+    }
+    // Current-dir branch.
+    if (arg === ".") {
+        const cwd = process.cwd();
+        if (fileExists(path.join(cwd, "package.json"))) {
+            throw new Error(`Refusing to scaffold into "." — package.json already present in ${cwd}.`);
+        }
+        return { dir: cwd, name: path.basename(cwd) };
+    }
+    // Named-dir branch.
+    const dir = path.join(process.cwd(), arg);
+    if (dirExists(dir) && !isDirEmpty(dir)) {
+        throw new Error(`Target directory not empty: ${dir}`);
+    }
+    ensureDir(dir);
+    return { dir, name: path.basename(dir) };
+}

package/dist/fonts.js

@@ -0,0 +1,98 @@
+// Phase 6 generators. All return strings to be spliced into sentinel positions.
+// Decision-locked: fonts type is object literal `as const` + `FontKey`
+// (NOT TS `enum` — Babel-unsafe under Hermes).
+/**
+ * Build the `Fonts` object literal + `FontKey` type. Family naming convention:
+ *   - `<FontName>-Regular` (always)
+ *   - `<FontName>-Medium`, `-SemiBold`, `-Bold` (always)
+ *   - if `secondary` non-empty: also `<SecondaryName>-Regular`, etc. as
+ *     `SECONDARY_REGULAR`, `SECONDARY_MEDIUM`, `SECONDARY_SEMIBOLD`, `SECONDARY_BOLD`
+ *
+ * Empty `primary` → `Fonts = {}` + `FontKey = never` (apps using `Fonts.X` will
+ * fail to typecheck; intended — user opted out).
+ */
+export function generateFontsObject(primary, secondary) {
+    const out = [];
+    out.push("export const Fonts = {");
+    if (primary) {
+        out.push(`  REGULAR: "${primary}-Regular",`);
+        out.push(`  MEDIUM: "${primary}-Medium",`);
+        out.push(`  SEMIBOLD: "${primary}-SemiBold",`);
+        out.push(`  BOLD: "${primary}-Bold",`);
+    }
+    if (secondary) {
+        out.push(`  SECONDARY_REGULAR: "${secondary}-Regular",`);
+        out.push(`  SECONDARY_MEDIUM: "${secondary}-Medium",`);
+        out.push(`  SECONDARY_SEMIBOLD: "${secondary}-SemiBold",`);
+        out.push(`  SECONDARY_BOLD: "${secondary}-Bold",`);
+    }
+    out.push("} as const;");
+    out.push("");
+    out.push("export type FontKey = keyof typeof Fonts;");
+    return out.join("\n");
+}
+/**
+ * Build the three pieces inserted into `_layout.tsx`:
+ *   - import line(s) for `useFonts` + the asset .ttf require()s
+ *   - the `useFonts(...)` hook call (must be inside the component body)
+ *   - the `if (!loaded) return null;` guard (also inside component body, after
+ *     the hook so React's rules-of-hooks stay satisfied)
+ *
+ * Empty `primary` → all three return empty strings → sentinel lines drop.
+ */
+export function generateUseFontsBlocks(primary, secondary) {
+    if (!primary) {
+        return { importBlock: "", hookBlock: "", guardBlock: "" };
+    }
+    const fontPairs = [
+        [`${primary}-Regular`, `${primary}-Regular.ttf`],
+        [`${primary}-Medium`, `${primary}-Medium.ttf`],
+        [`${primary}-SemiBold`, `${primary}-SemiBold.ttf`],
+        [`${primary}-Bold`, `${primary}-Bold.ttf`],
+    ];
+    if (secondary) {
+        fontPairs.push([`${secondary}-Regular`, `${secondary}-Regular.ttf`], [`${secondary}-Medium`, `${secondary}-Medium.ttf`], [`${secondary}-SemiBold`, `${secondary}-SemiBold.ttf`], [`${secondary}-Bold`, `${secondary}-Bold.ttf`]);
+    }
+    const importBlock = `import { useFonts } from "expo-font";`;
+    const mapEntries = fontPairs
+        .map(([key, file]) => `    "${key}": require("../../assets/fonts/${file}"),`)
+        .join("\n");
+    const hookBlock = `  const [loaded] = useFonts({\n${mapEntries}\n  });`;
+    const guardBlock = `  if (!loaded) return null;`;
+    return { importBlock, hookBlock, guardBlock };
+}
+/**
+ * Build the three pieces wrapping the routing tree with `BottomSheetModalProvider`:
+ *   - import line for `BottomSheetModalProvider`
+ *   - opening JSX
+ *   - closing JSX
+ *
+ * `bottomSheet === false` → all three empty → sentinel lines drop.
+ */
+export function generateBottomSheetProviderBlocks(bottomSheet) {
+    if (!bottomSheet) {
+        return { importBlock: "", openBlock: "", closeBlock: "" };
+    }
+    return {
+        importBlock: `import { BottomSheetModalProvider } from "@gorhom/bottom-sheet";`,
+        openBlock: `                <BottomSheetModalProvider>`,
+        closeBlock: `                </BottomSheetModalProvider>`,
+    };
+}
+/**
+ * Convenience: build the full sentinel-replacement map for `patchLayout`.
+ * Includes both layout sentinels and the fonts.ts sentinel.
+ */
+export function buildLayoutReplacements(answers) {
+    const fonts = generateUseFontsBlocks(answers.primaryFont, answers.secondaryFont);
+    const bs = generateBottomSheetProviderBlocks(answers.bottomSheet);
+    return {
+        USE_FONTS_IMPORT: fonts.importBlock,
+        USE_FONTS_HOOK: fonts.hookBlock,
+        USE_FONTS_GUARD: fonts.guardBlock,
+        BOTTOM_SHEET_PROVIDER_IMPORT: bs.importBlock,
+        BOTTOM_SHEET_PROVIDER_OPEN: bs.openBlock,
+        BOTTOM_SHEET_PROVIDER_CLOSE: bs.closeBlock,
+        FONTS_OBJECT: generateFontsObject(answers.primaryFont, answers.secondaryFont),
+    };
+}

package/dist/index.js

@@ -0,0 +1,120 @@
+// Entry point. Order per PLAN_V5.md (consolidated v5-r6):
+//   validateEnvVars
+//   → resolveTargetDir
+//   → runCreateExpoApp + cleanupBlankTemplate
+//   → gatherAnswers
+//   → applyBase + applyBottomSheet + applyImagePicker
+//   → patchAppJson + patchExpoRouterEntry + patchAppJsonPlugins
+//   → patchConstants + patchLayout
+//   → patchPackageJsonScripts + patchTsconfig + patchBabel
+//   → installNativeDeps
+//   → ensureLockfile
+//   → success message
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveTargetDir } from "./bootstrap.js";
+import { gatherAnswers, validateEnvVars } from "./prompts.js";
+import { cleanupBlankTemplate, runCreateExpoApp } from "./scaffold.js";
+import { applyBase, applyBottomSheet, applyImagePicker } from "./overlay.js";
+import { patchAppJson, patchAppJsonPlugins, patchConstants, patchExpoRouterEntry, patchLayout, patchPackageJsonScripts, patchTsconfig, } from "./patch.js";
+import { patchBabel } from "./babel.js";
+import { buildLayoutReplacements } from "./fonts.js";
+import { ensureLockfile, installNativeDeps } from "./install.js";
+import { log } from "./util.js";
+import { readSDKNotes } from "./sdkNotes.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Locate `templates/` directory. In the published package layout, it sits at
+ * `<pkgRoot>/templates/`; this file lives at `<pkgRoot>/dist/index.js`. So one
+ * level up from `dist/` reaches the package root.
+ */
+function resolveTemplatesRoot() {
+    return path.resolve(__dirname, "..", "templates");
+}
+/**
+ * Locate `docs/SDK_NOTES.md`. Same layout assumption as `resolveTemplatesRoot`.
+ */
+function resolveSdkNotesPath() {
+    return path.resolve(__dirname, "..", "docs", "SDK_NOTES.md");
+}
+async function main() {
+    validateEnvVars();
+    const arg = process.argv[2];
+    const target = await resolveTargetDir(arg);
+    log.info(`Target dir: ${target.dir}`);
+    log.info(`App name:   ${target.name}`);
+    await runCreateExpoApp(target.dir, target.name);
+    cleanupBlankTemplate(target.dir);
+    const answers = await gatherAnswers();
+    log.info(`Answers: primaryFont="${answers.primaryFont}" secondaryFont="${answers.secondaryFont}" ` +
+        `bottomSheet=${answers.bottomSheet} imagePicker=${answers.imagePicker} pm=${answers.packageManager}`);
+    // ---- Apply templates ----
+    const templatesRoot = resolveTemplatesRoot();
+    log.step("Overlaying templates/base/ …");
+    applyBase(target.dir, templatesRoot);
+    if (answers.bottomSheet) {
+        log.step("Overlaying templates/bottom-sheet/ …");
+        applyBottomSheet(target.dir, templatesRoot);
+    }
+    if (answers.imagePicker) {
+        log.step("Overlaying templates/image-picker/ …");
+        applyImagePicker(target.dir, templatesRoot);
+    }
+    // ---- Patches ----
+    log.step("Patching app.json + expo-router entry …");
+    patchAppJson(target.dir, target.name, answers);
+    patchExpoRouterEntry(target.dir);
+    patchAppJsonPlugins(target.dir, answers);
+    log.step("Splicing constants + layout sentinels …");
+    patchConstants(target.dir, templatesRoot, answers);
+    patchLayout(target.dir, buildLayoutReplacements(answers));
+    // ---- Read SDK_NOTES.md probe outcomes ----
+    const sdk = readSDKNotes(resolveSdkNotesPath());
+    const flagsOk = sdk.get("FLAGS_OK") === "1";
+    const probePass = sdk.get("PROBE_PASS") === "1";
+    const workletsAutoIncluded = sdk.get("BABEL_PRESET_AUTO_INCLUDES_WORKLETS") === "1";
+    const workletsPkg = sdk.get("WORKLETS_PKG") === "react-native-worklets-core"
+        ? "react-native-worklets-core"
+        : "react-native-worklets";
+    const expoBaseUrlInherited = sdk.get("EXPO_TSCONFIG_BASEURL") !== "null";
+    log.step("Patching package.json scripts + tsconfig + babel.config.js …");
+    patchPackageJsonScripts(target.dir);
+    patchTsconfig(target.dir, { expoBaseUrlInherited });
+    patchBabel(target.dir, {
+        workletsAutoIncluded,
+        workletsPkg,
+        aliasMap: {
+            "@": "./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",
+        },
+    });
+    // ---- Install + verify ----
+    await installNativeDeps(target.dir, answers, { flagsOk, workletsPkg });
+    const lockOutcome = await ensureLockfile(target.dir, answers, { probePass, flagsOk });
+    // ---- Success ----
+    const cmdPm = lockOutcome.producedPm === "yarn" ? "yarn" : "npm run";
+    log.success(`Project ready at ${target.dir}`);
+    log.raw("");
+    log.raw(`  cd ${path.relative(process.cwd(), target.dir) || target.name}`);
+    log.raw(`  npx expo prebuild`);
+    log.raw(`  ${cmdPm} ios       # or: ${cmdPm} android`);
+    log.raw("");
+    log.info("First-time dev-client build details: README → 'First-time dev-client build'.");
+}
+main().catch((err) => {
+    log.error(err instanceof Error ? err.message : String(err));
+    log.warn("If the failure is mid-patch, the target dir may be in an inconsistent state. " +
+        "Re-run the CLI (patches are idempotent and will converge), or `rm -rf <path>` and start fresh.");
+    process.exit(1);
+});