@symbiote-native/cli 0.1.2 → 0.2.1

package/bundle.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { styleText } from "node:util";
 import process$1, { stdin, stdout } from "node:process";
 import l__default from "node:readline";
-import * as fs from "node:fs";
+import * as fs$1 from "node:fs";
 import { readFileSync } from "node:fs";
-import * as path from "node:path";
+import * as path$1 from "node:path";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -29,6 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
 //#region src/errors.ts
 var import_picocolors = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -119,6 +122,32 @@ const EXPO_PACKAGE_LAYERS = [
 		label: "Application info",
 		symbiotePackage: "@symbiote-native/application"
 	},
+	{
+		id: "audio",
+		label: "Audio",
+		symbiotePackage: "@symbiote-native/audio",
+		optionalManifestBundles: [{
+			id: "recording",
+			label: "Background audio recording",
+			warning: "Requesting FOREGROUND_SERVICE_MICROPHONE triggers Play Console policy review — Google requires a clear, prominent in-app disclosure and justification before you can publish.",
+			nextSteps: "Pass `allowsBackgroundRecording: true` to setAudioModeAsync so recording keeps running with the app backgrounded.",
+			manifestPermissions: ["android.permission.FOREGROUND_SERVICE_MICROPHONE", "android.permission.POST_NOTIFICATIONS"],
+			manifestServices: [{
+				name: "expo.modules.audio.service.AudioRecordingService",
+				foregroundServiceType: "microphone"
+			}]
+		}]
+	},
+	{
+		id: "background-fetch",
+		label: "Background fetch",
+		symbiotePackage: "@symbiote-native/background-fetch"
+	},
+	{
+		id: "background-task",
+		label: "Background task",
+		symbiotePackage: "@symbiote-native/background-task"
+	},
 	{
 		id: "battery",
 		label: "Battery",
@@ -149,6 +178,11 @@ const EXPO_PACKAGE_LAYERS = [
 		label: "Device info",
 		symbiotePackage: "@symbiote-native/device"
 	},
+	{
+		id: "file-system",
+		label: "File system",
+		symbiotePackage: "@symbiote-native/file-system"
+	},
 	{
 		id: "haptics",
 		label: "Haptics",
@@ -169,11 +203,37 @@ const EXPO_PACKAGE_LAYERS = [
 		label: "Localization",
 		symbiotePackage: "@symbiote-native/localization"
 	},
+	{
+		id: "location",
+		label: "Location",
+		symbiotePackage: "@symbiote-native/location",
+		optionalManifestBundles: [{
+			id: "background",
+			label: "Background location tracking",
+			warning: "Requesting ACCESS_BACKGROUND_LOCATION and the location foreground-service permissions triggers Play Console policy review — Google requires a clear, prominent in-app disclosure and justification before you can publish.",
+			nextSteps: "Pass a `foregroundService` option to `startLocationUpdatesAsync` (notification title/body) so the OS keeps tracking alive outside the app. expo-location's own LocationTaskService is already declared in its AndroidManifest.xml and merges automatically — this only adds the permissions it needs.",
+			manifestPermissions: [
+				"android.permission.ACCESS_BACKGROUND_LOCATION",
+				"android.permission.FOREGROUND_SERVICE",
+				"android.permission.FOREGROUND_SERVICE_LOCATION"
+			]
+		}]
+	},
+	{
+		id: "media-library",
+		label: "Media library",
+		symbiotePackage: "@symbiote-native/media-library"
+	},
 	{
 		id: "network",
 		label: "Network info",
 		symbiotePackage: "@symbiote-native/network"
 	},
+	{
+		id: "notifications",
+		label: "Notifications",
+		symbiotePackage: "@symbiote-native/notifications"
+	},
 	{
 		id: "screen-orientation",
 		label: "Screen orientation",
@@ -199,6 +259,11 @@ const EXPO_PACKAGE_LAYERS = [
 		label: "SMS",
 		symbiotePackage: "@symbiote-native/sms"
 	},
+	{
+		id: "sqlite",
+		label: "SQLite",
+		symbiotePackage: "@symbiote-native/sqlite"
+	},
 	{
 		id: "standard-web-crypto",
 		label: "Web Crypto polyfill",
@@ -214,6 +279,11 @@ const EXPO_PACKAGE_LAYERS = [
 		label: "System UI",
 		symbiotePackage: "@symbiote-native/system-ui"
 	},
+	{
+		id: "task-manager",
+		label: "Task manager",
+		symbiotePackage: "@symbiote-native/task-manager"
+	},
 	{
 		id: "tracking-transparency",
 		label: "Tracking transparency",
@@ -229,6 +299,10 @@ const EXPO_PACKAGE_LAYER_IDS = new Set(EXPO_PACKAGE_LAYERS.map((layer) => layer.
 function isExpoPackageLayerName(value) {
 	return EXPO_PACKAGE_LAYER_IDS.has(value);
 }
+function expoPackagesWithOptionalManifestBundles(selected) {
+	const ids = selected instanceof Set ? selected : new Set(selected);
+	return EXPO_PACKAGE_LAYERS.filter((layer) => (layer.optionalManifestBundles?.length ?? 0) > 0 && ids.has(layer.id));
+}
 //#endregion
 //#region src/utils/suggest.ts
 function editDistance(a, b) {
@@ -336,7 +410,19 @@ function parseArgv(argv) {
 	const [command, ...rest] = argv;
 	if (command === void 0 || command === "--help" || command === "-h") return { kind: "help" };
 	if (command === "--version" || command === "-v") return { kind: "version" };
-	if (command !== "new" && command !== "add") throw usageErrorFor("command", command, ["new", "add"]);
+	if (command === "grant") {
+		const [layer, ...extra] = rest;
+		if (extra.length > 0) throw new CliUsageError(`"grant" takes at most one layer — got "${layer}" and "${extra[0]}".`);
+		return {
+			kind: "grant",
+			layer
+		};
+	}
+	if (command !== "new" && command !== "add") throw usageErrorFor("command", command, [
+		"new",
+		"add",
+		"grant"
+	]);
 	let appName;
 	let framework;
 	let vueFlavor;
@@ -744,7 +830,7 @@ function wrapAnsi(string, columns, options) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
-var import_src = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+var import_src$1 = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const ESC = "\x1B";
 	const CSI = `${ESC}[`;
 	const beep = "\x07";
@@ -973,9 +1059,9 @@ var V = class {
 				escapeCodeTimeout: 50,
 				terminal: true
 			}), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
-				this.output.write(import_src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
+				this.output.write(import_src$1.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(this.value);
 			}), this.once("cancel", () => {
-				this.output.write(import_src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+				this.output.write(import_src$1.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
 			});
 		});
 	}
@@ -1024,7 +1110,7 @@ var V = class {
 			trim: false
 		}).split(`
 `).length - 1;
-		this.output.write(import_src.cursor.move(-999, t * -1));
+		this.output.write(import_src$1.cursor.move(-999, t * -1));
 	}
 	render() {
 		const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
@@ -1032,7 +1118,7 @@ var V = class {
 			trim: false
 		});
 		if (t !== this._prevFrame) {
-			if (this.state === "initial") this.output.write(import_src.cursor.hide);
+			if (this.state === "initial") this.output.write(import_src$1.cursor.hide);
 			else {
 				const e = diffLines(this._prevFrame, t), i = getRows(this.output);
 				if (this.restoreCursor(), e) {
@@ -1043,18 +1129,18 @@ var V = class {
 						return;
 					}
 					if (e.lines.length === 1) {
-						this.output.write(import_src.cursor.move(0, r - s)), this.output.write(import_src.erase.lines(1));
+						this.output.write(import_src$1.cursor.move(0, r - s)), this.output.write(import_src$1.erase.lines(1));
 						const o = t.split(`
 `);
-						this.output.write(o[r]), this._prevFrame = t, this.output.write(import_src.cursor.move(0, o.length - r - 1));
+						this.output.write(o[r]), this._prevFrame = t, this.output.write(import_src$1.cursor.move(0, o.length - r - 1));
 						return;
 					} else if (e.lines.length > 1) {
 						if (n < s) r = n;
 						else {
 							const h = r - s;
-							h > 0 && this.output.write(import_src.cursor.move(0, h));
+							h > 0 && this.output.write(import_src$1.cursor.move(0, h));
 						}
-						this.output.write(import_src.erase.down());
+						this.output.write(import_src$1.erase.down());
 						const f = t.split(`
 `).slice(r);
 						this.output.write(f.join(`
@@ -1062,7 +1148,7 @@ var V = class {
 						return;
 					}
 				}
-				this.output.write(import_src.erase.down());
+				this.output.write(import_src$1.erase.down());
 			}
 			this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
 		}
@@ -1079,7 +1165,7 @@ var r = class extends V {
 		super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
 			this.value = this._value;
 		}), this.on("confirm", (i) => {
-			this.output.write(import_src.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
+			this.output.write(import_src$1.cursor.move(0, -1)), this.value = i, this.state = "submit", this.close();
 		}), this.on("cursor", () => {
 			this.value = !this.value;
 		});
@@ -1255,6 +1341,11 @@ const S_RADIO_INACTIVE = unicodeOr("○", " ");
 const S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
 const S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
 const S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+const S_BAR_H = unicodeOr("─", "-");
+const S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+const S_CONNECT_LEFT = unicodeOr("├", "+");
+const S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+const S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
 const symbol = (o) => {
 	switch (o) {
 		case "initial":
@@ -1548,6 +1639,32 @@ const outro = (o = "", t) => {
 ${styleText("gray", S_BAR_END)}  ` : "";
 	i.write(`${e}${o}
 
+`);
+};
+const W$1 = (o) => o;
+const C = (o, e, s) => {
+	const a = {
+		hard: true,
+		trim: false
+	}, i = wrapAnsi(o, e, a).split(`
+`), c = i.reduce((n, t) => Math.max(fastStringWidth(t), n), 0);
+	return wrapAnsi(o, e - (i.map(s).reduce((n, t) => Math.max(fastStringWidth(t), n), 0) - c), a);
+};
+const note = (o = "", e = "", s) => {
+	const a = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c = s?.format ?? W$1, g = [
+		"",
+		...C(o, getColumns(a) - 6, c).split(`
+`).map(c),
+		""
+	], n = fastStringWidth(e), t = Math.max(g.reduce((m, F) => {
+		const O = fastStringWidth(F);
+		return O > m ? O : m;
+	}, 0), n) + 2, h = g.map((m) => `${styleText("gray", S_BAR)}  ${m}${" ".repeat(t - fastStringWidth(m))}${styleText("gray", S_BAR)}`).join(`
+`), T = i ? `${styleText("gray", S_BAR)}
+` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+	a.write(`${T}${styleText("green", S_STEP_SUBMIT)}  ${styleText("reset", e)} ${styleText("gray", S_BAR_H.repeat(Math.max(t - n - 1, 1)) + S_CORNER_TOP_RIGHT)}
+${h}
+${styleText("gray", l$1 + S_BAR_H.repeat(t + 2) + S_CORNER_BOTTOM_RIGHT)}
 `);
 };
 const SELECT_INSTRUCTIONS = [`${styleText("dim", "↑/↓")} to navigate`, `${styleText("dim", "Enter:")} confirm`];
@@ -1668,44 +1785,44 @@ const TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 	""
 ]);
 function replaceTextContent(filePath, identity) {
-	const content = fs.readFileSync(filePath, "utf8");
+	const content = fs$1.readFileSync(filePath, "utf8");
 	const replaced = content.split("com.canary").join(identity.bundleId).split("Canary").join(identity.nativeAppName);
-	if (replaced !== content) fs.writeFileSync(filePath, replaced);
+	if (replaced !== content) fs$1.writeFileSync(filePath, replaced);
 }
 function walkTextFiles(dir, identity) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		const entryPath = path.join(dir, entry.name);
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path$1.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			walkTextFiles(entryPath, identity);
 			continue;
 		}
-		if (TEXT_FILE_EXTENSIONS.has(path.extname(entry.name))) replaceTextContent(entryPath, identity);
+		if (TEXT_FILE_EXTENSIONS.has(path$1.extname(entry.name))) replaceTextContent(entryPath, identity);
 	}
 }
 function renameCanaryPaths(dir, nativeAppName) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory()) renameCanaryPaths(path.join(dir, entry.name), nativeAppName);
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory()) renameCanaryPaths(path$1.join(dir, entry.name), nativeAppName);
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
 		if (!entry.name.startsWith("Canary")) continue;
-		const from = path.join(dir, entry.name);
-		const to = path.join(dir, entry.name.replace("Canary", nativeAppName));
-		fs.renameSync(from, to);
+		const from = path$1.join(dir, entry.name);
+		const to = path$1.join(dir, entry.name.replace("Canary", nativeAppName));
+		fs$1.renameSync(from, to);
 	}
 }
 function moveAndroidPackageDir(javaSrcDir, bundleId) {
-	const oldDir = path.join(javaSrcDir, "com", "canary");
-	if (!fs.existsSync(oldDir)) return;
-	const newDir = path.join(javaSrcDir, ...bundleId.split("."));
-	fs.mkdirSync(path.dirname(newDir), { recursive: true });
-	fs.renameSync(oldDir, newDir);
-	const oldTopDir = path.join(javaSrcDir, "com");
-	if (fs.existsSync(oldTopDir) && fs.readdirSync(oldTopDir).length === 0) fs.rmdirSync(oldTopDir);
+	const oldDir = path$1.join(javaSrcDir, "com", "canary");
+	if (!fs$1.existsSync(oldDir)) return;
+	const newDir = path$1.join(javaSrcDir, ...bundleId.split("."));
+	fs$1.mkdirSync(path$1.dirname(newDir), { recursive: true });
+	fs$1.renameSync(oldDir, newDir);
+	const oldTopDir = path$1.join(javaSrcDir, "com");
+	if (fs$1.existsSync(oldTopDir) && fs$1.readdirSync(oldTopDir).length === 0) fs$1.rmdirSync(oldTopDir);
 }
 function applyAppIdentity(root, identity) {
 	walkTextFiles(root, identity);
-	const iosDir = path.join(root, "ios");
-	if (fs.existsSync(iosDir)) renameCanaryPaths(iosDir, identity.nativeAppName);
-	const androidAppSrc = path.join(root, "android", "app", "src");
-	if (fs.existsSync(androidAppSrc)) for (const sourceSet of fs.readdirSync(androidAppSrc)) moveAndroidPackageDir(path.join(androidAppSrc, sourceSet, "java"), identity.bundleId);
+	const iosDir = path$1.join(root, "ios");
+	if (fs$1.existsSync(iosDir)) renameCanaryPaths(iosDir, identity.nativeAppName);
+	const androidAppSrc = path$1.join(root, "android", "app", "src");
+	if (fs$1.existsSync(androidAppSrc)) for (const sourceSet of fs$1.readdirSync(androidAppSrc)) moveAndroidPackageDir(path$1.join(androidAppSrc, sourceSet, "java"), identity.bundleId);
 }
 //#endregion
 //#region src/utils/json.ts
@@ -1752,7 +1869,7 @@ function sortDependencies(packageJson) {
 //#endregion
 //#region src/utils/render-template.ts
 function readJsonObject(filePath) {
-	const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+	const parsed = JSON.parse(fs$1.readFileSync(filePath, "utf8"));
 	if (!isJsonObject(parsed)) throw new Error(`${filePath}: expected a JSON object`);
 	return parsed;
 }
@@ -1782,37 +1899,37 @@ function stripTypescriptInfix(filename) {
 }
 const DEFAULT_OPTIONS = { hasTypescript: true };
 function renderTemplate(src, dest, options = DEFAULT_OPTIONS) {
-	if (fs.statSync(src).isDirectory()) {
-		fs.mkdirSync(dest, { recursive: true });
-		for (const entry of fs.readdirSync(src)) renderTemplate(path.resolve(src, entry), path.resolve(dest, entry), options);
+	if (fs$1.statSync(src).isDirectory()) {
+		fs$1.mkdirSync(dest, { recursive: true });
+		for (const entry of fs$1.readdirSync(src)) renderTemplate(path$1.resolve(src, entry), path$1.resolve(dest, entry), options);
 		return;
 	}
-	const filename = path.basename(src);
+	const filename = path$1.basename(src);
 	if (filename === "README.md") return;
 	if (!options.hasTypescript && (isTypescriptOnlyFile(filename) || filename.includes(".typescript."))) return;
 	if (options.hasTypescript && isJavascriptOnlyFile(filename)) return;
 	const destFilename = filename.includes(".typescript.") ? stripTypescriptInfix(filename) : filename;
-	const resolvedDest = path.join(path.dirname(dest), destFilename);
+	const resolvedDest = path$1.join(path$1.dirname(dest), destFilename);
 	if (destFilename === "package.json.fragment.json") {
-		const destPackageJsonPath = path.resolve(path.dirname(resolvedDest), "package.json");
+		const destPackageJsonPath = path$1.resolve(path$1.dirname(resolvedDest), "package.json");
 		const fragment = readJsonObject(src);
-		const merged = sortDependencies(deepMerge(fs.existsSync(destPackageJsonPath) ? readJsonObject(destPackageJsonPath) : {}, fragment));
-		fs.writeFileSync(destPackageJsonPath, `${JSON.stringify(merged, null, 2)}\n`);
+		const merged = sortDependencies(deepMerge(fs$1.existsSync(destPackageJsonPath) ? readJsonObject(destPackageJsonPath) : {}, fragment));
+		fs$1.writeFileSync(destPackageJsonPath, `${JSON.stringify(merged, null, 2)}\n`);
 		return;
 	}
-	if (destFilename === ".gitignore" && fs.existsSync(resolvedDest)) {
-		const existing = fs.readFileSync(resolvedDest, "utf8");
-		const addition = fs.readFileSync(src, "utf8");
-		fs.writeFileSync(resolvedDest, `${existing}\n${addition}`);
+	if (destFilename === ".gitignore" && fs$1.existsSync(resolvedDest)) {
+		const existing = fs$1.readFileSync(resolvedDest, "utf8");
+		const addition = fs$1.readFileSync(src, "utf8");
+		fs$1.writeFileSync(resolvedDest, `${existing}\n${addition}`);
 		return;
 	}
-	fs.copyFileSync(src, resolvedDest);
+	fs$1.copyFileSync(src, resolvedDest);
 }
 //#endregion
 //#region src/utils/apply-bootsplash-logo.ts
 function applyBootsplashLogo(root, templatesRoot, framework) {
-	const overlayRoot = path.join(templatesRoot, "bootsplash-logo", framework);
-	if (fs.existsSync(overlayRoot)) renderTemplate(overlayRoot, root);
+	const overlayRoot = path$1.join(templatesRoot, "bootsplash-logo", framework);
+	if (fs$1.existsSync(overlayRoot)) renderTemplate(overlayRoot, root);
 }
 //#endregion
 //#region src/utils/apply-expo-modules-manifest.ts
@@ -1827,54 +1944,54 @@ const EXPO_MODULES_BACKUP_ATTRS = `android:supportsRtl="true"
     android:dataExtractionRules="@xml/secure_store_data_extraction_rules"
     android:fullBackupContent="@xml/secure_store_backup_rules">`;
 function applyExpoModulesAndroidManifest(root) {
-	const manifestPath = path.join(root, "android/app/src/main/AndroidManifest.xml");
-	const manifest = fs.readFileSync(manifestPath, "utf8");
+	const manifestPath = path$1.join(root, "android/app/src/main/AndroidManifest.xml");
+	const manifest = fs$1.readFileSync(manifestPath, "utf8");
 	const withPermissions = manifest.includes("USE_BIOMETRIC") ? manifest : manifest.replace("  <uses-permission android:name=\"android.permission.VIBRATE\" />", EXPO_MODULES_PERMISSIONS);
 	const withBackupAttrs = withPermissions.includes("dataExtractionRules") ? withPermissions : withPermissions.replace("android:supportsRtl=\"true\">", EXPO_MODULES_BACKUP_ATTRS);
-	fs.writeFileSync(manifestPath, withBackupAttrs);
+	fs$1.writeFileSync(manifestPath, withBackupAttrs);
 }
 //#endregion
 //#region src/utils/apply-expo-modules-podfile-autolinking.ts
 const AUTOLINKING_REQUIRE = "require File.join(File.dirname(`node --print \"require.resolve('expo/package.json')\"`), \"scripts/autolinking\")";
 const NATIVE_MODULES_LINE = "config = use_native_modules!";
 function applyExpoModulesPodfileAutolinking(root) {
-	const podfilePath = path.join(root, "ios", "Podfile");
-	if (!fs.existsSync(podfilePath)) return;
-	let podfile = fs.readFileSync(podfilePath, "utf8");
+	const podfilePath = path$1.join(root, "ios", "Podfile");
+	if (!fs$1.existsSync(podfilePath)) return;
+	let podfile = fs$1.readFileSync(podfilePath, "utf8");
 	if (podfile.includes("use_expo_modules!")) return;
 	if (!podfile.includes(AUTOLINKING_REQUIRE)) podfile = `${AUTOLINKING_REQUIRE}\n\n${podfile}`;
 	podfile = podfile.replace(NATIVE_MODULES_LINE, `${NATIVE_MODULES_LINE}\n\n  use_expo_modules!`);
-	fs.writeFileSync(podfilePath, podfile);
+	fs$1.writeFileSync(podfilePath, podfile);
 }
 //#endregion
 //#region src/utils/apply-expo-modules-podfile.ts
 const DEFAULT_PLATFORM_LINE = "platform :ios, min_ios_version_supported.to_s";
 const RAISED_PLATFORM_LINE = "platform :ios, [min_ios_version_supported.to_f, 16.4].max.to_s";
 function applyExpoModulesPodfilePlatform(root) {
-	const podfilePath = path.join(root, "ios", "Podfile");
-	if (!fs.existsSync(podfilePath)) return;
-	const podfile = fs.readFileSync(podfilePath, "utf8");
+	const podfilePath = path$1.join(root, "ios", "Podfile");
+	if (!fs$1.existsSync(podfilePath)) return;
+	const podfile = fs$1.readFileSync(podfilePath, "utf8");
 	if (!podfile.includes(DEFAULT_PLATFORM_LINE)) return;
-	fs.writeFileSync(podfilePath, podfile.replace(DEFAULT_PLATFORM_LINE, RAISED_PLATFORM_LINE));
+	fs$1.writeFileSync(podfilePath, podfile.replace(DEFAULT_PLATFORM_LINE, RAISED_PLATFORM_LINE));
 }
 //#endregion
 //#region src/utils/apply-expo-modules-xcode-deployment-target.ts
 const MIN_EXPO_IOS_VERSION = 16.4;
 const DEPLOYMENT_TARGET_LINE = /IPHONEOS_DEPLOYMENT_TARGET = (\d+(?:\.\d+)?);/g;
 function findPbxprojPath(root) {
-	const iosDir = path.join(root, "ios");
-	if (!fs.existsSync(iosDir)) return void 0;
-	const xcodeproj = fs.readdirSync(iosDir).find((entry) => entry.endsWith(".xcodeproj"));
+	const iosDir = path$1.join(root, "ios");
+	if (!fs$1.existsSync(iosDir)) return void 0;
+	const xcodeproj = fs$1.readdirSync(iosDir).find((entry) => entry.endsWith(".xcodeproj"));
 	if (!xcodeproj) return void 0;
-	const pbxprojPath = path.join(iosDir, xcodeproj, "project.pbxproj");
-	return fs.existsSync(pbxprojPath) ? pbxprojPath : void 0;
+	const pbxprojPath = path$1.join(iosDir, xcodeproj, "project.pbxproj");
+	return fs$1.existsSync(pbxprojPath) ? pbxprojPath : void 0;
 }
 function applyExpoModulesXcodeDeploymentTarget(root) {
 	const pbxprojPath = findPbxprojPath(root);
 	if (!pbxprojPath) return;
-	const pbxproj = fs.readFileSync(pbxprojPath, "utf8");
+	const pbxproj = fs$1.readFileSync(pbxprojPath, "utf8");
 	const raised = pbxproj.replace(DEPLOYMENT_TARGET_LINE, (line, version) => Number.parseFloat(version) < MIN_EXPO_IOS_VERSION ? `IPHONEOS_DEPLOYMENT_TARGET = ${MIN_EXPO_IOS_VERSION};` : line);
-	if (raised !== pbxproj) fs.writeFileSync(pbxprojPath, raised);
+	if (raised !== pbxproj) fs$1.writeFileSync(pbxprojPath, raised);
 }
 //#endregion
 //#region src/utils/apply-splash-screen-hide.ts
@@ -1891,8 +2008,8 @@ const APP_COMPONENT_FILENAMES = /* @__PURE__ */ new Set([
 	"App.svelte"
 ]);
 function findAppComponentFile(dir) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		const entryPath = path.join(dir, entry.name);
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path$1.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (SKIPPED_DIR_NAMES$1.has(entry.name)) continue;
 			const found = findAppComponentFile(entryPath);
@@ -1938,9 +2055,9 @@ function patchSvelte(source) {
 function applySplashScreenAppHide(root, options) {
 	const appFilePath = findAppComponentFile(root);
 	if (appFilePath === void 0) return;
-	const source = fs.readFileSync(appFilePath, "utf8");
+	const source = fs$1.readFileSync(appFilePath, "utf8");
 	if (/\bhide\(\)/.test(source)) return;
-	fs.writeFileSync(appFilePath, patch(source, options.framework, appFilePath));
+	fs$1.writeFileSync(appFilePath, patch(source, options.framework, appFilePath));
 }
 function patch(source, framework, appFilePath) {
 	switch (framework) {
@@ -1956,16 +2073,16 @@ function patch(source, framework, appFilePath) {
 const INLINE_STYLE_BLOCK_FRAMEWORKS = /* @__PURE__ */ new Set(["vue-sfc", "svelte"]);
 const STYLE_TAG_PATTERN = /<style(?=[ >])/;
 function addStyleLangAttribute(dir, lang) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		const entryPath = path.join(dir, entry.name);
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path$1.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (SKIPPED_DIR_NAMES.has(entry.name)) continue;
 			addStyleLangAttribute(entryPath, lang);
 			continue;
 		}
 		if (!entry.name.endsWith(".vue") && !entry.name.endsWith(".svelte")) continue;
-		const content = fs.readFileSync(entryPath, "utf8");
-		if (STYLE_TAG_PATTERN.test(content)) fs.writeFileSync(entryPath, content.replace(STYLE_TAG_PATTERN, `<style lang="${lang}"`));
+		const content = fs$1.readFileSync(entryPath, "utf8");
+		if (STYLE_TAG_PATTERN.test(content)) fs$1.writeFileSync(entryPath, content.replace(STYLE_TAG_PATTERN, `<style lang="${lang}"`));
 	}
 }
 const PREPROCESSOR_EXTENSIONS = {
@@ -1979,42 +2096,42 @@ const SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
 	"node_modules"
 ]);
 function findAppCssFile(dir) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
 		if (entry.isDirectory()) {
 			if (SKIPPED_DIR_NAMES.has(entry.name)) continue;
-			const found = findAppCssFile(path.join(dir, entry.name));
+			const found = findAppCssFile(path$1.join(dir, entry.name));
 			if (found !== void 0) return found;
 			continue;
 		}
-		if (entry.name === "App.css") return path.join(dir, entry.name);
+		if (entry.name === "App.css") return path$1.join(dir, entry.name);
 	}
 }
 function replaceInTextFiles(dir, from, to) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		const entryPath = path.join(dir, entry.name);
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path$1.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (SKIPPED_DIR_NAMES.has(entry.name)) continue;
 			replaceInTextFiles(entryPath, from, to);
 			continue;
 		}
-		const content = fs.readFileSync(entryPath, "utf8");
-		if (content.includes(from)) fs.writeFileSync(entryPath, content.split(from).join(to));
+		const content = fs$1.readFileSync(entryPath, "utf8");
+		if (content.includes(from)) fs$1.writeFileSync(entryPath, content.split(from).join(to));
 	}
 }
 function renameStylesheetExtension(root, extension) {
 	const cssFile = findAppCssFile(root);
 	if (cssFile === void 0) return;
-	fs.renameSync(cssFile, path.join(path.dirname(cssFile), `App.${extension}`));
+	fs$1.renameSync(cssFile, path$1.join(path$1.dirname(cssFile), `App.${extension}`));
 	replaceInTextFiles(root, "'./App.css'", `'./App.${extension}'`);
 }
 function applyStyling(root, options) {
 	const { styling, jsTemplateDir, hasNavigation, hasTypescript, templatesRoot } = options;
 	if (styling === "css") return;
 	if (styling === "css-modules" || styling === "stylesheet") {
-		renderTemplate(path.join(templatesRoot, "styling", "js", jsTemplateDir, styling), root, { hasTypescript });
-		if (hasNavigation) renderTemplate(path.join(templatesRoot, "styling", "navigation", jsTemplateDir, styling), root, { hasTypescript });
+		renderTemplate(path$1.join(templatesRoot, "styling", "js", jsTemplateDir, styling), root, { hasTypescript });
+		if (hasNavigation) renderTemplate(path$1.join(templatesRoot, "styling", "navigation", jsTemplateDir, styling), root, { hasTypescript });
 		const orphanedCss = findAppCssFile(root);
-		if (orphanedCss !== void 0) fs.rmSync(orphanedCss, { force: true });
+		if (orphanedCss !== void 0) fs$1.rmSync(orphanedCss, { force: true });
 		return;
 	}
 	if (INLINE_STYLE_BLOCK_FRAMEWORKS.has(jsTemplateDir)) {
@@ -2053,50 +2170,50 @@ var TargetDirNotEmptyError = class extends Error {
 	}
 };
 function resolveTemplatesRoot() {
-	const packageDir = path.dirname(fileURLToPath(import.meta.url));
-	const sibling = path.join(packageDir, "templates");
-	return fs.existsSync(sibling) ? sibling : path.resolve(packageDir, "../templates");
+	const packageDir = path$1.dirname(fileURLToPath(import.meta.url));
+	const sibling = path$1.join(packageDir, "templates");
+	return fs$1.existsSync(sibling) ? sibling : path$1.resolve(packageDir, "../templates");
 }
 const templatesRoot = resolveTemplatesRoot();
 function isEmptyDir(dir) {
-	if (!fs.existsSync(dir)) return true;
-	const entries = fs.readdirSync(dir);
+	if (!fs$1.existsSync(dir)) return true;
+	const entries = fs$1.readdirSync(dir);
 	return entries.length === 0 || entries.length === 1 && entries[0] === ".git";
 }
 function scaffoldApp(options) {
-	const root = path.resolve(process.cwd(), options.appName);
+	const root = path$1.resolve(process.cwd(), options.appName);
 	const jsTemplateDir = resolveJsTemplateDir(options.framework, options.vueFlavor);
 	if (!isEmptyDir(root)) throw new TargetDirNotEmptyError(root);
-	fs.mkdirSync(root, { recursive: true });
-	const packageNameSource = options.appName === "." ? path.basename(root) : options.appName;
-	fs.writeFileSync(path.join(root, "package.json"), `${JSON.stringify({
+	fs$1.mkdirSync(root, { recursive: true });
+	const packageNameSource = options.appName === "." ? path$1.basename(root) : options.appName;
+	fs$1.writeFileSync(path$1.join(root, "package.json"), `${JSON.stringify({
 		name: toValidPackageName(packageNameSource),
 		version: "0.0.1",
 		private: true
 	}, null, 2)}\n`);
-	renderTemplate(path.join(templatesRoot, "native"), root, { hasTypescript: options.hasTypescript });
-	renderTemplate(path.join(templatesRoot, "js", jsTemplateDir), root, { hasTypescript: options.hasTypescript });
+	renderTemplate(path$1.join(templatesRoot, "native"), root, { hasTypescript: options.hasTypescript });
+	renderTemplate(path$1.join(templatesRoot, "js", jsTemplateDir), root, { hasTypescript: options.hasTypescript });
 	applyBootsplashLogo(root, templatesRoot, options.framework);
 	const hasExpoModules = options.hasExpoModules || (options.expoPackages?.size ?? 0) > 0;
 	if (options.hasNavigation) {
-		const navigationLayerRoot = path.join(templatesRoot, "layers", "navigation");
-		renderTemplate(path.join(navigationLayerRoot, "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
-		renderTemplate(path.join(navigationLayerRoot, "app", jsTemplateDir), root, { hasTypescript: options.hasTypescript });
+		const navigationLayerRoot = path$1.join(templatesRoot, "layers", "navigation");
+		renderTemplate(path$1.join(navigationLayerRoot, "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
+		renderTemplate(path$1.join(navigationLayerRoot, "app", jsTemplateDir), root, { hasTypescript: options.hasTypescript });
 	}
-	if (hasExpoModules) renderTemplate(path.join(templatesRoot, "layers", "expo-modules"), root);
+	if (hasExpoModules) renderTemplate(path$1.join(templatesRoot, "layers", "expo-modules"), root);
 	if (options.hasSplashScreen) {
-		const splashScreenLayerRoot = path.join(templatesRoot, "layers", "splash-screen");
-		renderTemplate(path.join(splashScreenLayerRoot, "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
-		renderTemplate(path.join(splashScreenLayerRoot, "native"), root);
+		const splashScreenLayerRoot = path$1.join(templatesRoot, "layers", "splash-screen");
+		renderTemplate(path$1.join(splashScreenLayerRoot, "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
+		renderTemplate(path$1.join(splashScreenLayerRoot, "native"), root);
 	}
-	if (options.hasSlider) renderTemplate(path.join(templatesRoot, "layers", "slider", "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
-	for (const layerName of options.expoPackages ?? []) renderTemplate(path.join(templatesRoot, "layers", layerName, "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
+	if (options.hasSlider) renderTemplate(path$1.join(templatesRoot, "layers", "slider", "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
+	for (const layerName of options.expoPackages ?? []) renderTemplate(path$1.join(templatesRoot, "layers", layerName, "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
 	if (options.hasTesting) {
-		const testingLayerRoot = path.join(templatesRoot, "layers", "testing");
+		const testingLayerRoot = path$1.join(templatesRoot, "layers", "testing");
 		const fragmentName = options.framework === "angular" ? "angular" : "base";
-		renderTemplate(path.join(testingLayerRoot, "fragment", fragmentName, "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
-		renderTemplate(path.join(testingLayerRoot, "detox.config.js"), path.join(root, "detox.config.js"));
-		renderTemplate(path.join(testingLayerRoot, "e2e"), path.join(root, "e2e"), { hasTypescript: true });
+		renderTemplate(path$1.join(testingLayerRoot, "fragment", fragmentName, "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
+		renderTemplate(path$1.join(testingLayerRoot, "detox.config.js"), path$1.join(root, "detox.config.js"));
+		renderTemplate(path$1.join(testingLayerRoot, "e2e"), path$1.join(root, "e2e"), { hasTypescript: true });
 	}
 	if (hasExpoModules) {
 		applyExpoModulesAndroidManifest(root);
@@ -2121,9 +2238,9 @@ function scaffoldApp(options) {
 //#endregion
 //#region src/utils/find-ios-app-dir.ts
 function findIosAppDir(root) {
-	const iosDir = path.join(root, "ios");
-	if (!fs.existsSync(iosDir)) return void 0;
-	for (const entry of fs.readdirSync(iosDir, { withFileTypes: true })) if (entry.isDirectory() && entry.name !== "Pods") return path.join(iosDir, entry.name);
+	const iosDir = path$1.join(root, "ios");
+	if (!fs$1.existsSync(iosDir)) return void 0;
+	for (const entry of fs$1.readdirSync(iosDir, { withFileTypes: true })) if (entry.isDirectory() && entry.name !== "Pods") return path$1.join(iosDir, entry.name);
 }
 //#endregion
 //#region src/utils/apply-expo-modules-plist.ts
@@ -2135,14 +2252,14 @@ const USAGE_DESCRIPTIONS = [
 function applyExpoModulesInfoPlist(root) {
 	const iosAppDir = findIosAppDir(root);
 	if (iosAppDir === void 0) return;
-	const plistPath = path.join(iosAppDir, "Info.plist");
-	if (!fs.existsSync(plistPath)) return;
-	const plist = fs.readFileSync(plistPath, "utf8");
+	const plistPath = path$1.join(iosAppDir, "Info.plist");
+	if (!fs$1.existsSync(plistPath)) return;
+	const plist = fs$1.readFileSync(plistPath, "utf8");
 	const updated = USAGE_DESCRIPTIONS.reduce((current, [key, description]) => {
 		if (current.includes(`<key>${key}</key>`)) return current;
 		return current.replace("</dict>\n</plist>", `\t<key>${key}</key>\n\t<string>${description}</string>\n</dict>\n</plist>`);
 	}, plist);
-	if (updated !== plist) fs.writeFileSync(plistPath, updated);
+	if (updated !== plist) fs$1.writeFileSync(plistPath, updated);
 }
 //#endregion
 //#region src/utils/apply-splash-screen-app-delegate.ts
@@ -2151,9 +2268,9 @@ const REACT_IMPORT = "import React\n";
 function applySplashScreenAppDelegate(root) {
 	const iosAppDir = findIosAppDir(root);
 	if (iosAppDir === void 0) return;
-	const appDelegatePath = path.join(iosAppDir, "AppDelegate.swift");
-	if (!fs.existsSync(appDelegatePath)) return;
-	const source = fs.readFileSync(appDelegatePath, "utf8");
+	const appDelegatePath = path$1.join(iosAppDir, "AppDelegate.swift");
+	if (!fs$1.existsSync(appDelegatePath)) return;
+	const source = fs$1.readFileSync(appDelegatePath, "utf8");
 	if (source.includes("RNBootSplash.initWithStoryboard(")) return;
 	if (!source.includes(REACT_IMPORT)) return;
 	const updated = source.includes("import RNBootSplash") ? source : source.replace(REACT_IMPORT, `${REACT_IMPORT}import RNBootSplash\n`);
@@ -2162,13 +2279,13 @@ function applySplashScreenAppDelegate(root) {
   }
 
 `);
-	fs.writeFileSync(appDelegatePath, withInit);
+	fs$1.writeFileSync(appDelegatePath, withInit);
 }
 //#endregion
 //#region src/utils/apply-splash-screen-main-activity.ts
 function findMainActivityKt(dir) {
-	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-		const entryPath = path.join(dir, entry.name);
+	for (const entry of fs$1.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path$1.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			const found = findMainActivityKt(entryPath);
 			if (found !== void 0) return found;
@@ -2180,32 +2297,32 @@ function findMainActivityKt(dir) {
 const ONCREATE_OPEN = /override fun onCreate\(savedInstanceState: Bundle\?\) \{\n/;
 const REACT_ACTIVITY_IMPORT = "import com.facebook.react.ReactActivity\n";
 function applySplashScreenMainActivity(root) {
-	const javaDir = path.join(root, "android/app/src/main/java");
-	if (!fs.existsSync(javaDir)) return;
+	const javaDir = path$1.join(root, "android/app/src/main/java");
+	if (!fs$1.existsSync(javaDir)) return;
 	const mainActivityPath = findMainActivityKt(javaDir);
 	if (mainActivityPath === void 0) return;
-	const source = fs.readFileSync(mainActivityPath, "utf8");
+	const source = fs$1.readFileSync(mainActivityPath, "utf8");
 	if (source.includes("RNBootSplash.init(")) return;
 	if (!source.includes(REACT_ACTIVITY_IMPORT)) return;
 	let updated = source.includes("import com.zoontek.rnbootsplash.RNBootSplash") ? source : source.replace(REACT_ACTIVITY_IMPORT, `${REACT_ACTIVITY_IMPORT}import com.zoontek.rnbootsplash.RNBootSplash\n`);
 	if (!updated.includes("import android.os.Bundle")) updated = updated.replace(REACT_ACTIVITY_IMPORT, `import android.os.Bundle\n${REACT_ACTIVITY_IMPORT}`);
 	updated = ONCREATE_OPEN.test(updated) ? updated.replace(ONCREATE_OPEN, (match) => `${match}    RNBootSplash.init(this, R.style.BootTheme)\n`) : updated.replace("class MainActivity : ReactActivity() {\n", "class MainActivity : ReactActivity() {\n\n  override fun onCreate(savedInstanceState: Bundle?) {\n    RNBootSplash.init(this, R.style.BootTheme)\n    super.onCreate(savedInstanceState)\n  }\n");
-	fs.writeFileSync(mainActivityPath, updated);
+	fs$1.writeFileSync(mainActivityPath, updated);
 }
 //#endregion
 //#region src/utils/apply-splash-screen-manifest.ts
 const MAIN_ACTIVITY_BLOCK = /<activity\b[^>]*android:name="\.MainActivity"[^>]*>/;
 function applySplashScreenManifest(root) {
-	const manifestPath = path.join(root, "android/app/src/main/AndroidManifest.xml");
-	if (!fs.existsSync(manifestPath)) return;
-	const manifest = fs.readFileSync(manifestPath, "utf8");
+	const manifestPath = path$1.join(root, "android/app/src/main/AndroidManifest.xml");
+	if (!fs$1.existsSync(manifestPath)) return;
+	const manifest = fs$1.readFileSync(manifestPath, "utf8");
 	const match = manifest.match(MAIN_ACTIVITY_BLOCK);
 	if (match === null) return;
 	const block = match[0];
 	if (block.includes("@style/BootTheme")) return;
 	if (!block.includes("android:theme=\"@style/AppTheme\"")) return;
 	const updatedBlock = block.replace("android:theme=\"@style/AppTheme\"", "android:theme=\"@style/BootTheme\"");
-	fs.writeFileSync(manifestPath, manifest.replace(block, updatedBlock));
+	fs$1.writeFileSync(manifestPath, manifest.replace(block, updatedBlock));
 }
 //#endregion
 //#region src/utils/apply-splash-screen-styles.ts
@@ -2216,22 +2333,22 @@ const BOOT_THEME_STYLE = `    <style name="BootTheme" parent="Theme.BootSplash">
     </style>
 `;
 function applySplashScreenStyles(root) {
-	const stylesPath = path.join(root, "android/app/src/main/res/values/styles.xml");
-	if (!fs.existsSync(stylesPath)) return;
-	const styles = fs.readFileSync(stylesPath, "utf8");
+	const stylesPath = path$1.join(root, "android/app/src/main/res/values/styles.xml");
+	if (!fs$1.existsSync(stylesPath)) return;
+	const styles = fs$1.readFileSync(stylesPath, "utf8");
 	if (styles.includes("name=\"BootTheme\"")) return;
 	if (!styles.includes("</resources>")) return;
-	fs.writeFileSync(stylesPath, styles.replace("</resources>", `${BOOT_THEME_STYLE}</resources>`));
+	fs$1.writeFileSync(stylesPath, styles.replace("</resources>", `${BOOT_THEME_STYLE}</resources>`));
 }
 //#endregion
 //#region src/add-layers.ts
 function applyDependencyOnlyLayer(root, layerName) {
-	renderTemplate(path.join(templatesRoot, "layers", layerName, "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
+	renderTemplate(path$1.join(templatesRoot, "layers", layerName, "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
 }
 function applyExpoModulesLayer(root) {
 	applyDependencyOnlyLayer(root, "expo-modules");
-	if (fs.existsSync(path.join(root, "android/app/src/main/AndroidManifest.xml"))) applyExpoModulesAndroidManifest(root);
-	if (fs.existsSync(path.join(root, "ios"))) {
+	if (fs$1.existsSync(path$1.join(root, "android/app/src/main/AndroidManifest.xml"))) applyExpoModulesAndroidManifest(root);
+	if (fs$1.existsSync(path$1.join(root, "ios"))) {
 		applyExpoModulesInfoPlist(root);
 		applyExpoModulesPodfilePlatform(root);
 		applyExpoModulesPodfileAutolinking(root);
@@ -2248,14 +2365,14 @@ function applySplashScreenLayer(root, framework) {
 	applyBootsplashLogo(root, templatesRoot, framework);
 }
 async function applyTestingLayer(root, framework, confirmOverwrite) {
-	const testingLayerRoot = path.join(templatesRoot, "layers", "testing");
+	const testingLayerRoot = path$1.join(templatesRoot, "layers", "testing");
 	const fragmentName = framework === "angular" ? "angular" : "base";
-	renderTemplate(path.join(testingLayerRoot, "fragment", fragmentName, "package.json.fragment.json"), path.join(root, "package.json.fragment.json"));
-	const detoxConfigPath = path.join(root, "detox.config.js");
-	const e2eDirPath = path.join(root, "e2e");
-	if ((fs.existsSync(detoxConfigPath) || fs.existsSync(e2eDirPath)) && !await confirmOverwrite()) return false;
-	renderTemplate(path.join(testingLayerRoot, "detox.config.js"), detoxConfigPath);
-	renderTemplate(path.join(testingLayerRoot, "e2e"), e2eDirPath, { hasTypescript: true });
+	renderTemplate(path$1.join(testingLayerRoot, "fragment", fragmentName, "package.json.fragment.json"), path$1.join(root, "package.json.fragment.json"));
+	const detoxConfigPath = path$1.join(root, "detox.config.js");
+	const e2eDirPath = path$1.join(root, "e2e");
+	if ((fs$1.existsSync(detoxConfigPath) || fs$1.existsSync(e2eDirPath)) && !await confirmOverwrite()) return false;
+	renderTemplate(path$1.join(testingLayerRoot, "detox.config.js"), detoxConfigPath);
+	renderTemplate(path$1.join(testingLayerRoot, "e2e"), e2eDirPath, { hasTypescript: true });
 	return true;
 }
 async function addLayersToApp(options) {
@@ -2330,6 +2447,591 @@ function getCommand(packageManager, script) {
 	return packageManager === "npm" ? `npm run ${script}` : `${packageManager} ${script}`;
 }
 //#endregion
+//#region src/grant-bundles.ts
+var import_src = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("node:fs");
+	const path = __require("node:path");
+	const BEGIN_TAG = "SYMBIOTE-EXPO-LINK:BEGIN";
+	const END_TAG = "SYMBIOTE-EXPO-LINK:END";
+	const REGION_NOTE = "generated by symbiote-expo-link - do not edit, regenerated on every install";
+	const REACT_ANDROID_ANCHOR = "implementation(\"com.facebook.react:react-android\")";
+	const MODULES_MAP_ANCHOR = "override fun getModulesMap(): Map<Class<out Module>, String?> = mapOf(";
+	const MODULES_PROVIDER_CLASS_ANCHOR = ": ModulesProvider {";
+	const MANIFEST_FILENAME = "native-link.json";
+	function isDebug() {
+		return process.env.DEBUG === "1" || process.env.DEBUG === "true" || globalThis.__SYMBIOTE_DEBUG__ === true;
+	}
+	function dlog(...args) {
+		if (isDebug()) console.log("[symbiote-expo-link]", ...args);
+	}
+	function warn(message) {
+		console.warn(`[symbiote-expo-link] ${message}`);
+	}
+	function writeFileAtomic(filePath, content) {
+		const tmpPath = `${filePath}.symbiote-expo-link.${process.pid}.tmp`;
+		fs.writeFileSync(tmpPath, content);
+		fs.renameSync(tmpPath, filePath);
+	}
+	function findAppRoot() {
+		const candidates = [process.cwd(), process.env.INIT_CWD].filter(Boolean);
+		for (const candidate of candidates) {
+			if (fs.existsSync(path.join(candidate, "android", "app", "build.gradle"))) return candidate;
+			if (findInfoPlistFile(candidate)) return candidate;
+		}
+		return null;
+	}
+	function findInfoPlistFile(appRoot) {
+		const iosRoot = path.join(appRoot, "ios");
+		if (!fs.existsSync(iosRoot)) return null;
+		const skip = /Pods|build|DerivedData|Tests/i;
+		const stack = [iosRoot];
+		while (stack.length > 0) {
+			const dir = stack.pop();
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				if (skip.test(entry.name)) continue;
+				const full = path.join(dir, entry.name);
+				if (entry.isDirectory()) stack.push(full);
+				else if (entry.name === "Info.plist") return full;
+			}
+		}
+		return null;
+	}
+	function findMainApplicationFile(appRoot) {
+		const javaRoot = path.join(appRoot, "android", "app", "src", "main", "java");
+		if (!fs.existsSync(javaRoot)) return null;
+		const stack = [javaRoot];
+		while (stack.length > 0) {
+			const dir = stack.pop();
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				const full = path.join(dir, entry.name);
+				if (entry.isDirectory()) stack.push(full);
+				else if (entry.name === "MainApplication.kt") return full;
+			}
+		}
+		return null;
+	}
+	function readManifest(packageDir, packageName) {
+		const manifestPath = path.join(packageDir, MANIFEST_FILENAME);
+		if (!fs.existsSync(manifestPath)) return null;
+		try {
+			return {
+				packageName,
+				manifest: JSON.parse(fs.readFileSync(manifestPath, "utf8"))
+			};
+		} catch (error) {
+			warn(`skipping ${packageName}: its ${MANIFEST_FILENAME} is not valid JSON (${error.message})`);
+			return null;
+		}
+	}
+	function collectManifests(appRoot) {
+		const modulesRoot = path.join(appRoot, "node_modules");
+		if (!fs.existsSync(modulesRoot)) {
+			warn(`no node_modules in ${appRoot}, nothing to link`);
+			return [];
+		}
+		const found = [];
+		for (const entry of fs.readdirSync(modulesRoot, { withFileTypes: true })) {
+			if (entry.name.startsWith(".")) continue;
+			if (entry.name.startsWith("@")) {
+				const scopeDir = path.join(modulesRoot, entry.name);
+				for (const scoped of fs.readdirSync(scopeDir, { withFileTypes: true })) {
+					const entryFound = readManifest(path.join(scopeDir, scoped.name), `${entry.name}/${scoped.name}`);
+					if (entryFound) found.push(entryFound);
+				}
+				continue;
+			}
+			const entryFound = readManifest(path.join(modulesRoot, entry.name), entry.name);
+			if (entryFound) found.push(entryFound);
+		}
+		found.sort((a, b) => a.packageName < b.packageName ? -1 : a.packageName > b.packageName ? 1 : 0);
+		dlog(`found ${found.length} linkable package(s): ${found.map((f) => f.packageName).join(", ")}`);
+		return found;
+	}
+	function writeRegion({ filePath, content, name, indent, bodyLines, findAnchorIndex, anchorLabel }) {
+		const lines = content.split("\n");
+		const block = [
+			`${indent}// ${BEGIN_TAG} ${name} (${REGION_NOTE})`,
+			...bodyLines.map((line) => `${indent}${line}`),
+			`${indent}// ${END_TAG} ${name}`
+		];
+		const beginIndex = lines.findIndex((line) => line.includes(`${BEGIN_TAG} ${name}`));
+		if (beginIndex !== -1) {
+			const endIndex = lines.findIndex((line, i) => i > beginIndex && line.includes(`${END_TAG} ${name}`));
+			if (endIndex === -1) {
+				warn(`${filePath} has "${BEGIN_TAG} ${name}" but no matching "${END_TAG} ${name}". Restore the end marker (or delete the whole block) and reinstall.`);
+				return null;
+			}
+			lines.splice(beginIndex, endIndex - beginIndex + 1, ...block);
+			return lines.join("\n");
+		}
+		const anchorIndex = findAnchorIndex(lines);
+		if (anchorIndex === -1) {
+			warn(`cannot create the ${name} block in ${filePath}: ${anchorLabel}`);
+			return null;
+		}
+		lines.splice(anchorIndex + 1, 0, ...block);
+		return lines.join("\n");
+	}
+	function applyIfChanged(filePath, content, nextContent) {
+		if (nextContent === null || nextContent === content) return;
+		writeFileAtomic(filePath, nextContent);
+		dlog(`updated ${filePath}`);
+	}
+	function patchBuildGradle(appRoot, entries) {
+		const gradlePath = path.join(appRoot, "android", "app", "build.gradle");
+		if (!fs.existsSync(gradlePath)) {
+			dlog("android/app/build.gradle not found, skipping");
+			return;
+		}
+		const primaryProjectNames = entries.filter((entry) => entry.manifest.android && entry.manifest.android.gradleProjectName).map((entry) => entry.manifest.android.gradleProjectName);
+		const serviceProjectNames = androidServicesOf(entries).map((service) => service.gradleProjectName);
+		const deps = [.../* @__PURE__ */ new Set([...primaryProjectNames, ...serviceProjectNames])].sort().map((name) => `implementation project(':${name}')`);
+		const content = fs.readFileSync(gradlePath, "utf8");
+		applyIfChanged(gradlePath, content, writeRegion({
+			filePath: gradlePath,
+			content,
+			name: "DEPENDENCIES",
+			indent: "    ",
+			bodyLines: deps,
+			findAnchorIndex: (lines) => lines.findIndex((line) => line.includes(REACT_ANDROID_ANCHOR)),
+			anchorLabel: `no \`${REACT_ANDROID_ANCHOR}\` line to anchor below`
+		}));
+	}
+	function androidModulesOf(entries) {
+		return entries.flatMap((entry) => entry.manifest.android && Array.isArray(entry.manifest.android.modules) ? entry.manifest.android.modules : []);
+	}
+	function androidServicesOf(entries) {
+		return entries.flatMap((entry) => entry.manifest.android && Array.isArray(entry.manifest.android.services) ? entry.manifest.android.services : []);
+	}
+	function patchMainApplication(appRoot, entries) {
+		const filePath = findMainApplicationFile(appRoot);
+		if (!filePath) {
+			dlog("MainApplication.kt not found, skipping");
+			return;
+		}
+		const modules = androidModulesOf(entries);
+		const services = androidServicesOf(entries);
+		const imports = [.../* @__PURE__ */ new Set([
+			...modules.map((module$1) => `import ${module$1.importPath}`),
+			...services.map((service) => `import ${service.importPath}`),
+			"import expo.modules.kotlin.services.Service"
+		])].sort();
+		const mapEntries = [...new Set(modules.map((module$2) => `${module$2.className}::class.java to "${module$2.nativeName}",`))].sort();
+		const serviceEntries = [...new Set(services.map((service) => `  ${service.className}::class.java,`))].sort();
+		const content = fs.readFileSync(filePath, "utf8");
+		const withImports = writeRegion({
+			filePath,
+			content,
+			name: "IMPORTS",
+			indent: "",
+			bodyLines: imports,
+			findAnchorIndex: (lines) => {
+				let lastImport = -1;
+				for (let i = 0; i < lines.length; i += 1) if (lines[i].trim().startsWith("import ")) lastImport = i;
+				return lastImport;
+			},
+			anchorLabel: "no import statements to anchor below"
+		});
+		if (withImports === null) return;
+		const withModules = writeRegion({
+			filePath,
+			content: withImports,
+			name: "MODULES-MAP",
+			indent: "    ",
+			bodyLines: mapEntries,
+			findAnchorIndex: (lines) => lines.findIndex((line) => line.includes(MODULES_MAP_ANCHOR)),
+			anchorLabel: "no `getModulesMap()` declaration to anchor below"
+		});
+		if (withModules === null) return;
+		applyIfChanged(filePath, content, writeRegion({
+			filePath,
+			content: withModules,
+			name: "SERVICES",
+			indent: "  ",
+			bodyLines: [
+				"override fun getServices(): List<Class<out Service>> = listOf(",
+				...serviceEntries,
+				")"
+			],
+			findAnchorIndex: (lines) => lines.findIndex((line) => line.includes(MODULES_PROVIDER_CLASS_ANCHOR)),
+			anchorLabel: "no `ExpoModulesProvider : ModulesProvider` class declaration to anchor below"
+		}));
+	}
+	function escapeXml(value) {
+		return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	}
+	function escapeXmlAttribute(value) {
+		return escapeXml(value).replace(/"/g, "&quot;");
+	}
+	function findTag(content, tagName) {
+		const match = new RegExp(`<${tagName}(?=[\\s>/])`).exec(content);
+		if (!match) return null;
+		let quote = null;
+		for (let i = match.index; i < content.length; i += 1) {
+			const char = content[i];
+			if (quote !== null) {
+				if (char === quote) quote = null;
+				continue;
+			}
+			if (char === "\"" || char === "'") quote = char;
+			else if (char === ">") return {
+				start: match.index,
+				end: i
+			};
+		}
+		return null;
+	}
+	function findApplicationTag(content) {
+		return findTag(content, "application");
+	}
+	function findAllTags(content, tagName) {
+		const tags = [];
+		const re = new RegExp(`<${tagName}(?=[\\s>/])`, "g");
+		let match = re.exec(content);
+		while (match) {
+			let quote = null;
+			for (let i = match.index; i < content.length; i += 1) {
+				const char = content[i];
+				if (quote !== null) {
+					if (char === quote) quote = null;
+					continue;
+				}
+				if (char === "\"" || char === "'") quote = char;
+				else if (char === ">") {
+					tags.push({
+						start: match.index,
+						end: i
+					});
+					re.lastIndex = i + 1;
+					break;
+				}
+			}
+			match = re.exec(content);
+		}
+		return tags;
+	}
+	function findMainActivityTag(content) {
+		for (const tag of findAllTags(content, "activity")) {
+			const name = readXmlAttribute(content.slice(tag.start, tag.end), "android:name");
+			if (name && /(^|\.)MainActivity$/.test(name)) return tag;
+		}
+		return null;
+	}
+	function readXmlAttribute(tagText, name) {
+		const match = new RegExp(`\\s${name}\\s*=\\s*"([^"]*)"`).exec(tagText);
+		return match ? match[1] : null;
+	}
+	function patchAndroidManifest(appRoot, entries) {
+		const wanted = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const attributes = entry.manifest.android && entry.manifest.android.manifestApplicationAttributes;
+			if (!attributes) continue;
+			for (const [name, value] of Object.entries(attributes)) if (!wanted.has(name)) wanted.set(name, value);
+		}
+		if (wanted.size === 0) return;
+		const manifestPath = path.join(appRoot, "android", "app", "src", "main", "AndroidManifest.xml");
+		if (!fs.existsSync(manifestPath)) {
+			dlog("AndroidManifest.xml not found, skipping application attributes");
+			return;
+		}
+		const content = fs.readFileSync(manifestPath, "utf8");
+		let next = content;
+		for (const [name, value] of [...wanted].sort((a, b) => a[0] < b[0] ? -1 : 1)) {
+			if (!/^[\w.:-]+$/.test(name)) {
+				warn(`skipping the manifest attribute "${name}": not a plain XML attribute name`);
+				continue;
+			}
+			const tag = findApplicationTag(next);
+			if (!tag) {
+				warn(`${manifestPath} has no <application> element, skipping ${name}`);
+				return;
+			}
+			const tagText = next.slice(tag.start, tag.end);
+			const escaped = escapeXmlAttribute(value);
+			const existing = readXmlAttribute(tagText, name);
+			if (existing !== null) {
+				if (existing !== escaped) warn(`${name} in ${manifestPath} reads "${existing}" but the package manifest says "${value}". Keeping the file as-is; edit it by hand if you want the manifest's.`);
+				continue;
+			}
+			const lastNewline = tagText.lastIndexOf("\n");
+			const separator = lastNewline === -1 ? " " : `\n${/^[ \t]*/.exec(tagText.slice(lastNewline + 1))[0]}`;
+			const insertAt = next[tag.end - 1] === "/" ? tag.end - 1 : tag.end;
+			next = `${next.slice(0, insertAt)}${separator}${name}="${escaped}"${next.slice(insertAt)}`;
+		}
+		applyIfChanged(manifestPath, content, next);
+	}
+	function patchMainActivityConfigChanges(appRoot, entries) {
+		const wanted = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			const values = entry.manifest.android && entry.manifest.android.mainActivityConfigChanges;
+			if (!values) continue;
+			for (const value of values) wanted.add(value);
+		}
+		if (wanted.size === 0) return;
+		const manifestPath = path.join(appRoot, "android", "app", "src", "main", "AndroidManifest.xml");
+		if (!fs.existsSync(manifestPath)) {
+			dlog("AndroidManifest.xml not found, skipping MainActivity configChanges");
+			return;
+		}
+		const content = fs.readFileSync(manifestPath, "utf8");
+		const tag = findMainActivityTag(content);
+		if (!tag) {
+			warn(`${manifestPath} has no MainActivity <activity> element, skipping configChanges`);
+			return;
+		}
+		const tagText = content.slice(tag.start, tag.end);
+		const existingValue = readXmlAttribute(tagText, "android:configChanges");
+		const existingTokens = existingValue ? existingValue.split("|").map((token) => token.trim()).filter(Boolean) : [];
+		const existingSet = new Set(existingTokens);
+		const missing = [...wanted].filter((token) => !existingSet.has(token)).sort();
+		if (missing.length === 0) return;
+		const merged = [...existingTokens, ...missing].join("|");
+		let next;
+		if (existingValue !== null) {
+			const valueMatch = /android:configChanges\s*=\s*"/.exec(tagText);
+			const valueStart = valueMatch.index + valueMatch[0].length;
+			const valueEnd = tagText.indexOf("\"", valueStart);
+			const nextTagText = tagText.slice(0, valueStart) + merged + tagText.slice(valueEnd);
+			next = content.slice(0, tag.start) + nextTagText + content.slice(tag.end);
+		} else {
+			const lastNewline = tagText.lastIndexOf("\n");
+			const separator = lastNewline === -1 ? " " : `\n${/^[ \t]*/.exec(tagText.slice(lastNewline + 1))[0]}`;
+			const selfClosing = content[tag.end - 1] === "/";
+			const insertAt = selfClosing ? tag.end - 1 : tag.end;
+			next = `${content.slice(0, insertAt).replace(/[ \t]+$/, "")}${separator}android:configChanges="${merged}"${selfClosing ? " " : ""}${content.slice(insertAt)}`;
+		}
+		applyIfChanged(manifestPath, content, next);
+	}
+	function readManifestPermissions(content) {
+		return new Set([...content.matchAll(/<uses-permission\s[^>]*android:name="([^"]+)"/g)].map((match) => match[1]));
+	}
+	function patchAndroidManifestPermissions(appRoot, entries) {
+		const wanted = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			const permissions = entry.manifest.android && entry.manifest.android.manifestPermissions;
+			if (!permissions) continue;
+			for (const permission of permissions) wanted.add(permission);
+		}
+		if (wanted.size === 0) return;
+		const manifestPath = path.join(appRoot, "android", "app", "src", "main", "AndroidManifest.xml");
+		if (!fs.existsSync(manifestPath)) {
+			dlog("AndroidManifest.xml not found, skipping permissions");
+			return;
+		}
+		const content = fs.readFileSync(manifestPath, "utf8");
+		const existing = readManifestPermissions(content);
+		const missing = [...wanted].filter((permission) => !existing.has(permission)).sort();
+		if (missing.length === 0) return;
+		const tag = findTag(content, "manifest");
+		if (!tag) {
+			warn(`${manifestPath} has no <manifest> element, skipping permissions`);
+			return;
+		}
+		const lines = missing.map((permission) => `  <uses-permission android:name="${permission}" />`).join("\n");
+		applyIfChanged(manifestPath, content, `${content.slice(0, tag.end + 1)}\n${lines}${content.slice(tag.end + 1)}`);
+	}
+	function readManifestServiceNames(content) {
+		return new Set([...content.matchAll(/<service\s[^>]*android:name="([^"]+)"/g)].map((match) => match[1]));
+	}
+	function buildServiceXml(service, indent) {
+		const attrs = [`android:name="${escapeXmlAttribute(service.name)}"`, `android:exported="${service.exported === true ? "true" : "false"}"`];
+		if (service.foregroundServiceType) attrs.push(`android:foregroundServiceType="${escapeXmlAttribute(service.foregroundServiceType)}"`);
+		const openTag = `${indent}<service ${attrs.join(" ")}`;
+		if (!service.intentFilterActions || service.intentFilterActions.length === 0) return `${openTag} />`;
+		return `${openTag}>\n${indent}  <intent-filter>\n${service.intentFilterActions.map((action) => `${indent}    <action android:name="${escapeXmlAttribute(action)}" />`).join("\n")}\n${indent}  </intent-filter>\n${indent}</service>`;
+	}
+	function patchAndroidManifestServices(appRoot, entries) {
+		const wanted = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const services = entry.manifest.android && entry.manifest.android.manifestServices;
+			if (!services) continue;
+			for (const service of services) if (!wanted.has(service.name)) wanted.set(service.name, service);
+		}
+		if (wanted.size === 0) return;
+		const manifestPath = path.join(appRoot, "android", "app", "src", "main", "AndroidManifest.xml");
+		if (!fs.existsSync(manifestPath)) {
+			dlog("AndroidManifest.xml not found, skipping services");
+			return;
+		}
+		const content = fs.readFileSync(manifestPath, "utf8");
+		const existing = readManifestServiceNames(content);
+		const missing = [...wanted.values()].filter((service) => !existing.has(service.name)).sort((a, b) => a.name < b.name ? -1 : 1);
+		if (missing.length === 0) return;
+		const tag = findApplicationTag(content);
+		if (!tag) {
+			warn(`${manifestPath} has no <application> element, skipping services`);
+			return;
+		}
+		if (content[tag.end - 1] === "/") {
+			warn(`${manifestPath}'s <application> is self-closing, skipping services`);
+			return;
+		}
+		const lastNewline = content.lastIndexOf("\n", tag.start);
+		const indent = `${/^[ \t]*/.exec(content.slice(lastNewline + 1, tag.start))[0]}  `;
+		const blocks = missing.map((service) => buildServiceXml(service, indent)).join("\n");
+		const insertAt = tag.end + 1;
+		applyIfChanged(manifestPath, content, `${content.slice(0, insertAt)}\n${blocks}${content.slice(insertAt)}`);
+	}
+	function readPlistString(content, key) {
+		const keyIndex = content.indexOf(`<key>${key}</key>`);
+		if (keyIndex === -1) return null;
+		const match = /<string>([\s\S]*?)<\/string>/.exec(content.slice(keyIndex));
+		return match ? match[1] : null;
+	}
+	function patchInfoPlist(appRoot, entries) {
+		const wanted = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const keys = entry.manifest.ios && entry.manifest.ios.infoPlistKeys;
+			if (!keys) continue;
+			for (const [key, description] of Object.entries(keys)) if (!wanted.has(key)) wanted.set(key, description);
+		}
+		if (wanted.size === 0) return;
+		const plistPath = findInfoPlistFile(appRoot);
+		if (!plistPath) {
+			dlog("Info.plist not found, skipping iOS permission strings");
+			return;
+		}
+		const content = fs.readFileSync(plistPath, "utf8");
+		let next = content;
+		for (const [key, description] of [...wanted].sort((a, b) => a[0] < b[0] ? -1 : 1)) {
+			const escaped = escapeXml(description);
+			const existing = readPlistString(next, key);
+			if (existing !== null) {
+				if (existing !== escaped) warn(`${key} in ${plistPath} reads "${existing}" but the package manifest says "${description}". Keeping the file as-is; edit it by hand if you want the manifest's.`);
+				continue;
+			}
+			const plistCloseIndex = next.lastIndexOf("</plist>");
+			const dictCloseIndex = next.lastIndexOf("</dict>", plistCloseIndex === -1 ? void 0 : plistCloseIndex);
+			if (dictCloseIndex === -1) {
+				warn(`${plistPath} has no closing </dict>, skipping ${key}`);
+				continue;
+			}
+			const block = `\t<key>${key}</key>\n\t<string>${escaped}</string>\n`;
+			next = next.slice(0, dictCloseIndex) + block + next.slice(dictCloseIndex);
+		}
+		applyIfChanged(plistPath, content, next);
+	}
+	function readPlistArray(content, key) {
+		const keyTag = `<key>${key}</key>`;
+		const keyIndex = content.indexOf(keyTag);
+		if (keyIndex === -1) return null;
+		const arrayOpenIndex = content.indexOf("<array>", keyIndex + keyTag.length);
+		const arrayCloseIndex = arrayOpenIndex === -1 ? -1 : content.indexOf("</array>", arrayOpenIndex);
+		if (arrayOpenIndex === -1 || arrayCloseIndex === -1) return null;
+		return {
+			arrayCloseIndex,
+			items: [...content.slice(arrayOpenIndex + 7, arrayCloseIndex).matchAll(/<string>([\s\S]*?)<\/string>/g)].map((match) => match[1])
+		};
+	}
+	function patchInfoPlistArrays(appRoot, entries) {
+		const wanted = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			const arrayKeys = entry.manifest.ios && entry.manifest.ios.infoPlistArrayKeys;
+			if (!arrayKeys) continue;
+			for (const [key, items] of Object.entries(arrayKeys)) {
+				if (!wanted.has(key)) wanted.set(key, /* @__PURE__ */ new Set());
+				for (const item of items) wanted.get(key).add(item);
+			}
+		}
+		if (wanted.size === 0) return;
+		const plistPath = findInfoPlistFile(appRoot);
+		if (!plistPath) {
+			dlog("Info.plist not found, skipping iOS array keys");
+			return;
+		}
+		const content = fs.readFileSync(plistPath, "utf8");
+		let next = content;
+		for (const [key, itemsSet] of [...wanted].sort((a, b) => a[0] < b[0] ? -1 : 1)) {
+			const wantedItems = [...itemsSet];
+			const existing = readPlistArray(next, key);
+			if (existing === null) {
+				const plistCloseIndex = next.lastIndexOf("</plist>");
+				const dictCloseIndex = next.lastIndexOf("</dict>", plistCloseIndex === -1 ? void 0 : plistCloseIndex);
+				if (dictCloseIndex === -1) {
+					warn(`${plistPath} has no closing </dict>, skipping ${key}`);
+					continue;
+				}
+				const block = `\t<key>${key}</key>\n\t<array>\n${wantedItems.map((item) => `\t\t<string>${escapeXml(item)}</string>`).join("\n")}\n\t</array>\n`;
+				next = next.slice(0, dictCloseIndex) + block + next.slice(dictCloseIndex);
+				continue;
+			}
+			const missing = wantedItems.filter((item) => !existing.items.includes(item));
+			if (missing.length === 0) continue;
+			const missingLines = missing.map((item) => `\t\t<string>${escapeXml(item)}</string>\n`).join("");
+			next = next.slice(0, existing.arrayCloseIndex) + missingLines + next.slice(existing.arrayCloseIndex);
+		}
+		applyIfChanged(plistPath, content, next);
+	}
+	function linkApp(explicitAppRoot) {
+		const appRoot = explicitAppRoot || findAppRoot();
+		if (!appRoot) {
+			warn("no React Native app here (no android/app/build.gradle, no ios/**/Info.plist), skipping");
+			return;
+		}
+		const entries = collectManifests(appRoot);
+		patchBuildGradle(appRoot, entries);
+		patchMainApplication(appRoot, entries);
+		patchAndroidManifest(appRoot, entries);
+		patchAndroidManifestPermissions(appRoot, entries);
+		patchAndroidManifestServices(appRoot, entries);
+		patchMainActivityConfigChanges(appRoot, entries);
+		patchInfoPlist(appRoot, entries);
+		patchInfoPlistArrays(appRoot, entries);
+	}
+	module.exports = {
+		linkApp,
+		collectManifests,
+		findAppRoot,
+		findInfoPlistFile,
+		findMainApplicationFile,
+		patchBuildGradle,
+		patchMainApplication,
+		patchAndroidManifest,
+		patchAndroidManifestPermissions,
+		patchAndroidManifestServices,
+		patchMainActivityConfigChanges,
+		patchInfoPlist,
+		patchInfoPlistArrays
+	};
+})))();
+function discoveredBundlesFromLayers(layers) {
+	return layers.flatMap((layer) => (layer.optionalManifestBundles ?? []).map((bundle) => ({
+		packageName: layer.symbiotePackage,
+		bundle
+	})));
+}
+function discoverOptionalBundles(appRoot) {
+	const discovered = [];
+	for (const entry of (0, import_src.collectManifests)(appRoot)) {
+		const bundles = entry.manifest.android?.optionalManifestBundles;
+		if (!bundles) continue;
+		for (const bundle of bundles) discovered.push({
+			packageName: entry.packageName,
+			bundle
+		});
+	}
+	return discovered;
+}
+function applyBundle(appRoot, bundle) {
+	const entries = [{
+		packageName: `grant:${bundle.id}`,
+		manifest: { android: {
+			manifestPermissions: bundle.manifestPermissions,
+			manifestServices: bundle.manifestServices
+		} }
+	}];
+	(0, import_src.patchAndroidManifestPermissions)(appRoot, entries);
+	(0, import_src.patchAndroidManifestServices)(appRoot, entries);
+}
+function packageShortName(packageName) {
+	const slashIndex = packageName.lastIndexOf("/");
+	return slashIndex === -1 ? packageName : packageName.slice(slashIndex + 1);
+}
+function filterBundlesForLayer(discovered, layer) {
+	if (layer === void 0) return [...discovered];
+	return discovered.filter((entry) => packageShortName(entry.packageName) === layer);
+}
+//#endregion
 //#region src/detect-package-manager.ts
 const USER_AGENT_PREFIXES = [
 	["pnpm", "pnpm"],
@@ -2433,6 +3135,15 @@ async function resolveOverwrite(targetDir, force) {
 	assertNotCancelled(answer);
 	return answer;
 }
+async function resolveGitInit() {
+	if (!isInteractive()) return false;
+	const answer = await confirm({
+		message: "Initialize a git repository?",
+		initialValue: true
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
 async function resolveStyling(styling) {
 	if (styling !== void 0) return styling;
 	if (!isInteractive()) return "css";
@@ -2581,6 +3292,10 @@ const ADD_LAYER_OPTIONS = [
 		hint: layer.symbiotePackage
 	}))
 ];
+const ADD_LAYER_NAME_SET = new Set(ADD_LAYER_OPTIONS.map((option) => option.value));
+function isAddLayerName(value) {
+	return ADD_LAYER_NAME_SET.has(value);
+}
 function explicitLayersFromFlags(flags) {
 	const explicit = [];
 	if (flags.hasNavigation) explicit.push("navigation");
@@ -2622,7 +3337,22 @@ async function resolveAddLayers(flags, alreadyAdded, hasForce = false) {
 		required: false
 	});
 	assertNotCancelled(answer);
-	return withImpliedExpoModules(dropAlreadyAdded(answer, alreadyAdded, hasForce));
+	return withImpliedExpoModules(dropAlreadyAdded(answer.filter(isAddLayerName), alreadyAdded, hasForce));
+}
+async function resolveGrantSelection(candidates) {
+	if (!isInteractive()) throw new CliUsageError("Not running in an interactive terminal — \"grant\" needs a real choice for each policy-sensitive bundle, so it cannot run non-interactively.");
+	const answer = await multiselect({
+		message: "Which policy-sensitive capabilities should this app request?",
+		options: candidates.map((entry, index) => ({
+			value: String(index),
+			label: entry.bundle.label,
+			hint: entry.packageName
+		})),
+		required: false
+	});
+	assertNotCancelled(answer);
+	const selectedIndexes = new Set(answer);
+	return candidates.filter((_entry, index) => selectedIndexes.has(String(index)));
 }
 async function resolvePackageManager(packageManager) {
 	const detected = packageManager ?? detectPackageManagerFromUserAgent();
@@ -2649,6 +3379,11 @@ async function resolvePackageManager(packageManager) {
 	return answer;
 }
 //#endregion
+//#region src/commands/grant-summary.ts
+function printGrantedNotes(granted) {
+	for (const entry of granted) note(`${entry.bundle.warning}\n\nNext: ${entry.bundle.nextSteps}`, entry.bundle.label);
+}
+//#endregion
 //#region src/commands/add.ts
 function resolveFrameworkForAdd(explicit, cwd = process.cwd()) {
 	const detected = detectSymbioteFrameworkFromDependencies(readCwdDependencies(cwd));
@@ -2690,20 +3425,70 @@ async function runAdd(parsed) {
 	const allSkips = [...alreadyPresentSkips, ...result.skippedLayers];
 	if (allSkips.length > 0) lines.push("", `Skipped (already present, left untouched): ${allSkips.join(", ")}.`);
 	if (result.appliedLayers.includes("navigation")) lines.push("", "Wire it up in your App entry:", import_picocolors.default.dim(`  import { Stack } from '@symbiote-native/navigation/${framework}';`));
+	const grantable = expoPackagesWithOptionalManifestBundles(new Set(result.appliedLayers));
+	if (grantable.length > 0) {
+		const candidates = discoveredBundlesFromLayers(grantable);
+		let granted = [];
+		let asked = false;
+		try {
+			granted = await resolveGrantSelection(candidates);
+			asked = true;
+		} catch (error) {
+			if (!(error instanceof CliUsageError)) throw error;
+		}
+		if (granted.length > 0) {
+			for (const entry of granted) applyBundle(cwd, entry.bundle);
+			printGrantedNotes(granted);
+			lines.push("", `Granted: ${granted.map((entry) => entry.bundle.label).join(", ")}.`);
+		} else if (!asked) lines.push("", `${grantable.map((layer) => layer.label).join(", ")} also offer${grantable.length === 1 ? "s" : ""} optional, policy-sensitive Android permissions — after installing:`, ...grantable.map((layer) => import_picocolors.default.dim(`  npx @symbiote-native/cli grant ${layer.id}`)));
+	}
 	outro(lines.length > 0 ? lines.join("\n") : "Nothing changed.");
 }
 //#endregion
+//#region src/commands/grant.ts
+async function runGrant(parsed) {
+	intro("@symbiote-native/cli grant");
+	const appRoot = (0, import_src.findAppRoot)();
+	if (!appRoot) throw new NotSymbioteAppError();
+	const candidates = filterBundlesForLayer(discoverOptionalBundles(appRoot), parsed.layer);
+	if (candidates.length === 0) {
+		outro(parsed.layer === void 0 ? "Nothing to grant — no installed package declares an optional manifest bundle." : `Nothing to grant for "${parsed.layer}" — it declares no optional manifest bundle, or isn't installed.`);
+		return;
+	}
+	const selected = await resolveGrantSelection(candidates);
+	if (selected.length === 0) {
+		outro("Nothing granted.");
+		return;
+	}
+	for (const entry of selected) applyBundle(appRoot, entry.bundle);
+	printGrantedNotes(selected);
+	outro(`Granted: ${selected.map((entry) => entry.bundle.label).join(", ")}.`);
+}
+//#endregion
+//#region src/utils/git-init.ts
+function tryGitInit(root) {
+	try {
+		execFileSync("git", ["init"], {
+			cwd: root,
+			stdio: "ignore"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/commands/new.ts
 async function runNew(parsed) {
 	intro("@symbiote-native/cli new");
 	const appName = await resolveAppName(parsed.appName);
-	const targetDir = path.resolve(process.cwd(), appName);
+	const targetDir = path$1.resolve(process.cwd(), appName);
 	if (!isEmptyDir(targetDir)) {
 		if (!await resolveOverwrite(targetDir, parsed.hasForce)) {
 			cancel("Cancelled.");
 			process.exit(1);
 		}
-		fs.rmSync(targetDir, {
+		fs$1.rmSync(targetDir, {
 			recursive: true,
 			force: true
 		});
@@ -2729,23 +3514,38 @@ async function runNew(parsed) {
 		styling,
 		packageManager
 	});
-	const hasGitDir = fs.existsSync(path.join(root, ".git"));
-	outro([
+	const hasGitDir = fs$1.existsSync(path$1.join(root, ".git"));
+	const lines = [
 		`Scaffolded "${appName}" at ${root}.`,
 		"",
 		...appName === "." ? [] : [import_picocolors.default.bold(import_picocolors.default.green(`  cd ${appName}`))],
 		import_picocolors.default.bold(import_picocolors.default.green(`  ${getCommand(packageManager, "install")}`)),
-		import_picocolors.default.bold(import_picocolors.default.green(`  ${getCommand(packageManager, "dev")}`)),
-		...hasGitDir ? [] : [
-			"",
-			"Not a git repository yet:",
-			import_picocolors.default.bold(import_picocolors.default.green("  git init && git add -A && git commit -m \"initial commit\""))
-		]
-	].join("\n"));
+		import_picocolors.default.bold(import_picocolors.default.green(`  ${getCommand(packageManager, "dev")}`))
+	];
+	if (!hasGitDir && await resolveGitInit() && tryGitInit(root)) lines.push("", import_picocolors.default.dim("Initialized an empty git repository."));
+	else if (!hasGitDir) lines.push("", "Not a git repository yet:", import_picocolors.default.bold(import_picocolors.default.green("  git init && git add -A && git commit -m \"initial commit\"")));
+	const grantable = expoPackagesWithOptionalManifestBundles(expoPackages);
+	if (grantable.length > 0) {
+		const candidates = discoveredBundlesFromLayers(grantable);
+		let granted = [];
+		let asked = false;
+		try {
+			granted = await resolveGrantSelection(candidates);
+			asked = true;
+		} catch (error) {
+			if (!(error instanceof CliUsageError)) throw error;
+		}
+		if (granted.length > 0) {
+			for (const entry of granted) applyBundle(root, entry.bundle);
+			printGrantedNotes(granted);
+			lines.push("", `Granted: ${granted.map((entry) => entry.bundle.label).join(", ")}.`);
+		} else if (!asked) lines.push("", `${grantable.map((layer) => layer.label).join(", ")} also offer${grantable.length === 1 ? "s" : ""} optional, policy-sensitive Android permissions — after installing:`, ...grantable.map((layer) => import_picocolors.default.dim(`  npx @symbiote-native/cli grant ${layer.id}`)));
+	}
+	outro(lines.join("\n"));
 }
 //#endregion
 //#region package.json
-var version = "0.1.2";
+var version = "0.2.1";
 //#endregion
 //#region src/index.ts
 function printHelp() {
@@ -2761,6 +3561,10 @@ Usage:
   npx @symbiote-native/cli add [--navigation] [--expo-modules] [--testing] [--splash-screen] [--slider]
                       [--<expo-package> ...] [--force] [--pm npm|pnpm|yarn]
                       (run inside an existing @symbiote-native/* app)
+  npx @symbiote-native/cli grant [layer]
+                      interactively opt into policy-sensitive Android permissions/services
+                      (e.g. background location, audio recording) an installed package offers;
+                      [layer] narrows to one package's short name, e.g. "grant location"
 
   npx @symbiote-native/cli --version   print the CLI version
   npx @symbiote-native/cli --help      print this message
@@ -2778,6 +3582,9 @@ async function main() {
 		case "add":
 			await runAdd(parsed);
 			return;
+		case "grant":
+			await runGrant(parsed);
+			return;
 		case "help":
 			printHelp();
 			return;