@symbiote-native/cli 0.0.1

package/bundle.js

@@ -0,0 +1,2833 @@
+#!/usr/bin/env node
+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 { readFileSync } from "node:fs";
+import * as path from "node:path";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/errors.ts
+var import_picocolors = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {};
+	let argv = p.argv || [];
+	let env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+})))(), 1);
+var CliUsageError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CliUsageError";
+	}
+};
+var NotSymbioteAppError = class extends Error {
+	constructor() {
+		super("No @symbiote-native/<adapter> dependency found in this project's package.json — \"add\" only works inside an existing @symbiote-native/* app. Run \"@symbiote-native/cli new\" to scaffold one.");
+		this.name = "NotSymbioteAppError";
+	}
+};
+//#endregion
+//#region src/expo-package-layers.ts
+const EXPO_PACKAGE_LAYERS = [
+	{
+		id: "application",
+		label: "Application info",
+		symbiotePackage: "@symbiote-native/application"
+	},
+	{
+		id: "battery",
+		label: "Battery",
+		symbiotePackage: "@symbiote-native/battery"
+	},
+	{
+		id: "brightness",
+		label: "Brightness",
+		symbiotePackage: "@symbiote-native/brightness"
+	},
+	{
+		id: "cellular",
+		label: "Cellular info",
+		symbiotePackage: "@symbiote-native/cellular"
+	},
+	{
+		id: "clipboard",
+		label: "Clipboard",
+		symbiotePackage: "@symbiote-native/clipboard"
+	},
+	{
+		id: "crypto",
+		label: "Crypto",
+		symbiotePackage: "@symbiote-native/crypto"
+	},
+	{
+		id: "device",
+		label: "Device info",
+		symbiotePackage: "@symbiote-native/device"
+	},
+	{
+		id: "haptics",
+		label: "Haptics",
+		symbiotePackage: "@symbiote-native/haptics"
+	},
+	{
+		id: "keep-awake",
+		label: "Keep awake",
+		symbiotePackage: "@symbiote-native/keep-awake"
+	},
+	{
+		id: "local-auth",
+		label: "Local authentication",
+		symbiotePackage: "@symbiote-native/local-auth"
+	},
+	{
+		id: "localization",
+		label: "Localization",
+		symbiotePackage: "@symbiote-native/localization"
+	},
+	{
+		id: "network",
+		label: "Network info",
+		symbiotePackage: "@symbiote-native/network"
+	},
+	{
+		id: "screen-orientation",
+		label: "Screen orientation",
+		symbiotePackage: "@symbiote-native/screen-orientation"
+	},
+	{
+		id: "secure-store",
+		label: "Secure store",
+		symbiotePackage: "@symbiote-native/secure-store"
+	},
+	{
+		id: "sensors",
+		label: "Sensors",
+		symbiotePackage: "@symbiote-native/sensors"
+	},
+	{
+		id: "sharing",
+		label: "Sharing",
+		symbiotePackage: "@symbiote-native/sharing"
+	},
+	{
+		id: "sms",
+		label: "SMS",
+		symbiotePackage: "@symbiote-native/sms"
+	},
+	{
+		id: "standard-web-crypto",
+		label: "Web Crypto polyfill",
+		symbiotePackage: "@symbiote-native/standard-web-crypto"
+	},
+	{
+		id: "store-review",
+		label: "Store review prompt",
+		symbiotePackage: "@symbiote-native/store-review"
+	},
+	{
+		id: "system-ui",
+		label: "System UI",
+		symbiotePackage: "@symbiote-native/system-ui"
+	},
+	{
+		id: "tracking-transparency",
+		label: "Tracking transparency",
+		symbiotePackage: "@symbiote-native/tracking-transparency"
+	},
+	{
+		id: "web-browser",
+		label: "Web browser",
+		symbiotePackage: "@symbiote-native/web-browser"
+	}
+];
+const EXPO_PACKAGE_LAYER_IDS = new Set(EXPO_PACKAGE_LAYERS.map((layer) => layer.id));
+function isExpoPackageLayerName(value) {
+	return EXPO_PACKAGE_LAYER_IDS.has(value);
+}
+//#endregion
+//#region src/utils/suggest.ts
+function editDistance(a, b) {
+	const rows = a.length + 1;
+	const cols = b.length + 1;
+	const distances = Array.from({ length: rows }, () => new Array(cols).fill(0));
+	for (let row = 0; row < rows; row += 1) distances[row][0] = row;
+	for (let col = 0; col < cols; col += 1) distances[0][col] = col;
+	for (let row = 1; row < rows; row += 1) for (let col = 1; col < cols; col += 1) {
+		const cost = a[row - 1] === b[col - 1] ? 0 : 1;
+		let best = Math.min(distances[row - 1][col] + 1, distances[row][col - 1] + 1, distances[row - 1][col - 1] + cost);
+		if (row > 1 && col > 1 && a[row - 1] === b[col - 2] && a[row - 2] === b[col - 1]) best = Math.min(best, distances[row - 2][col - 2] + 1);
+		distances[row][col] = best;
+	}
+	return distances[rows - 1][cols - 1];
+}
+function findClosestMatch(input, candidates) {
+	let closest;
+	let closestDistance = Infinity;
+	for (const candidate of candidates) {
+		const distance = editDistance(input, candidate);
+		if (distance < closestDistance) {
+			closestDistance = distance;
+			closest = candidate;
+		}
+	}
+	if (closest === void 0) return void 0;
+	const threshold = Math.max(1, Math.floor(Math.max(input.length, closest.length) / 2));
+	return closestDistance <= threshold ? closest : void 0;
+}
+//#endregion
+//#region src/cli.ts
+const FRAMEWORKS = /* @__PURE__ */ new Set([
+	"react",
+	"vue",
+	"angular",
+	"solid",
+	"svelte"
+]);
+const VUE_FLAVORS = /* @__PURE__ */ new Set(["tsx", "sfc"]);
+const PACKAGE_MANAGERS = /* @__PURE__ */ new Set([
+	"npm",
+	"pnpm",
+	"yarn"
+]);
+const STYLING_OPTIONS = /* @__PURE__ */ new Set([
+	"css",
+	"scss",
+	"less",
+	"stylus",
+	"css-modules",
+	"stylesheet"
+]);
+const KNOWN_FLAGS = [
+	"--javascript",
+	"--force",
+	"--expo-modules",
+	"--navigation",
+	"--testing",
+	"--splash-screen",
+	"--slider",
+	"--framework",
+	"--bundle-id",
+	"--styling",
+	"--vue-flavor",
+	"--pm",
+	...EXPO_PACKAGE_LAYERS.map((layer) => `--${layer.id}`)
+];
+function isFramework(value) {
+	return FRAMEWORKS.has(value);
+}
+function isVueFlavor(value) {
+	return VUE_FLAVORS.has(value);
+}
+function isPackageManager(value) {
+	return PACKAGE_MANAGERS.has(value);
+}
+function isStylingOption(value) {
+	return STYLING_OPTIONS.has(value);
+}
+function splitInlineFlag(token) {
+	const eqIndex = token.startsWith("--") ? token.indexOf("=") : -1;
+	if (eqIndex === -1) return {
+		name: token,
+		inlineValue: void 0
+	};
+	return {
+		name: token.slice(0, eqIndex),
+		inlineValue: token.slice(eqIndex + 1)
+	};
+}
+function assertNoInlineValue(flagName, inlineValue) {
+	if (inlineValue !== void 0) throw new CliUsageError(`"${flagName}" doesn't take a value — just "${flagName}".`);
+}
+function usageErrorFor(kind, input, candidates) {
+	const suggestion = findClosestMatch(input, candidates);
+	return new CliUsageError(`Unknown ${kind === "command" ? "command" : "flag"} "${input}"${suggestion ? ` — did you mean "${suggestion}"?` : "."} Run "@symbiote-native/cli --help" for usage.`);
+}
+function requireEnumValue(flag, rawValue, isValid, validValues) {
+	if (rawValue === void 0 || rawValue.startsWith("--")) throw new CliUsageError(`"${flag}" needs a value. Valid values: ${validValues.join(", ")}.`);
+	if (!isValid(rawValue)) throw new CliUsageError(`"${flag} ${rawValue}" is invalid. Valid values: ${validValues.join(", ")}.`);
+	return rawValue;
+}
+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"]);
+	let appName;
+	let framework;
+	let vueFlavor;
+	let isJavascript = false;
+	let hasForce = false;
+	let bundleId;
+	let hasExpoModules = false;
+	let hasNavigation = false;
+	let hasTesting = false;
+	let hasSplashScreen = false;
+	let hasSlider = false;
+	const expoPackages = /* @__PURE__ */ new Set();
+	let styling;
+	let packageManager;
+	for (let index = 0; index < rest.length; index += 1) {
+		const { name: token, inlineValue } = splitInlineFlag(rest[index]);
+		if (token === "--javascript") {
+			assertNoInlineValue(token, inlineValue);
+			isJavascript = true;
+			continue;
+		}
+		if (token === "--force") {
+			assertNoInlineValue(token, inlineValue);
+			hasForce = true;
+			continue;
+		}
+		if (token === "--expo-modules") {
+			assertNoInlineValue(token, inlineValue);
+			hasExpoModules = true;
+			continue;
+		}
+		if (token === "--navigation") {
+			assertNoInlineValue(token, inlineValue);
+			hasNavigation = true;
+			continue;
+		}
+		if (token === "--testing") {
+			assertNoInlineValue(token, inlineValue);
+			hasTesting = true;
+			continue;
+		}
+		if (token === "--splash-screen") {
+			assertNoInlineValue(token, inlineValue);
+			hasSplashScreen = true;
+			continue;
+		}
+		if (token === "--slider") {
+			assertNoInlineValue(token, inlineValue);
+			hasSlider = true;
+			continue;
+		}
+		const expoPackageId = token.startsWith("--") ? token.slice(2) : "";
+		if (isExpoPackageLayerName(expoPackageId)) {
+			assertNoInlineValue(token, inlineValue);
+			expoPackages.add(expoPackageId);
+			continue;
+		}
+		if (token === "--framework") {
+			framework = requireEnumValue(token, inlineValue ?? rest[index + 1], isFramework, [...FRAMEWORKS]);
+			if (inlineValue === void 0) index += 1;
+			continue;
+		}
+		if (token === "--bundle-id") {
+			const value = inlineValue ?? rest[index + 1];
+			if (value === void 0 || value.startsWith("--")) throw new CliUsageError(`"${token}" needs a value, e.g. "com.example.app".`);
+			bundleId = value;
+			if (inlineValue === void 0) index += 1;
+			continue;
+		}
+		if (token === "--styling") {
+			styling = requireEnumValue(token, inlineValue ?? rest[index + 1], isStylingOption, [...STYLING_OPTIONS]);
+			if (inlineValue === void 0) index += 1;
+			continue;
+		}
+		if (token === "--vue-flavor") {
+			vueFlavor = requireEnumValue(token, inlineValue ?? rest[index + 1], isVueFlavor, [...VUE_FLAVORS]);
+			if (inlineValue === void 0) index += 1;
+			continue;
+		}
+		if (token === "--pm") {
+			packageManager = requireEnumValue(token, inlineValue ?? rest[index + 1], isPackageManager, [...PACKAGE_MANAGERS]);
+			if (inlineValue === void 0) index += 1;
+			continue;
+		}
+		if (token.startsWith("--")) throw usageErrorFor("flag", token, KNOWN_FLAGS);
+		if (command === "add") throw new CliUsageError(`"add" doesn't take a positional argument — got "${token}".`);
+		if (appName === void 0) {
+			appName = token;
+			continue;
+		}
+		throw new CliUsageError(`Unexpected argument "${token}" — "new" takes one app name.`);
+	}
+	if (command === "new") return {
+		kind: "new",
+		appName,
+		framework,
+		vueFlavor,
+		isJavascript,
+		hasForce,
+		bundleId,
+		hasExpoModules,
+		hasNavigation,
+		hasTesting,
+		hasSplashScreen,
+		hasSlider,
+		expoPackages,
+		styling,
+		packageManager
+	};
+	return {
+		kind: "add",
+		framework,
+		vueFlavor,
+		hasExpoModules,
+		hasNavigation,
+		hasTesting,
+		hasSplashScreen,
+		hasSlider,
+		expoPackages,
+		hasForce,
+		packageManager
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+const getCodePointsLength = (() => {
+	const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	return (input) => {
+		let surrogatePairsNr = 0;
+		SURROGATE_PAIR_RE.lastIndex = 0;
+		while (SURROGATE_PAIR_RE.test(input)) surrogatePairsNr += 1;
+		return input.length - surrogatePairsNr;
+	};
+})();
+const isFullWidth = (x) => {
+	return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+const isWideNotCJKTNotEmoji = (x) => {
+	return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+const ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+const CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+const NO_TRUNCATION$1 = {
+	limit: Infinity,
+	ellipsis: ""
+};
+const getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+	const LIMIT = truncationOptions.limit ?? Infinity;
+	const ELLIPSIS = truncationOptions.ellipsis ?? "";
+	const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION$1, widthOptions).width : 0);
+	const ANSI_WIDTH = 0;
+	const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+	const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+	const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+	const FULL_WIDTH_WIDTH = 2;
+	const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+	const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+	const PARSE_BLOCKS = [
+		[LATIN_RE, REGULAR_WIDTH],
+		[ANSI_RE, ANSI_WIDTH],
+		[CONTROL_RE, CONTROL_WIDTH],
+		[TAB_RE, TAB_WIDTH],
+		[EMOJI_RE, EMOJI_WIDTH],
+		[CJKT_WIDE_RE, WIDE_WIDTH]
+	];
+	let indexPrev = 0;
+	let index = 0;
+	let length = input.length;
+	let lengthExtra = 0;
+	let truncationEnabled = false;
+	let truncationIndex = length;
+	let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+	let unmatchedStart = 0;
+	let unmatchedEnd = 0;
+	let width = 0;
+	let widthExtra = 0;
+	outer: while (true) {
+		if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+			const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+			lengthExtra = 0;
+			for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+				const codePoint = char.codePointAt(0) || 0;
+				if (isFullWidth(codePoint)) widthExtra = FULL_WIDTH_WIDTH;
+				else if (isWideNotCJKTNotEmoji(codePoint)) widthExtra = WIDE_WIDTH;
+				else widthExtra = REGULAR_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				lengthExtra += char.length;
+				width += widthExtra;
+			}
+			unmatchedStart = unmatchedEnd = 0;
+		}
+		if (index >= length) break outer;
+		for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+			const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+			BLOCK_RE.lastIndex = index;
+			if (BLOCK_RE.test(input)) {
+				lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+				widthExtra = lengthExtra * BLOCK_WIDTH;
+				if (width + widthExtra > truncationLimit) truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+				if (width + widthExtra > LIMIT) {
+					truncationEnabled = true;
+					break outer;
+				}
+				width += widthExtra;
+				unmatchedStart = indexPrev;
+				unmatchedEnd = index;
+				index = indexPrev = BLOCK_RE.lastIndex;
+				continue outer;
+			}
+		}
+		index += 1;
+	}
+	return {
+		width: truncationEnabled ? truncationLimit : width,
+		index: truncationEnabled ? truncationIndex : length,
+		truncated: truncationEnabled,
+		ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+const NO_TRUNCATION = {
+	limit: Infinity,
+	ellipsis: "",
+	ellipsisWidth: 0
+};
+const fastStringWidth = (input, options = {}) => {
+	return getStringTruncatedWidth(input, NO_TRUNCATION, options).width;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+const ESC = "\x1B";
+const CSI = "›";
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_OSC = "]";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+const getClosingCode = (openingCode) => {
+	if (openingCode >= 30 && openingCode <= 37) return 39;
+	if (openingCode >= 90 && openingCode <= 97) return 39;
+	if (openingCode >= 40 && openingCode <= 47) return 49;
+	if (openingCode >= 100 && openingCode <= 107) return 49;
+	if (openingCode === 1 || openingCode === 2) return 22;
+	if (openingCode === 3) return 23;
+	if (openingCode === 4) return 24;
+	if (openingCode === 7) return 27;
+	if (openingCode === 8) return 28;
+	if (openingCode === 9) return 29;
+	if (openingCode === 0) return 0;
+};
+const wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+const wrapWord = (rows, word, columns) => {
+	const characters = word[Symbol.iterator]();
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let lastRow = rows.at(-1);
+	let visible = lastRow === void 0 ? 0 : fastStringWidth(lastRow);
+	let currentCharacter = characters.next();
+	let nextCharacter = characters.next();
+	let rawCharacterIndex = 0;
+	while (!currentCharacter.done) {
+		const character = currentCharacter.value;
+		const characterLength = fastStringWidth(character);
+		if (visible + characterLength <= columns) rows[rows.length - 1] += character;
+		else {
+			rows.push(character);
+			visible = 0;
+		}
+		if (character === ESC || character === CSI) {
+			isInsideEscape = true;
+			isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+		}
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) isInsideEscape = false;
+		} else {
+			visible += characterLength;
+			if (visible === columns && !nextCharacter.done) {
+				rows.push("");
+				visible = 0;
+			}
+		}
+		currentCharacter = nextCharacter;
+		nextCharacter = characters.next();
+		rawCharacterIndex += character.length;
+	}
+	lastRow = rows.at(-1);
+	if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) rows[rows.length - 2] += rows.pop();
+};
+const stringVisibleTrimSpacesRight = (string) => {
+	const words = string.split(" ");
+	let last = words.length;
+	while (last) {
+		if (fastStringWidth(words[last - 1])) break;
+		last--;
+	}
+	if (last === words.length) return string;
+	return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === "") return "";
+	let returnValue = "";
+	let escapeCode;
+	let escapeUrl;
+	const words = string.split(" ");
+	let rows = [""];
+	let rowLength = 0;
+	for (let index = 0; index < words.length; index++) {
+		const word = words[index];
+		if (options.trim !== false) {
+			const row = rows.at(-1) ?? "";
+			const trimmed = row.trimStart();
+			if (row.length !== trimmed.length) {
+				rows[rows.length - 1] = trimmed;
+				rowLength = fastStringWidth(trimmed);
+			}
+		}
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				rows.push("");
+				rowLength = 0;
+			}
+			if (rowLength || options.trim === false) {
+				rows[rows.length - 1] += " ";
+				rowLength++;
+			}
+		}
+		const wordLength = fastStringWidth(word);
+		if (options.hard && wordLength > columns) {
+			const remainingColumns = columns - rowLength;
+			const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+			if (Math.floor((wordLength - 1) / columns) < breaksStartingThisLine) rows.push("");
+			wrapWord(rows, word, columns);
+			rowLength = fastStringWidth(rows.at(-1) ?? "");
+			continue;
+		}
+		if (rowLength + wordLength > columns && rowLength && wordLength) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				rowLength = fastStringWidth(rows.at(-1) ?? "");
+				continue;
+			}
+			rows.push("");
+			rowLength = 0;
+		}
+		if (rowLength + wordLength > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			rowLength = fastStringWidth(rows.at(-1) ?? "");
+			continue;
+		}
+		rows[rows.length - 1] += word;
+		rowLength += wordLength;
+	}
+	if (options.trim !== false) rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+	const preString = rows.join("\n");
+	let inSurrogate = false;
+	for (let i = 0; i < preString.length; i++) {
+		const character = preString[i];
+		returnValue += character;
+		if (!inSurrogate) {
+			inSurrogate = character >= "\ud800" && character <= "\udbff";
+			if (inSurrogate) continue;
+		} else inSurrogate = false;
+		if (character === ESC || character === CSI) {
+			GROUP_REGEX.lastIndex = i + 1;
+			const groups = GROUP_REGEX.exec(preString)?.groups;
+			if (groups?.code !== void 0) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? void 0 : code;
+			} else if (groups?.uri !== void 0) escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+		}
+		if (preString[i + 1] === "\n") {
+			if (escapeUrl) returnValue += wrapAnsiHyperlink("");
+			const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+			if (escapeCode && closingCode) returnValue += wrapAnsiCode(closingCode);
+		} else if (character === "\n") {
+			if (escapeCode && getClosingCode(escapeCode)) returnValue += wrapAnsiCode(escapeCode);
+			if (escapeUrl) returnValue += wrapAnsiHyperlink(escapeUrl);
+		}
+	}
+	return returnValue;
+};
+const CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+	return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+var import_src = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ESC = "\x1B";
+	const CSI = `${ESC}[`;
+	const beep = "\x07";
+	const cursor = {
+		to(x, y) {
+			if (!y) return `${CSI}${x + 1}G`;
+			return `${CSI}${y + 1};${x + 1}H`;
+		},
+		move(x, y) {
+			let ret = "";
+			if (x < 0) ret += `${CSI}${-x}D`;
+			else if (x > 0) ret += `${CSI}${x}C`;
+			if (y < 0) ret += `${CSI}${-y}A`;
+			else if (y > 0) ret += `${CSI}${y}B`;
+			return ret;
+		},
+		up: (count = 1) => `${CSI}${count}A`,
+		down: (count = 1) => `${CSI}${count}B`,
+		forward: (count = 1) => `${CSI}${count}C`,
+		backward: (count = 1) => `${CSI}${count}D`,
+		nextLine: (count = 1) => `${CSI}E`.repeat(count),
+		prevLine: (count = 1) => `${CSI}F`.repeat(count),
+		left: `${CSI}G`,
+		hide: `${CSI}?25l`,
+		show: `${CSI}?25h`,
+		save: `${ESC}7`,
+		restore: `${ESC}8`
+	};
+	module.exports = {
+		cursor,
+		scroll: {
+			up: (count = 1) => `${CSI}S`.repeat(count),
+			down: (count = 1) => `${CSI}T`.repeat(count)
+		},
+		erase: {
+			screen: `${CSI}2J`,
+			up: (count = 1) => `${CSI}1J`.repeat(count),
+			down: (count = 1) => `${CSI}J`.repeat(count),
+			line: `${CSI}2K`,
+			lineEnd: `${CSI}K`,
+			lineStart: `${CSI}1K`,
+			lines(count) {
+				let clear = "";
+				for (let i = 0; i < count; i++) clear += this.line + (i < count - 1 ? cursor.up() : "");
+				if (count) clear += cursor.left;
+				return clear;
+			}
+		},
+		beep
+	};
+})))();
+function findCursor(s, o, l) {
+	if (!l.some((r) => !r.disabled)) return s;
+	const t = s + o, n = Math.max(l.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+	return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : e;
+}
+const settings = {
+	actions: /* @__PURE__ */ new Set([
+		"up",
+		"down",
+		"left",
+		"right",
+		"space",
+		"enter",
+		"cancel"
+	]),
+	aliases: /* @__PURE__ */ new Map([
+		["k", "up"],
+		["j", "down"],
+		["h", "left"],
+		["l", "right"],
+		["", "cancel"],
+		["escape", "cancel"]
+	]),
+	messages: {
+		cancel: "Canceled",
+		error: "Something went wrong"
+	},
+	withGuide: true,
+	date: {
+		monthNames: [...[
+			"January",
+			"February",
+			"March",
+			"April",
+			"May",
+			"June",
+			"July",
+			"August",
+			"September",
+			"October",
+			"November",
+			"December"
+		]],
+		messages: {
+			required: "Please enter a valid date",
+			invalidMonth: "There are only 12 months in a year",
+			invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+			afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+			beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+		}
+	}
+};
+function isActionKey(n, e) {
+	if (typeof n == "string") return settings.aliases.get(n) === e;
+	for (const s of n) if (s !== void 0 && isActionKey(s, e)) return true;
+	return false;
+}
+function diffLines(i, s) {
+	if (i === s) return;
+	const e = i.split(`
+`), t = s.split(`
+`), r = Math.max(e.length, t.length), f = [];
+	for (let n = 0; n < r; n++) e[n] !== t[n] && f.push(n);
+	return {
+		lines: f,
+		numLinesBefore: e.length,
+		numLinesAfter: t.length,
+		numLines: r
+	};
+}
+globalThis.process.platform.startsWith("win");
+const CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+	return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+	const o = e;
+	o.isTTY && o.setRawMode(r);
+}
+const getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80;
+const getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, t = o, s = o, n) {
+	return wrapAnsi(r, getColumns(e ?? stdout) - o.length, {
+		hard: true,
+		trim: false
+	}).split(`
+`).map((c, i, m) => {
+		const d = n ? n(c, i) : c;
+		return i === 0 ? `${t}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+	}).join(`
+`);
+}
+function runValidation(e, n) {
+	if ("~standard" in e) {
+		const a = e["~standard"].validate(n);
+		if (a instanceof Promise) throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+		return a.issues?.at(0)?.message;
+	}
+	return e(n);
+}
+var V = class {
+	input;
+	output;
+	_abortSignal;
+	rl;
+	opts;
+	_render;
+	_track = false;
+	_prevFrame = "";
+	_subscribers = /* @__PURE__ */ new Map();
+	_cursor = 0;
+	state = "initial";
+	error = "";
+	value;
+	userInput = "";
+	constructor(t, e = true) {
+		const { input: i = stdin, output: n = stdout, render: s, signal: r, ...o } = t;
+		this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+	}
+	/**
+	* Unsubscribe all listeners
+	*/
+	unsubscribe() {
+		this._subscribers.clear();
+	}
+	/**
+	* Set a subscriber with opts
+	* @param event - The event name
+	*/
+	setSubscriber(t, e) {
+		const i = this._subscribers.get(t) ?? [];
+		i.push(e), this._subscribers.set(t, i);
+	}
+	/**
+	* Subscribe to an event
+	* @param event - The event name
+	* @param cb - The callback
+	*/
+	on(t, e) {
+		this.setSubscriber(t, { cb: e });
+	}
+	/**
+	* Subscribe to an event once
+	* @param event - The event name
+	* @param cb - The callback
+	*/
+	once(t, e) {
+		this.setSubscriber(t, {
+			cb: e,
+			once: true
+		});
+	}
+	/**
+	* Emit an event with data
+	* @param event - The event name
+	* @param data - The data to pass to the callback
+	*/
+	emit(t, ...e) {
+		const i = this._subscribers.get(t) ?? [], n = [];
+		for (const s of i) s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+		for (const s of n) s();
+	}
+	prompt() {
+		return new Promise((t) => {
+			if (this._abortSignal) {
+				if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t(CANCEL_SYMBOL);
+				this._abortSignal.addEventListener("abort", () => {
+					this.state = "cancel", this.close();
+				}, { once: true });
+			}
+			this.rl = l__default.createInterface({
+				input: this.input,
+				tabSize: 2,
+				prompt: "",
+				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.once("cancel", () => {
+				this.output.write(import_src.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t(CANCEL_SYMBOL);
+			});
+		});
+	}
+	_isActionKey(t, e) {
+		return t === "	";
+	}
+	_shouldSubmit(t, e) {
+		return true;
+	}
+	_setValue(t) {
+		this.value = t, this.emit("value", this.value);
+	}
+	_setUserInput(t, e) {
+		this.userInput = t ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+	}
+	_clearUserInput() {
+		this.rl?.write(null, {
+			ctrl: true,
+			name: "u"
+		}), this._setUserInput("");
+	}
+	onKeypress(t, e) {
+		if (this._track && e.name !== "return" && (e.name && this._isActionKey(t, e) && this.rl?.write(null, {
+			ctrl: true,
+			name: "h"
+		}), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t, e), e?.name === "return" && this._shouldSubmit(t, e)) {
+			if (this.opts.validate) {
+				const i = runValidation(this.opts.validate, this.value);
+				i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+			}
+			this.state !== "error" && (this.state = "submit");
+		}
+		isActionKey([
+			t,
+			e?.name,
+			e?.sequence
+		], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+	}
+	close() {
+		this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+	}
+	restoreCursor() {
+		const t = wrapAnsi(this._prevFrame, process.stdout.columns, {
+			hard: true,
+			trim: false
+		}).split(`
+`).length - 1;
+		this.output.write(import_src.cursor.move(-999, t * -1));
+	}
+	render() {
+		const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+			hard: true,
+			trim: false
+		});
+		if (t !== this._prevFrame) {
+			if (this.state === "initial") this.output.write(import_src.cursor.hide);
+			else {
+				const e = diffLines(this._prevFrame, t), i = getRows(this.output);
+				if (this.restoreCursor(), e) {
+					const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+					let r = e.lines.find((o) => o >= n);
+					if (r === void 0) {
+						this._prevFrame = t;
+						return;
+					}
+					if (e.lines.length === 1) {
+						this.output.write(import_src.cursor.move(0, r - s)), this.output.write(import_src.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));
+						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));
+						}
+						this.output.write(import_src.erase.down());
+						const f = t.split(`
+`).slice(r);
+						this.output.write(f.join(`
+`)), this._prevFrame = t;
+						return;
+					}
+				}
+				this.output.write(import_src.erase.down());
+			}
+			this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+		}
+	}
+};
+var r = class extends V {
+	get cursor() {
+		return this.value ? 0 : 1;
+	}
+	get _value() {
+		return this.cursor === 0;
+	}
+	constructor(t) {
+		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.on("cursor", () => {
+			this.value = !this.value;
+		});
+	}
+};
+let u$2 = class u extends V {
+	options;
+	cursor = 0;
+	#t;
+	getGroupItems(t) {
+		return this.options.filter((r) => r.group === t);
+	}
+	isGroupSelected(t) {
+		const r = this.getGroupItems(t), e = this.value;
+		return e === void 0 ? false : r.every((s) => e.includes(s.value));
+	}
+	toggleValue() {
+		const t = this.options[this.cursor];
+		if (t !== void 0) if (this.value === void 0 && (this.value = []), t.group === true) {
+			const r = t.value, e = this.getGroupItems(r);
+			this.isGroupSelected(r) ? this.value = this.value.filter((s) => e.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
+		} else {
+			const r = this.value.includes(t.value);
+			this.value = r ? this.value.filter((e) => e !== t.value) : [...this.value, t.value];
+		}
+	}
+	constructor(t) {
+		super(t, false);
+		const { options: r } = t;
+		this.#t = t.selectableGroups !== false, this.options = Object.entries(r).flatMap(([e, s]) => [{
+			value: e,
+			group: true,
+			label: e
+		}, ...s.map((i) => ({
+			...i,
+			group: e
+		}))]), this.value = [...t.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: e }) => e === t.cursorAt), this.#t ? 0 : 1), this.on("cursor", (e) => {
+			switch (e) {
+				case "left":
+				case "up": {
+					this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+					const s = this.options[this.cursor]?.group === true;
+					!this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
+					break;
+				}
+				case "down":
+				case "right": {
+					this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+					const s = this.options[this.cursor]?.group === true;
+					!this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
+					break;
+				}
+				case "space":
+					this.toggleValue();
+					break;
+			}
+		});
+	}
+};
+var a = class extends V {
+	options;
+	cursor = 0;
+	get _value() {
+		return this.options[this.cursor]?.value;
+	}
+	get _enabledOptions() {
+		return this.options.filter((e) => e.disabled !== true);
+	}
+	toggleAll() {
+		const e = this._enabledOptions, i = this.value !== void 0 && this.value.length === e.length;
+		this.value = i ? [] : e.map((t) => t.value);
+	}
+	toggleInvert() {
+		const e = this.value;
+		if (!e) return;
+		const i = this._enabledOptions.filter((t) => !e.includes(t.value));
+		this.value = i.map((t) => t.value);
+	}
+	toggleValue() {
+		this.value === void 0 && (this.value = []);
+		const e = this.value.includes(this._value);
+		this.value = e ? this.value.filter((i) => i !== this._value) : [...this.value, this._value];
+	}
+	constructor(e) {
+		super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+		const i = Math.max(this.options.findIndex(({ value: t }) => t === e.cursorAt), 0);
+		this.cursor = this.options[i]?.disabled ? findCursor(i, 1, this.options) : i, this.on("key", (t, l) => {
+			l.name === "a" && this.toggleAll(), l.name === "i" && this.toggleInvert();
+		}), this.on("cursor", (t) => {
+			switch (t) {
+				case "left":
+				case "up":
+					this.cursor = findCursor(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = findCursor(this.cursor, 1, this.options);
+					break;
+				case "space":
+					this.toggleValue();
+					break;
+			}
+		});
+	}
+};
+let n$1 = class n extends V {
+	options;
+	cursor = 0;
+	get _selectedValue() {
+		return this.options[this.cursor];
+	}
+	changeValue() {
+		const e = this._selectedValue;
+		this.value = e === void 0 ? void 0 : e.value;
+	}
+	constructor(e) {
+		super(e, false), this.options = e.options;
+		const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t = o === -1 ? 0 : o;
+		this.cursor = this.options[t]?.disabled ? findCursor(t, 1, this.options) : t, this.changeValue(), this.on("cursor", (s) => {
+			switch (s) {
+				case "left":
+				case "up":
+					this.cursor = findCursor(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = findCursor(this.cursor, 1, this.options);
+					break;
+			}
+			this.changeValue();
+		});
+	}
+};
+var n = class extends V {
+	get userInputWithCursor() {
+		if (this.state === "submit") return this.userInput;
+		const t = this.userInput;
+		if (this.cursor >= t.length) return `${this.userInput}\u2588`;
+		const r = t.slice(0, this.cursor), s = t.slice(this.cursor, this.cursor + 1), e = t.slice(this.cursor + 1);
+		return `${r}${styleText("inverse", s)}${e}`;
+	}
+	get cursor() {
+		return this._cursor;
+	}
+	constructor(t) {
+		super({
+			...t,
+			initialUserInput: t.initialUserInput ?? t.initialValue
+		}), this.on("userInput", (r) => {
+			this._setValue(r);
+		}), this.on("finalize", () => {
+			this.value || (this.value = t.defaultValue), this.value === void 0 && (this.value = "");
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
+function isUnicodeSupported() {
+	if (process$1.platform !== "win32") return process$1.env.TERM !== "linux";
+	return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+const unicode = isUnicodeSupported();
+const unicodeOr = (o, e) => unicode ? o : e;
+const S_STEP_ACTIVE = unicodeOr("◆", "*");
+const S_STEP_CANCEL = unicodeOr("■", "x");
+const S_STEP_ERROR = unicodeOr("▲", "x");
+const S_STEP_SUBMIT = unicodeOr("◇", "o");
+const S_BAR_START = unicodeOr("┌", "T");
+const S_BAR = unicodeOr("│", "|");
+const S_BAR_END = unicodeOr("└", "—");
+const S_RADIO_ACTIVE = unicodeOr("●", ">");
+const S_RADIO_INACTIVE = unicodeOr("○", " ");
+const S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+const S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+const S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+const symbol = (o) => {
+	switch (o) {
+		case "initial":
+		case "active": return styleText("cyan", S_STEP_ACTIVE);
+		case "cancel": return styleText("red", S_STEP_CANCEL);
+		case "error": return styleText("yellow", S_STEP_ERROR);
+		case "submit": return styleText("green", S_STEP_SUBMIT);
+	}
+};
+const symbolBar = (o) => {
+	switch (o) {
+		case "initial":
+		case "active": return styleText("cyan", S_BAR);
+		case "cancel": return styleText("red", S_BAR);
+		case "error": return styleText("yellow", S_BAR);
+		case "submit": return styleText("green", S_BAR);
+	}
+};
+function formatInstructionFooter(o, e) {
+	const r = [`${e ? `${styleText("cyan", S_BAR)}  ` : ""}${o.join(" • ")}`];
+	return e && r.push(styleText("cyan", S_BAR_END)), r;
+}
+const I = (l, e, w, p, b, C = false) => {
+	let r = e, O = 0;
+	if (C) for (let i = p - 1; i >= w; i--) {
+		const m = l[i];
+		if (m && (r -= m.length), O++, r <= b) break;
+	}
+	else for (let i = w; i < p; i++) {
+		const m = l[i];
+		if (m && (r -= m.length), O++, r <= b) break;
+	}
+	return {
+		lineCount: r,
+		removals: O
+	};
+};
+const limitOptions = ({ cursor: l, options: e, style: w, output: p = process.stdout, maxItems: b = Number.POSITIVE_INFINITY, columnPadding: C = 0, rowPadding: r = 4 }) => {
+	const i = getColumns(p) - C, m = getRows(p), M = styleText("dim", "..."), v = Math.max(m - r, 0), a = Math.max(Math.min(b, v), 5);
+	let f = 0;
+	l >= a - 3 && (f = Math.max(Math.min(l - a + 3, e.length - a), 0));
+	let d = a < e.length && f > 0, c = a < e.length && f + a < e.length;
+	const W = Math.min(f + a, e.length), s = [];
+	let g = 0;
+	d && g++, c && g++;
+	const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+	for (let t = T; t < y; t++) {
+		const n = e[t], h = wrapAnsi(n ? w(n, t === l) : "", i, {
+			hard: true,
+			trim: false
+		}).split(`
+`);
+		s.push(h), g += h.length;
+	}
+	if (g > v) {
+		let t = 0, n = 0, o = g;
+		const h = l - T;
+		let u = v;
+		const L = () => I(s, o, 0, h, u), E = () => I(s, o, h + 1, s.length, u, true);
+		d ? ({lineCount: o, removals: t} = L(), o > u && (c || (u -= 1), {lineCount: o, removals: n} = E())) : (c || (u -= 1), {lineCount: o, removals: n} = E(), o > u && (u -= 1, {lineCount: o, removals: t} = L())), t > 0 && (d = true, s.splice(0, t)), n > 0 && (c = true, s.splice(s.length - n, n));
+	}
+	const x = [];
+	d && x.push(M);
+	for (const t of s) for (const n of t) x.push(n);
+	return c && x.push(M), x;
+};
+const confirm = (i) => {
+	const a = i.active ?? "Yes", s = i.inactive ?? "No";
+	return new r({
+		active: a,
+		inactive: s,
+		signal: i.signal,
+		input: i.input,
+		output: i.output,
+		initialValue: i.initialValue ?? true,
+		render() {
+			const e = i.withGuide ?? settings.withGuide, u = `${symbol(this.state)}  `, l = e ? `${styleText("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(i.output, i.message, l, u), o = `${e ? `${styleText("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a : s;
+			switch (this.state) {
+				case "submit": return `${o}${e ? `${styleText("gray", S_BAR)}  ` : ""}${styleText("dim", c)}`;
+				case "cancel": return `${o}${e ? `${styleText("gray", S_BAR)}  ` : ""}${styleText(["strikethrough", "dim"], c)}${e ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				default: {
+					const r = e ? `${styleText("cyan", S_BAR)}  ` : "", g = e ? styleText("cyan", S_BAR_END) : "";
+					return `${o}${r}${this.value ? `${styleText("green", S_RADIO_ACTIVE)} ${a}` : `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", a)}`}${i.vertical ? e ? `
+${styleText("cyan", S_BAR)}  ` : `
+` : ` ${styleText("dim", "/")} `}${this.value ? `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", s)}` : `${styleText("green", S_RADIO_ACTIVE)} ${s}`}
+${g}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+const MULTISELECT_INSTRUCTIONS = [
+	`${styleText("dim", "↑/↓")} to navigate`,
+	`${styleText("dim", "Space:")} select`,
+	`${styleText("dim", "Enter:")} confirm`
+];
+const m = (i, u) => i.split(`
+`).map((d) => u(d)).join(`
+`);
+const multiselect = (i) => {
+	const u = (t, a) => {
+		const r = t.label ?? String(t.value);
+		return a === "disabled" ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${m(r, (o) => styleText(["strikethrough", "gray"], o))}${t.hint ? ` ${styleText("dim", `(${t.hint ?? "disabled"})`)}` : ""}` : a === "active" ? `${styleText("cyan", S_CHECKBOX_ACTIVE)} ${r}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${m(r, (o) => styleText("dim", o))}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "cancelled" ? `${m(r, (o) => styleText(["strikethrough", "dim"], o))}` : a === "active-selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${r}${t.hint ? ` ${styleText("dim", `(${t.hint})`)}` : ""}` : a === "submitted" ? `${m(r, (o) => styleText("dim", o))}` : `${styleText("dim", S_CHECKBOX_INACTIVE)} ${m(r, (o) => styleText("dim", o))}`;
+	}, d = i.required ?? true, v = i.showInstructions ?? true;
+	return new a({
+		options: i.options,
+		signal: i.signal,
+		input: i.input,
+		output: i.output,
+		initialValues: i.initialValues,
+		required: d,
+		cursorAt: i.cursorAt,
+		validate(t) {
+			if (d && (t === void 0 || t.length === 0)) return `Please select at least one option.
+${styleText("reset", styleText("dim", `Press ${styleText([
+				"gray",
+				"bgWhite",
+				"inverse"
+			], " space ")} to select, ${styleText("gray", styleText("bgWhite", styleText("inverse", " enter ")))} to submit`))}`;
+		},
+		render() {
+			const t = i.withGuide ?? settings.withGuide, a = wrapTextWithPrefix(i.output, i.message, t ? `${symbolBar(this.state)}  ` : "", `${symbol(this.state)}  `), r = `${t ? `${styleText("gray", S_BAR)}
+` : ""}${a}
+`, o = this.value ?? [], p = (n, l) => {
+				if (n.disabled) return u(n, "disabled");
+				const s = o.includes(n.value);
+				return l && s ? u(n, "active-selected") : s ? u(n, "selected") : u(n, l ? "active" : "inactive");
+			};
+			switch (this.state) {
+				case "submit": {
+					const n = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u(s, "submitted")).join(styleText("dim", ", ")) || styleText("dim", "none");
+					return `${r}${wrapTextWithPrefix(i.output, n, t ? `${styleText("gray", S_BAR)}  ` : "")}`;
+				}
+				case "cancel": {
+					const n = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u(s, "cancelled")).join(styleText("dim", ", "));
+					if (n.trim() === "") return `${r}${styleText("gray", S_BAR)}`;
+					return `${r}${wrapTextWithPrefix(i.output, n, t ? `${styleText("gray", S_BAR)}  ` : "")}${t ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				}
+				case "error": {
+					const n = t ? `${styleText("yellow", S_BAR)}  ` : "", l = this.error.split(`
+`).map(($, C) => C === 0 ? `${t ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", $)}` : `   ${$}`).join(`
+`), s = r.split(`
+`).length, h = l.split(`
+`).length + 1;
+					return `${r}${n}${limitOptions({
+						output: i.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: i.maxItems,
+						columnPadding: n.length,
+						rowPadding: s + h,
+						style: p
+					}).join(`
+${n}`)}
+${l}
+`;
+				}
+				default: {
+					const n = t ? `${styleText("cyan", S_BAR)}  ` : "", l = r.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t) : t ? [styleText("cyan", S_BAR_END)] : [], h = s.join(`
+`), $ = s.length + 1;
+					return `${r}${n}${limitOptions({
+						output: i.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: i.maxItems,
+						columnPadding: n.length,
+						rowPadding: l + $,
+						style: p
+					}).join(`
+${n}`)}
+${h}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+const groupMultiselect = (o) => {
+	const { selectableGroups: h = true, groupSpacing: x = 0 } = o, m = (n, l, g = []) => {
+		const a = n.label ?? String(n.value), t = typeof n.group == "string", s = t && (g[g.indexOf(n) + 1] ?? { group: true }), u = t && s && s.group === true;
+		let r = "", c = "";
+		t && (h ? (r = u ? `${S_BAR_END} ` : `${S_BAR} `, c = u ? "  " : `${S_BAR} `) : r = "  ");
+		let i = "";
+		if (x > 0 && !t && (i = `
+`.repeat(x)), l === "active") return wrapTextWithPrefix(o.output, `${a}${n.hint ? ` ${styleText("dim", `(${n.hint})`)}` : ""}`, `${i}${styleText("dim", r)} `, `${i}${styleText("dim", r)}${styleText("cyan", S_CHECKBOX_ACTIVE)} `, `${i}${styleText("dim", c)} `);
+		if (l === "group-active") return wrapTextWithPrefix(o.output, a, `${i}${r} `, `${i}${r}${styleText("cyan", S_CHECKBOX_ACTIVE)} `, `${i}${c} `, (d) => styleText("dim", d));
+		if (l === "group-active-selected") return wrapTextWithPrefix(o.output, a, `${i}${r} `, `${i}${r}${styleText("green", S_CHECKBOX_SELECTED)} `, `${i}${c} `, (d) => styleText("dim", d));
+		if (l === "selected") {
+			const d = t || h ? styleText("green", S_CHECKBOX_SELECTED) : "";
+			return wrapTextWithPrefix(o.output, `${a}${n.hint ? ` (${n.hint})` : ""}`, `${i}${styleText("dim", r)} `, `${i}${styleText("dim", r)}${d} `, `${i}${styleText("dim", c)} `, (S) => styleText("dim", S));
+		}
+		if (l === "cancelled") return `${styleText(["strikethrough", "dim"], a)}`;
+		if (l === "active-selected") return wrapTextWithPrefix(o.output, `${a}${n.hint ? ` ${styleText("dim", `(${n.hint})`)}` : ""}`, `${i}${styleText("dim", r)} `, `${i}${styleText("dim", r)}${styleText("green", S_CHECKBOX_SELECTED)} `, `${i}${styleText("dim", c)} `);
+		if (l === "submitted") return `${styleText("dim", a)}`;
+		const f = t || h ? styleText("dim", S_CHECKBOX_INACTIVE) : "";
+		return wrapTextWithPrefix(o.output, a, `${i}${styleText("dim", r)} `, `${i}${styleText("dim", r)}${f} `, `${i}${styleText("dim", c)} `, (d) => styleText("dim", d));
+	}, y = o.required ?? true, I = o.showInstructions ?? true;
+	return new u$2({
+		options: o.options,
+		signal: o.signal,
+		input: o.input,
+		output: o.output,
+		initialValues: o.initialValues,
+		required: y,
+		cursorAt: o.cursorAt,
+		selectableGroups: h,
+		validate(n) {
+			if (y && (n === void 0 || n.length === 0)) return `Please select at least one option.
+${styleText("reset", styleText("dim", `Press ${styleText([
+				"gray",
+				"bgWhite",
+				"inverse"
+			], " space ")} to select, ${styleText("gray", styleText(["bgWhite", "inverse"], " enter "))} to submit`))}`;
+		},
+		render() {
+			const n = o.withGuide ?? settings.withGuide, l = `${n ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${o.message}
+`, g = this.value ?? [], a = (t, s) => {
+				const u = this.options, r = g.includes(t.value) || t.group === true && this.isGroupSelected(`${t.value}`);
+				return !s && typeof t.group == "string" && this.options[this.cursor]?.value === t.group ? m(t, r ? "group-active-selected" : "group-active", u) : s && r ? m(t, "active-selected", u) : r ? m(t, "selected", u) : m(t, s ? "active" : "inactive", u);
+			};
+			switch (this.state) {
+				case "submit": {
+					const t = this.options.filter(({ value: u }) => g.includes(u)).map((u) => m(u, "submitted")), s = t.length === 0 ? "" : `  ${t.join(styleText("dim", ", "))}`;
+					return `${l}${n ? styleText("gray", S_BAR) : ""}${s}`;
+				}
+				case "cancel": {
+					const t = this.options.filter(({ value: s }) => g.includes(s)).map((s) => m(s, "cancelled")).join(styleText("dim", ", "));
+					return `${l}${n ? `${styleText("gray", S_BAR)}  ` : ""}${t.trim() ? `${t}${n ? `
+${styleText("gray", S_BAR)}` : ""}` : ""}`;
+				}
+				case "error": {
+					const t = n ? `${styleText("yellow", S_BAR)}  ` : "", s = this.error.split(`
+`).map((i, f) => f === 0 ? `${n ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", i)}` : `   ${i}`).join(`
+`), u = l.split(`
+`).length, r = s.split(`
+`).length + 1;
+					return `${l}${t}${limitOptions({
+						output: o.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: o.maxItems,
+						columnPadding: t.length,
+						rowPadding: u + r,
+						style: a
+					}).join(`
+${t}`)}
+${s}
+`;
+				}
+				default: {
+					const t = n ? `${styleText("cyan", S_BAR)}  ` : "", s = l.split(`
+`).length, u = I ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, n) : n ? [styleText("cyan", S_BAR_END)] : [], r = u.join(`
+`), c = u.length + 1;
+					return `${l}${t}${limitOptions({
+						output: o.output,
+						options: this.options,
+						cursor: this.cursor,
+						maxItems: o.maxItems,
+						columnPadding: t.length,
+						rowPadding: s + c,
+						style: a
+					}).join(`
+${t}`)}
+${r}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+const cancel = (o = "", t) => {
+	const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_END)}  ` : "";
+	i.write(`${e}${styleText("red", o)}
+
+`);
+};
+const intro = (o = "", t) => {
+	const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_START)}  ` : "";
+	i.write(`${e}${o}
+`);
+};
+const outro = (o = "", t) => {
+	const i = t?.output ?? process.stdout, e = t?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR)}
+${styleText("gray", S_BAR_END)}  ` : "";
+	i.write(`${e}${o}
+
+`);
+};
+const SELECT_INSTRUCTIONS = [`${styleText("dim", "↑/↓")} to navigate`, `${styleText("dim", "Enter:")} confirm`];
+const c = (t, o) => t.includes(`
+`) ? t.split(`
+`).map((d) => o(d)).join(`
+`) : o(t);
+const select = (t) => {
+	const o = (n, m) => {
+		if (n === void 0) return "";
+		const s = n.label ?? String(n.value);
+		switch (m) {
+			case "disabled": return `${styleText("gray", S_RADIO_INACTIVE)} ${c(s, (i) => styleText("gray", i))}${n.hint ? ` ${styleText("dim", `(${n.hint ?? "disabled"})`)}` : ""}`;
+			case "selected": return `${c(s, (i) => styleText("dim", i))}`;
+			case "active": return `${styleText("green", S_RADIO_ACTIVE)} ${s}${n.hint ? ` ${styleText("dim", `(${n.hint})`)}` : ""}`;
+			case "cancelled": return `${c(s, (i) => styleText(["strikethrough", "dim"], i))}`;
+			default: return `${styleText("dim", S_RADIO_INACTIVE)} ${c(s, (i) => styleText("dim", i))}`;
+		}
+	}, d = t.showInstructions ?? true;
+	return new n$1({
+		options: t.options,
+		signal: t.signal,
+		input: t.input,
+		output: t.output,
+		initialValue: t.initialValue,
+		render() {
+			const n = t.withGuide ?? settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i = wrapTextWithPrefix(t.output, t.message, s, m), u = `${n ? `${styleText("gray", S_BAR)}
+` : ""}${i}
+`;
+			switch (this.state) {
+				case "submit": {
+					const r = n ? `${styleText("gray", S_BAR)}  ` : "";
+					return `${u}${wrapTextWithPrefix(t.output, o(this.options[this.cursor], "selected"), r)}`;
+				}
+				case "cancel": {
+					const r = n ? `${styleText("gray", S_BAR)}  ` : "";
+					return `${u}${wrapTextWithPrefix(t.output, o(this.options[this.cursor], "cancelled"), r)}${n ? `
+${styleText("gray", S_BAR)}` : ""}`;
+				}
+				default: {
+					const r = n ? `${styleText("cyan", S_BAR)}  ` : "", a = u.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n) : n ? [styleText("cyan", S_BAR_END)] : [], b = p.join(`
+`), f = p.length + 1;
+					return `${u}${r}${limitOptions({
+						output: t.output,
+						cursor: this.cursor,
+						options: this.options,
+						maxItems: t.maxItems,
+						columnPadding: r.length,
+						rowPadding: a + f,
+						style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+					}).join(`
+${r}`)}
+${b}
+`;
+				}
+			}
+		}
+	}).prompt();
+};
+`${styleText("gray", S_BAR)}`;
+const text = (e) => new n({
+	validate: e.validate,
+	placeholder: e.placeholder,
+	defaultValue: e.defaultValue,
+	initialValue: e.initialValue,
+	output: e.output,
+	signal: e.signal,
+	input: e.input,
+	render() {
+		const i = e?.withGuide ?? settings.withGuide, s = `${`${i ? `${styleText("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, c = e.placeholder && e.placeholder.length > 0 ? styleText("inverse", e.placeholder[0]) + styleText("dim", e.placeholder.slice(1)) : styleText(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : c, l = this.value ?? "";
+		switch (this.state) {
+			case "error": {
+				const n = this.error ? `  ${styleText("yellow", this.error)}` : "", r = i ? `${styleText("yellow", S_BAR)}  ` : "", d = i ? styleText("yellow", S_BAR_END) : "";
+				return `${s.trim()}
+${r}${o}
+${d}${n}
+`;
+			}
+			case "submit": {
+				const n = l ? `  ${styleText("dim", l)}` : "";
+				return `${s}${i ? styleText("gray", S_BAR) : ""}${n}`;
+			}
+			case "cancel": {
+				const n = l ? `  ${styleText(["strikethrough", "dim"], l)}` : "", r = i ? styleText("gray", S_BAR) : "";
+				return `${s}${r}${n}${l.trim() ? `
+${r}` : ""}`;
+			}
+			default: return `${s}${i ? `${styleText("cyan", S_BAR)}  ` : ""}${o}
+${i ? styleText("cyan", S_BAR_END) : ""}
+`;
+		}
+	}
+}).prompt();
+//#endregion
+//#region src/template-dir.ts
+function resolveJsTemplateDir(framework, vueFlavor) {
+	if (framework !== "vue") return framework;
+	return `vue-${vueFlavor ?? "sfc"}`;
+}
+//#endregion
+//#region src/utils/apply-app-identity.ts
+const TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".plist",
+	".pbxproj",
+	".xcscheme",
+	".xcworkspacedata",
+	".storyboard",
+	".swift",
+	".kt",
+	".java",
+	".gradle",
+	".xml",
+	".json",
+	".js",
+	""
+]);
+function replaceTextContent(filePath, identity) {
+	const content = fs.readFileSync(filePath, "utf8");
+	const replaced = content.split("com.canary").join(identity.bundleId).split("Canary").join(identity.nativeAppName);
+	if (replaced !== content) fs.writeFileSync(filePath, replaced);
+}
+function walkTextFiles(dir, identity) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			walkTextFiles(entryPath, identity);
+			continue;
+		}
+		if (TEXT_FILE_EXTENSIONS.has(path.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 })) {
+		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);
+	}
+}
+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);
+}
+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);
+}
+//#endregion
+//#region src/utils/json.ts
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/utils/deep-merge.ts
+function mergeArrayWithDedupe(a, b) {
+	return Array.from(/* @__PURE__ */ new Set([...a, ...b]));
+}
+function deepMerge(target, source) {
+	for (const key of Object.keys(source)) {
+		const oldVal = target[key];
+		const newVal = source[key];
+		if (Array.isArray(oldVal) && Array.isArray(newVal)) target[key] = mergeArrayWithDedupe(oldVal, newVal);
+		else if (isJsonObject(oldVal) && isJsonObject(newVal)) target[key] = deepMerge(oldVal, newVal);
+		else target[key] = newVal;
+	}
+	return target;
+}
+//#endregion
+//#region src/utils/sort-dependencies.ts
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+function sortDependencies(packageJson) {
+	const sorted = {};
+	for (const field of DEPENDENCY_FIELDS) {
+		const deps = packageJson[field];
+		if (!isJsonObject(deps)) continue;
+		const sortedDeps = {};
+		for (const name of Object.keys(deps).sort()) sortedDeps[name] = deps[name];
+		sorted[field] = sortedDeps;
+	}
+	return {
+		...packageJson,
+		...sorted
+	};
+}
+//#endregion
+//#region src/utils/render-template.ts
+function readJsonObject(filePath) {
+	const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+	if (!isJsonObject(parsed)) throw new Error(`${filePath}: expected a JSON object`);
+	return parsed;
+}
+const TYPESCRIPT_ONLY_FILENAMES = /* @__PURE__ */ new Set([
+	"tsconfig.json",
+	"tsconfig.angular.json",
+	"tsconfig.typecheck.json",
+	"App.tsx"
+]);
+function isTypescriptOnlyFile(filename) {
+	return TYPESCRIPT_ONLY_FILENAMES.has(filename) || filename.endsWith(".d.ts");
+}
+const JAVASCRIPT_ONLY_FILENAMES = /* @__PURE__ */ new Set([
+	"App.jsx",
+	"App.vue",
+	"App.svelte",
+	"MenuScreen.vue",
+	"DetailsScreen.vue",
+	"MenuScreen.svelte",
+	"DetailsScreen.svelte"
+]);
+function isJavascriptOnlyFile(filename) {
+	return JAVASCRIPT_ONLY_FILENAMES.has(filename);
+}
+function stripTypescriptInfix(filename) {
+	return filename.replace(".typescript.", ".");
+}
+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);
+		return;
+	}
+	const filename = path.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);
+	if (destFilename === "package.json.fragment.json") {
+		const destPackageJsonPath = path.resolve(path.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`);
+		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}`);
+		return;
+	}
+	fs.copyFileSync(src, resolvedDest);
+}
+//#endregion
+//#region src/utils/apply-bootsplash-logo.ts
+function applyBootsplashLogo(root, templatesRoot, framework) {
+	const overlayRoot = path.join(templatesRoot, "native", "bootsplash-logo", framework);
+	if (fs.existsSync(overlayRoot)) renderTemplate(overlayRoot, root);
+}
+//#endregion
+//#region src/utils/apply-expo-modules-manifest.ts
+const EXPO_MODULES_PERMISSIONS = `  <uses-permission android:name="android.permission.VIBRATE" />
+  <uses-permission android:name="android.permission.USE_FINGERPRINT" />
+  <uses-permission android:name="android.permission.USE_BIOMETRIC" />
+  <!-- @symbiote-native/brightness: setSystemBrightnessAsync/getPermissionsAsync -->
+  <uses-permission android:name="android.permission.WRITE_SETTINGS" />
+  <!-- @symbiote-native/cellular: getCarrierNameAsync/getIsoCountryCodeAsync/etc. -->
+  <uses-permission android:name="android.permission.READ_PHONE_STATE" />`;
+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 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);
+}
+//#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");
+	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);
+}
+//#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");
+	if (!podfile.includes(DEFAULT_PLATFORM_LINE)) return;
+	fs.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"));
+	if (!xcodeproj) return void 0;
+	const pbxprojPath = path.join(iosDir, xcodeproj, "project.pbxproj");
+	return fs.existsSync(pbxprojPath) ? pbxprojPath : void 0;
+}
+function applyExpoModulesXcodeDeploymentTarget(root) {
+	const pbxprojPath = findPbxprojPath(root);
+	if (!pbxprojPath) return;
+	const pbxproj = fs.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);
+}
+//#endregion
+//#region src/utils/apply-splash-screen-hide.ts
+const SKIPPED_DIR_NAMES$1 = /* @__PURE__ */ new Set([
+	"ios",
+	"android",
+	"node_modules"
+]);
+const APP_COMPONENT_FILENAMES$1 = /* @__PURE__ */ new Set([
+	"App.tsx",
+	"App.jsx",
+	"App.ts",
+	"App.vue",
+	"App.svelte"
+]);
+function findAppComponentFile(dir) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (SKIPPED_DIR_NAMES$1.has(entry.name)) continue;
+			const found = findAppComponentFile(entryPath);
+			if (found !== void 0) return found;
+			continue;
+		}
+		if (APP_COMPONENT_FILENAMES$1.has(entry.name)) return entryPath;
+	}
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function insertOrMergeNamedImport(source, moduleSpecifier, name, insertFallback = (src, line) => `${line}\n${src}`) {
+	const importLineRegex = new RegExp(`import \\{ ([^}]*) \\} from '${escapeRegExp(moduleSpecifier)}';`);
+	const match = source.match(importLineRegex);
+	if (match?.[1] !== void 0) {
+		const names = match[1];
+		if (names.split(",").map((n) => n.trim()).includes(name)) return source;
+		return source.replace(importLineRegex, `import { ${names}, ${name} } from '${moduleSpecifier}';`);
+	}
+	return insertFallback(source, `import { ${name} } from '${moduleSpecifier}';`);
+}
+function patchReact(source) {
+	return `import { hide } from '@symbiote-native/splash-screen/react';\n${insertOrMergeNamedImport(source, "react", "useEffect")}`.replace("export default function App() {", "export default function App() {\n  useEffect(() => {\n    hide();\n  }, []);\n");
+}
+function patchSolid(source) {
+	return `import { hide } from '@symbiote-native/splash-screen';\n${insertOrMergeNamedImport(source, "solid-js", "onMount")}`.replace("export default function App() {", "export default function App() {\n  onMount(() => {\n    hide();\n  });\n");
+}
+function patchVueTsx(source) {
+	return `import { hide } from '@symbiote-native/splash-screen/vue';\n${insertOrMergeNamedImport(source, "@vue/runtime-core", "onMounted")}`.replace("setup() {", "setup() {\n    onMounted(() => hide());\n");
+}
+const SCRIPT_OPEN_TAG = /<script setup(?: lang="ts")?>/;
+function patchVueSfc(source) {
+	return insertOrMergeNamedImport(source, "vue", "onMounted", (src, line) => src.replace(SCRIPT_OPEN_TAG, (tag) => `${tag}\n${line}`)).replace("<\/script>", `import { hide } from '@symbiote-native/splash-screen/vue';\nonMounted(() => hide());\n<\/script>`);
+}
+const ANGULAR_CORE_IMPORT = /import \{ ([^}]*) \} from '@angular\/core';/;
+function patchAngular(source) {
+	return source.replace(ANGULAR_CORE_IMPORT, (line, specifiers) => specifiers.includes("OnInit") ? line : `import { ${specifiers}, OnInit } from '@angular/core';`).replace(ANGULAR_CORE_IMPORT, (line) => `${line}\nimport { hide } from '@symbiote-native/splash-screen/angular';`).replace("export class AppComponent {", "export class AppComponent implements OnInit {\n  ngOnInit(): void {\n    hide();\n  }\n");
+}
+function patchSvelte(source) {
+	return source.replace("<\/script>", `  import { hide } from '@symbiote-native/splash-screen/svelte';\n  hide();\n<\/script>`);
+}
+function applySplashScreenAppHide(root, options) {
+	const appFilePath = findAppComponentFile(root);
+	if (appFilePath === void 0) return;
+	const source = fs.readFileSync(appFilePath, "utf8");
+	if (/\bhide\(\)/.test(source)) return;
+	fs.writeFileSync(appFilePath, patch(source, options.framework, appFilePath));
+}
+function patch(source, framework, appFilePath) {
+	switch (framework) {
+		case "react": return patchReact(source);
+		case "solid": return patchSolid(source);
+		case "angular": return patchAngular(source);
+		case "svelte": return patchSvelte(source);
+		case "vue": return appFilePath.endsWith(".vue") ? patchVueSfc(source) : patchVueTsx(source);
+	}
+}
+//#endregion
+//#region src/utils/apply-styling.ts
+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);
+		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 PREPROCESSOR_EXTENSIONS = {
+	scss: "scss",
+	less: "less",
+	stylus: "styl"
+};
+const SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
+	"ios",
+	"android",
+	"node_modules"
+]);
+const APP_COMPONENT_FILENAMES = /* @__PURE__ */ new Set([
+	"App.tsx",
+	"App.jsx",
+	"App.ts",
+	"App.vue",
+	"App.svelte"
+]);
+const STARTER_CSS_CONTENT = `.container {
+  flex: 1;
+  align-items: center;
+  justify-content: center;
+}
+`;
+function findAppComponentDir(dir) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (SKIPPED_DIR_NAMES.has(entry.name)) continue;
+			const found = findAppComponentDir(entryPath);
+			if (found !== void 0) return found;
+			continue;
+		}
+		if (APP_COMPONENT_FILENAMES.has(entry.name)) return dir;
+	}
+}
+function findAppCssFile(dir) {
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		if (entry.isDirectory()) {
+			if (SKIPPED_DIR_NAMES.has(entry.name)) continue;
+			const found = findAppCssFile(path.join(dir, entry.name));
+			if (found !== void 0) return found;
+			continue;
+		}
+		if (entry.name === "App.css") return path.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);
+		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));
+	}
+}
+function renameStylesheetExtension(root, extension) {
+	const cssFile = findAppCssFile(root);
+	if (cssFile === void 0) return;
+	fs.renameSync(cssFile, path.join(path.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 });
+		const orphanedCss = findAppCssFile(root);
+		if (orphanedCss !== void 0) fs.rmSync(orphanedCss, { force: true });
+		if (styling === "css-modules") {
+			const appDir = findAppComponentDir(root);
+			if (appDir !== void 0) fs.writeFileSync(path.join(appDir, "App.module.css"), STARTER_CSS_CONTENT);
+		}
+		return;
+	}
+	if (INLINE_STYLE_BLOCK_FRAMEWORKS.has(jsTemplateDir)) {
+		addStyleLangAttribute(root, styling);
+		renameStylesheetExtension(root, PREPROCESSOR_EXTENSIONS[styling]);
+		return;
+	}
+	renameStylesheetExtension(root, PREPROCESSOR_EXTENSIONS[styling]);
+}
+//#endregion
+//#region src/utils/native-identity.ts
+function sanitizeNativeAppName(appName) {
+	const pascalCase = (appName.match(/[a-zA-Z0-9]+/g) ?? []).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+	return pascalCase === "" || /^[0-9]/.test(pascalCase) ? `App${pascalCase}` : pascalCase;
+}
+function defaultBundleId(nativeAppName) {
+	return `com.${nativeAppName.toLowerCase()}`;
+}
+const BUNDLE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+function isValidBundleId(value) {
+	return BUNDLE_ID_PATTERN.test(value);
+}
+//#endregion
+//#region src/utils/package-name.ts
+function toValidPackageName(name) {
+	return name.trim().toLowerCase().replace(/\s+/g, "-").replace(/^[._]/, "").replace(/[^a-z0-9-~]+/g, "-");
+}
+//#endregion
+//#region src/generate.ts
+var TargetDirNotEmptyError = class extends Error {
+	targetDir;
+	constructor(targetDir) {
+		super(`"${targetDir}" already exists and is not empty.`);
+		this.targetDir = targetDir;
+		this.name = "TargetDirNotEmptyError";
+	}
+};
+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 templatesRoot = resolveTemplatesRoot();
+function isEmptyDir(dir) {
+	if (!fs.existsSync(dir)) return true;
+	const entries = fs.readdirSync(dir);
+	return entries.length === 0 || entries.length === 1 && entries[0] === ".git";
+}
+function scaffoldApp(options) {
+	const root = path.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({
+		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 });
+	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 });
+	}
+	if (hasExpoModules) renderTemplate(path.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);
+	}
+	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.hasTesting) {
+		const testingLayerRoot = path.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 });
+	}
+	if (hasExpoModules) {
+		applyExpoModulesAndroidManifest(root);
+		applyExpoModulesPodfilePlatform(root);
+		applyExpoModulesPodfileAutolinking(root);
+		applyExpoModulesXcodeDeploymentTarget(root);
+	}
+	applyStyling(root, {
+		styling: options.styling,
+		jsTemplateDir,
+		hasNavigation: options.hasNavigation,
+		hasTypescript: options.hasTypescript,
+		templatesRoot
+	});
+	if (options.hasSplashScreen) applySplashScreenAppHide(root, { framework: options.framework });
+	applyAppIdentity(root, {
+		nativeAppName: sanitizeNativeAppName(options.appName),
+		bundleId: options.bundleId
+	});
+	return root;
+}
+//#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);
+}
+//#endregion
+//#region src/utils/apply-expo-modules-plist.ts
+const USAGE_DESCRIPTIONS = [
+	["NSFaceIDUsageDescription", "This app uses Face ID to authenticate you."],
+	["NSMotionUsageDescription", "This app uses motion sensor data."],
+	["NSUserTrackingUsageDescription", "This app tracks your activity across other apps and websites."]
+];
+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 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);
+}
+//#endregion
+//#region src/utils/apply-splash-screen-app-delegate.ts
+const CUSTOMIZE_OPEN = /override func customize\(_ rootView: RCTRootView\) \{\n/;
+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");
+	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`);
+	const withInit = CUSTOMIZE_OPEN.test(updated) ? updated.replace(CUSTOMIZE_OPEN, (match) => `${match}    RNBootSplash.initWithStoryboard("BootSplash", rootView: rootView)\n`) : updated.replace(/class ReactNativeDelegate: RCTDefaultReactNativeFactoryDelegate \{\n/, (match) => `${match}  override func customize(_ rootView: RCTRootView) {\n    super.customize(rootView)
+    RNBootSplash.initWithStoryboard("BootSplash", rootView: rootView)
+  }
+
+`);
+	fs.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);
+		if (entry.isDirectory()) {
+			const found = findMainActivityKt(entryPath);
+			if (found !== void 0) return found;
+			continue;
+		}
+		if (entry.name === "MainActivity.kt") return entryPath;
+	}
+}
+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 mainActivityPath = findMainActivityKt(javaDir);
+	if (mainActivityPath === void 0) return;
+	const source = fs.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);
+}
+//#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 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));
+}
+//#endregion
+//#region src/utils/apply-splash-screen-styles.ts
+const BOOT_THEME_STYLE = `    <style name="BootTheme" parent="Theme.BootSplash">
+        <item name="bootSplashBackground">@color/bootsplash_background</item>
+        <item name="bootSplashLogo">@drawable/bootsplash_logo</item>
+        <item name="postBootSplashTheme">@style/AppTheme</item>
+    </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");
+	if (styles.includes("name=\"BootTheme\"")) return;
+	if (!styles.includes("</resources>")) return;
+	fs.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"));
+}
+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"))) {
+		applyExpoModulesInfoPlist(root);
+		applyExpoModulesPodfilePlatform(root);
+		applyExpoModulesPodfileAutolinking(root);
+		applyExpoModulesXcodeDeploymentTarget(root);
+	}
+}
+function applySplashScreenLayer(root, framework) {
+	applyDependencyOnlyLayer(root, "splash-screen");
+	applySplashScreenManifest(root);
+	applySplashScreenStyles(root);
+	applySplashScreenMainActivity(root);
+	applySplashScreenAppDelegate(root);
+	applySplashScreenAppHide(root, { framework });
+	applyBootsplashLogo(root, templatesRoot, framework);
+}
+async function applyTestingLayer(root, framework, confirmOverwrite) {
+	const testingLayerRoot = path.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 });
+	return true;
+}
+async function addLayersToApp(options) {
+	const appliedLayers = [];
+	const skippedLayers = [];
+	for (const layer of options.layers) {
+		if (layer === "testing") {
+			(await applyTestingLayer(options.root, options.framework, options.confirmTestingOverwrite) ? appliedLayers : skippedLayers).push(layer);
+			continue;
+		}
+		if (layer === "expo-modules") applyExpoModulesLayer(options.root);
+		else if (layer === "splash-screen") applySplashScreenLayer(options.root, options.framework);
+		else applyDependencyOnlyLayer(options.root, layer);
+		appliedLayers.push(layer);
+	}
+	return {
+		appliedLayers,
+		skippedLayers
+	};
+}
+//#endregion
+//#region src/detect-added-layers.ts
+const LAYER_MARKER_DEPENDENCY = [
+	["navigation", "@symbiote-native/navigation"],
+	["expo-modules", "@symbiote-native/expo-modules-link"],
+	["testing", "detox"],
+	["slider", "@symbiote-native/slider"],
+	["splash-screen", "@symbiote-native/splash-screen"],
+	...EXPO_PACKAGE_LAYERS.map((layer) => [layer.id, layer.symbiotePackage])
+];
+function detectAddedLayers(dependencies) {
+	return new Set(LAYER_MARKER_DEPENDENCY.filter(([, dependencyName]) => dependencyName in dependencies).map(([layer]) => layer));
+}
+//#endregion
+//#region src/detect-framework.ts
+const SYMBIOTE_ADAPTER_BY_DEPENDENCY = [
+	["@symbiote-native/angular", "angular"],
+	["@symbiote-native/vue", "vue"],
+	["@symbiote-native/svelte", "svelte"],
+	["@symbiote-native/solid", "solid"],
+	["@symbiote-native/react", "react"]
+];
+function detectSymbioteFrameworkFromDependencies(dependencies) {
+	return SYMBIOTE_ADAPTER_BY_DEPENDENCY.find(([dependencyName]) => dependencyName in dependencies)?.[1];
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStringRecord(value) {
+	if (!isRecord(value)) return {};
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") result[key] = entry;
+	return result;
+}
+function readCwdDependencies(cwd = process.cwd()) {
+	try {
+		const raw = readFileSync(join(cwd, "package.json"), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isRecord(parsed)) return {};
+		return {
+			...toStringRecord(parsed.dependencies),
+			...toStringRecord(parsed.devDependencies)
+		};
+	} catch {
+		return {};
+	}
+}
+//#endregion
+//#region src/get-command.ts
+function getCommand(packageManager, script) {
+	if (script === "install") return packageManager === "yarn" ? "yarn" : `${packageManager} install`;
+	return packageManager === "npm" ? `npm run ${script}` : `${packageManager} ${script}`;
+}
+//#endregion
+//#region src/detect-package-manager.ts
+const USER_AGENT_PREFIXES = [
+	["pnpm", "pnpm"],
+	["yarn", "yarn"],
+	["npm", "npm"]
+];
+function detectPackageManagerFromUserAgent(userAgent = process.env.npm_config_user_agent) {
+	if (userAgent === void 0) return void 0;
+	return USER_AGENT_PREFIXES.find(([prefix]) => userAgent.startsWith(prefix))?.[1];
+}
+//#endregion
+//#region src/prompts.ts
+function assertNotCancelled(answer) {
+	if (isCancel(answer)) {
+		cancel("Cancelled.");
+		process.exit(1);
+	}
+}
+function isInteractive() {
+	return process.stdin.isTTY === true;
+}
+async function resolveAppName(appName) {
+	if (appName !== void 0) return appName;
+	if (!isInteractive()) throw new CliUsageError("No app name given and not running in an interactive terminal — pass it as the first argument, e.g. \"new my-app\".");
+	const answer = await text({
+		message: "App name?",
+		placeholder: "my-app"
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+async function resolveFramework(framework) {
+	if (framework !== void 0) return framework;
+	if (!isInteractive()) throw new CliUsageError("No --framework given and not running in an interactive terminal — pass --framework react|vue|angular|solid|svelte.");
+	const answer = await select({
+		message: "Which framework?",
+		options: [
+			{
+				value: "react",
+				label: "React"
+			},
+			{
+				value: "vue",
+				label: "Vue"
+			},
+			{
+				value: "angular",
+				label: "Angular"
+			},
+			{
+				value: "solid",
+				label: "Solid"
+			},
+			{
+				value: "svelte",
+				label: "Svelte"
+			}
+		]
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+async function resolveVueFlavor(vueFlavor) {
+	if (vueFlavor !== void 0) return vueFlavor;
+	if (!isInteractive()) throw new CliUsageError("No --vue-flavor given and not running in an interactive terminal — pass --vue-flavor tsx|sfc.");
+	const answer = await select({
+		message: "Vue: TSX or SFC (.vue) components?",
+		options: [{
+			value: "sfc",
+			label: "SFC (.vue single-file components)"
+		}, {
+			value: "tsx",
+			label: "TSX (JSX-flavored, no .vue files)"
+		}]
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+async function resolveBundleId(bundleId, nativeAppName) {
+	if (bundleId !== void 0) {
+		if (!isValidBundleId(bundleId)) throw new Error(`Invalid --bundle-id "${bundleId}": reverse-DNS only (letters, digits, underscores, dots) — e.g. "com.example.app".`);
+		return bundleId;
+	}
+	const computedDefault = defaultBundleId(nativeAppName);
+	if (!isInteractive()) return computedDefault;
+	const answer = await text({
+		message: "Bundle identifier (iOS + Android)?",
+		initialValue: computedDefault,
+		validate: (value) => isValidBundleId(value ?? "") ? void 0 : "Reverse-DNS only: letters, digits, underscores, dots — e.g. \"com.example.app\"."
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+async function resolveOverwrite(targetDir, force) {
+	if (force) return true;
+	if (!isInteractive()) throw new CliUsageError(`"${targetDir}" already exists and is not empty, and not running in an interactive terminal — pass --force to overwrite it, or scaffold into an empty directory.`);
+	const answer = await confirm({
+		message: `"${targetDir}" already exists and is not empty. Empty it and continue?`,
+		initialValue: false
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+async function resolveStyling(styling) {
+	if (styling !== void 0) return styling;
+	if (!isInteractive()) return "css";
+	const answer = await select({
+		message: "How should the app style itself?",
+		options: [
+			{
+				value: "css",
+				label: "CSS classes",
+				hint: "plain .css, recommended"
+			},
+			{
+				value: "css-modules",
+				label: "CSS Modules",
+				hint: "scoped .module.css classes"
+			},
+			{
+				value: "scss",
+				label: "SCSS"
+			},
+			{
+				value: "less",
+				label: "LESS"
+			},
+			{
+				value: "stylus",
+				label: "Stylus"
+			},
+			{
+				value: "stylesheet",
+				label: "StyleSheet.create",
+				hint: "JS style objects"
+			}
+		],
+		initialValue: "css"
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+async function resolveFeatures(framework, flags) {
+	if (framework === "angular" && flags.isJavascript) throw new CliUsageError("--framework angular requires TypeScript — drop --javascript.");
+	const typescriptForced = framework === "angular" ? true : flags.isJavascript ? false : void 0;
+	const options = [
+		...typescriptForced === void 0 ? [{
+			value: "typescript",
+			label: "TypeScript"
+		}] : [],
+		...flags.hasNavigation ? [] : [{
+			value: "navigation",
+			label: "Navigation",
+			hint: "@symbiote-native/navigation"
+		}],
+		...flags.hasExpoModules ? [] : [{
+			value: "expo-modules",
+			label: "Expo-modules autolinking",
+			hint: "@symbiote-native/expo-modules-link"
+		}],
+		...flags.hasTesting ? [] : [{
+			value: "testing",
+			label: "E2E testing",
+			hint: "Detox"
+		}],
+		...flags.hasSplashScreen ? [] : [{
+			value: "splash-screen",
+			label: "Splash screen",
+			hint: "@symbiote-native/splash-screen"
+		}],
+		...flags.hasSlider ? [] : [{
+			value: "slider",
+			label: "Slider",
+			hint: "@symbiote-native/slider"
+		}],
+		...EXPO_PACKAGE_LAYERS.filter((layer) => !flags.expoPackages.has(layer.id)).map((layer) => ({
+			value: layer.id,
+			label: layer.label,
+			hint: layer.symbiotePackage
+		}))
+	];
+	if (options.length === 0 || !isInteractive()) return {
+		hasTypescript: typescriptForced ?? true,
+		hasNavigation: flags.hasNavigation,
+		hasExpoModules: flags.hasExpoModules || flags.expoPackages.size > 0,
+		hasTesting: flags.hasTesting,
+		hasSplashScreen: flags.hasSplashScreen,
+		hasSlider: flags.hasSlider,
+		expoPackages: flags.expoPackages
+	};
+	const answer = await multiselect({
+		message: "Which features?",
+		options,
+		initialValues: typescriptForced === void 0 ? ["typescript"] : [],
+		required: false
+	});
+	assertNotCancelled(answer);
+	const selected = new Set(answer);
+	const expoPackages = /* @__PURE__ */ new Set([...flags.expoPackages, ...EXPO_PACKAGE_LAYERS.filter((layer) => selected.has(layer.id)).map((layer) => layer.id)]);
+	return {
+		hasTypescript: typescriptForced ?? selected.has("typescript"),
+		hasNavigation: flags.hasNavigation || selected.has("navigation"),
+		hasExpoModules: flags.hasExpoModules || selected.has("expo-modules") || expoPackages.size > 0,
+		hasTesting: flags.hasTesting || selected.has("testing"),
+		hasSplashScreen: flags.hasSplashScreen || selected.has("splash-screen"),
+		hasSlider: flags.hasSlider || selected.has("slider"),
+		expoPackages
+	};
+}
+async function resolveAddOverwrite(hasForce, message) {
+	if (hasForce) return true;
+	if (!isInteractive()) return false;
+	const answer = await confirm({
+		message,
+		initialValue: false
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+const ADD_LAYER_OPTIONS = [
+	{
+		value: "navigation",
+		label: "Navigation",
+		hint: "@symbiote-native/navigation"
+	},
+	{
+		value: "expo-modules",
+		label: "Expo-modules autolinking",
+		hint: "@symbiote-native/expo-modules-link"
+	},
+	{
+		value: "testing",
+		label: "E2E testing",
+		hint: "Detox"
+	},
+	{
+		value: "splash-screen",
+		label: "Splash screen",
+		hint: "@symbiote-native/splash-screen"
+	},
+	{
+		value: "slider",
+		label: "Slider",
+		hint: "@symbiote-native/slider"
+	},
+	...EXPO_PACKAGE_LAYERS.map((layer) => ({
+		value: layer.id,
+		label: layer.label,
+		hint: layer.symbiotePackage
+	}))
+];
+function explicitLayersFromFlags(flags) {
+	const explicit = [];
+	if (flags.hasNavigation) explicit.push("navigation");
+	if (flags.hasExpoModules) explicit.push("expo-modules");
+	if (flags.hasTesting) explicit.push("testing");
+	if (flags.hasSplashScreen) explicit.push("splash-screen");
+	if (flags.hasSlider) explicit.push("slider");
+	explicit.push(...flags.expoPackages ?? []);
+	return explicit;
+}
+function buildAddLayerOptions(alreadyAdded) {
+	const withDisabledState = ADD_LAYER_OPTIONS.map((option) => {
+		const isAlreadyAdded = alreadyAdded.has(option.value);
+		return {
+			...option,
+			hint: isAlreadyAdded ? "already added" : option.hint,
+			disabled: isAlreadyAdded
+		};
+	});
+	return {
+		"Core layers": withDisabledState.filter((option) => !isExpoPackageLayerName(option.value)),
+		"Expo packages": withDisabledState.filter((option) => isExpoPackageLayerName(option.value))
+	};
+}
+function withImpliedExpoModules(layers) {
+	return layers.some((layer) => isExpoPackageLayerName(layer)) && !layers.includes("expo-modules") ? [...layers, "expo-modules"] : [...layers];
+}
+function dropAlreadyAdded(layers, alreadyAdded, hasForce) {
+	return hasForce ? [...layers] : layers.filter((layer) => !alreadyAdded.has(layer));
+}
+async function resolveAddLayers(flags, alreadyAdded, hasForce = false) {
+	const explicit = explicitLayersFromFlags(flags);
+	if (explicit.length > 0) return withImpliedExpoModules(dropAlreadyAdded(explicit, alreadyAdded, hasForce));
+	if (ADD_LAYER_OPTIONS.every((option) => alreadyAdded.has(option.value))) return [];
+	if (!isInteractive()) throw new CliUsageError("No layer flags given and not running in an interactive terminal — pass at least one of --navigation/--expo-modules/--testing/--splash-screen/--slider, or an Expo-package flag such as --battery/--sensors.");
+	const answer = await groupMultiselect({
+		message: "Which features to add?",
+		options: buildAddLayerOptions(alreadyAdded),
+		required: false
+	});
+	assertNotCancelled(answer);
+	return withImpliedExpoModules(dropAlreadyAdded(answer, alreadyAdded, hasForce));
+}
+async function resolvePackageManager(packageManager) {
+	const detected = packageManager ?? detectPackageManagerFromUserAgent();
+	if (detected !== void 0) return detected;
+	if (!isInteractive()) return "npm";
+	const answer = await select({
+		message: "Which package manager?",
+		options: [
+			{
+				value: "npm",
+				label: "npm"
+			},
+			{
+				value: "pnpm",
+				label: "pnpm"
+			},
+			{
+				value: "yarn",
+				label: "yarn"
+			}
+		]
+	});
+	assertNotCancelled(answer);
+	return answer;
+}
+//#endregion
+//#region src/commands/add.ts
+function resolveFrameworkForAdd(explicit, cwd = process.cwd()) {
+	const detected = detectSymbioteFrameworkFromDependencies(readCwdDependencies(cwd));
+	if (detected === void 0) throw new NotSymbioteAppError();
+	if (explicit !== void 0 && explicit !== detected) throw new CliUsageError(`--framework ${explicit} was given, but this project's package.json declares @symbiote-native/${detected} — pass --framework ${detected} or omit the flag.`);
+	return detected;
+}
+async function runAdd(parsed) {
+	intro("@symbiote-native/cli add");
+	const cwd = process.cwd();
+	const framework = resolveFrameworkForAdd(parsed.framework, cwd);
+	const alreadyAdded = detectAddedLayers(readCwdDependencies(cwd));
+	const layerFlags = {
+		hasExpoModules: parsed.hasExpoModules,
+		hasNavigation: parsed.hasNavigation,
+		hasTesting: parsed.hasTesting,
+		hasSlider: parsed.hasSlider,
+		hasSplashScreen: parsed.hasSplashScreen,
+		expoPackages: parsed.expoPackages
+	};
+	const layers = await resolveAddLayers(layerFlags, alreadyAdded, parsed.hasForce);
+	const alreadyPresentSkips = parsed.hasForce ? [] : explicitLayersFromFlags(layerFlags).filter((layer) => alreadyAdded.has(layer));
+	if (layers.length === 0) {
+		const outro$1 = alreadyPresentSkips.length > 0 ? `Nothing to add — already present: ${alreadyPresentSkips.join(", ")}.` : "Nothing to add — every optional layer @symbiote-native/cli offers is already present.";
+		outro(outro$1);
+		return;
+	}
+	const result = await addLayersToApp({
+		root: cwd,
+		framework,
+		layers,
+		confirmTestingOverwrite: () => resolveAddOverwrite(parsed.hasForce, "\"detox.config.js\" / \"e2e/\" already exist. Overwrite them?")
+	});
+	const lines = [];
+	if (result.appliedLayers.length > 0) {
+		const packageManager = await resolvePackageManager(parsed.packageManager);
+		lines.push(`Added: ${result.appliedLayers.join(", ")}.`, "", import_picocolors.default.bold(import_picocolors.default.green(`  ${getCommand(packageManager, "install")}`)));
+	}
+	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}';`));
+	outro(lines.length > 0 ? lines.join("\n") : "Nothing changed.");
+}
+//#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);
+	if (!isEmptyDir(targetDir)) {
+		if (!await resolveOverwrite(targetDir, parsed.hasForce)) {
+			cancel("Cancelled.");
+			process.exit(1);
+		}
+		fs.rmSync(targetDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	const framework = await resolveFramework(parsed.framework);
+	const vueFlavor = framework === "vue" ? await resolveVueFlavor(parsed.vueFlavor) : void 0;
+	const bundleId = await resolveBundleId(parsed.bundleId, sanitizeNativeAppName(appName));
+	const { hasTypescript, hasNavigation, hasExpoModules, hasTesting, hasSplashScreen, hasSlider, expoPackages } = await resolveFeatures(framework, parsed);
+	const styling = await resolveStyling(parsed.styling);
+	const packageManager = await resolvePackageManager(parsed.packageManager);
+	const root = scaffoldApp({
+		appName,
+		framework,
+		vueFlavor,
+		hasTypescript,
+		bundleId,
+		hasExpoModules,
+		hasNavigation,
+		hasTesting,
+		hasSplashScreen,
+		hasSlider,
+		expoPackages,
+		styling,
+		packageManager
+	});
+	const hasGitDir = fs.existsSync(path.join(root, ".git"));
+	outro([
+		`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"));
+}
+//#endregion
+//#region package.json
+var version = "0.0.1";
+//#endregion
+//#region src/index.ts
+function printHelp() {
+	const expoPackageFlags = EXPO_PACKAGE_LAYERS.map((layer) => `--${layer.id}`).join(", ");
+	console.log(`@symbiote-native/cli — scaffold a SymbioteNative app, or add it to an existing one.
+
+Usage:
+  npx @symbiote-native/cli new <app-name> [--framework react|vue|angular|solid|svelte] [--vue-flavor tsx|sfc]
+                      [--javascript] [--force] [--bundle-id com.example.app]
+                      [--styling css|css-modules|scss|less|stylus|stylesheet]
+                      [--navigation] [--expo-modules] [--testing] [--splash-screen] [--slider] [--pm npm|pnpm|yarn]
+                      [--<expo-package> ...]  (one per Expo-backed package, implies --expo-modules)
+  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 --version   print the CLI version
+  npx @symbiote-native/cli --help      print this message
+
+<expo-package> flags: ${expoPackageFlags}
+
+Flags left out of either command are asked for interactively.`);
+}
+async function main() {
+	const parsed = parseArgv(process.argv.slice(2));
+	switch (parsed.kind) {
+		case "new":
+			await runNew(parsed);
+			return;
+		case "add":
+			await runAdd(parsed);
+			return;
+		case "help":
+			printHelp();
+			return;
+		case "version":
+			console.log(version);
+			return;
+	}
+}
+main().catch((error) => {
+	if (error instanceof CliUsageError) {
+		console.error(import_picocolors.default.red(`@symbiote-native/cli: ${error.message}`));
+		process.exitCode = 1;
+		return;
+	}
+	if (error instanceof NotSymbioteAppError) {
+		console.error(import_picocolors.default.red(`@symbiote-native/cli: ${error.message}`));
+		process.exitCode = 1;
+		return;
+	}
+	console.error(import_picocolors.default.red("@symbiote-native/cli: unexpected error"), error);
+	process.exitCode = 1;
+});
+//#endregion
+export {};